%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /var/www/html/diaspora/api/app/Models/
Upload File :
Create Path :
Current File : /var/www/html/diaspora/api/app/Models/Post.php

<?php

namespace App\Models;

use App\Jobs\NotifyUsersForNewPostCreatedJob;
use Carbon\Carbon;
use Dimsav\Translatable\Translatable;
use Spatie\MediaLibrary\Exceptions\FileCannotBeAdded;
use Spatie\MediaLibrary\Exceptions\FileCannotBeAdded\InvalidBase64Data;
use Spatie\MediaLibrary\HasMedia\HasMedia;
use Spatie\MediaLibrary\HasMedia\HasMediaTrait;
use Spatie\MediaLibrary\Models\Media;

/**
 * @property integer id
 * @property string title
 * @property string short_desc
 * @property string content
 * @property integer read_count
 * @property integer author_id
 * @property integer country_id
 * @property integer category_id
 * @property string status
 * @property string video_type
 * @property string video_url
 * @property User author
 * @property Category category
 * @property Country country
 * @property mixed published_at
 * @property mixed created_at
 * @property mixed updated_at
 * @property mixed activities
 * @property mixed categories
 */
class Post extends BaseModel implements HasMedia
{
    use HasMediaTrait, Translatable;

    const AVATAR = 'posts';
    const AVATAR_DISK = 'posts';

    const DRAFT = 'DRAFT';
    const PUBLISHED = 'PUBLISHED';
    const ARCHIVED = 'ARCHIVED';

    const NO_VIDEO = 'NO_VIDEO';
    const VIDEO_VIMEO = 'VIMEO';
    const VIDEO_YOUTUBE = 'YOUTUBE';

    public $translatedAttributes = [
        'title',
        'short_desc',
        'content',
    ];

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'title',
        'read_count',
        'content',
        'status',
        'video_type',
        'video_url',
        'published_at',
    ];

    protected $dates = [
        'published_at',
    ];

    protected $guarded = [
        'author_id',
        'category_id',
    ];

    protected $casts = [
        'id'           => 'integer',
        'title'        => 'string',
        'short_desc'   => 'string',
        'content'      => 'string',
        'author_id'    => 'integer',
        'read_count'   => 'integer',
        'category_id'  => 'integer',
        'status'       => 'string',
        'video_type'   => 'string',
        'video_url'    => 'string',
        'published_at' => 'dateTime',

    ];

    public static function getAvailableValidationVideoTypes()
    {
        return implode(',', [
            self::VIDEO_VIMEO,
            self::VIDEO_YOUTUBE,
        ]);
    }

    public function author()
    {
        return $this->belongsTo(User::class, 'author_id');
    }

    public function category()
    {
        return $this->belongsTo(Category::class);
    }

    public function categories()
    {
        return $this->belongsToMany(Category::class);
    }

    public function country()
    {
        return $this->belongsTo(Country::class);
    }

    public function registerMediaCollections()
    {
        $this->addMediaCollection(self::AVATAR)
             ->useDisk(self::AVATAR_DISK);
    }

    /**
     * @param $baseImage
     *
     * @return Media
     * @throws FileCannotBeAdded
     * @throws InvalidBase64Data
     */
    public function uploadImage($baseImage)
    {
        $name = md5(time());
        try {
            $media = $this->addMediaFromBase64($baseImage)
                          ->usingName($name)
                          ->usingFileName("$name.png")
                          ->toMediaCollection(self::AVATAR);
            $this->featureMedia($media);
            return $media;
        } catch (InvalidBase64Data $e) {
            throw $e;
        } catch (FileCannotBeAdded $e) {
            throw $e;
        }
    }

    public function featureMedia(Media $media)
    {
        $this->media()
             ->where('id', '!=', $media->id)
             ->get()
             ->each(function (Media $m) {
                 if ($m->hasCustomProperty('is_featured')) {
                     $m->delete();
                 }
             });
        $media->setCustomProperty('is_featured', true);
        $media->save();
        return $this;
    }

    public function publish()
    {
        $this->status = self::PUBLISHED;
        $this->published_at = Carbon::now();
        $this->save();
        dispatch(new NotifyUsersForNewPostCreatedJob($this));
        return $this;
    }

    public function archive()
    {
        $this->status = self::ARCHIVED;
        $this->save();
        return $this;
    }

    public function isPublished()
    {
        return $this->status === self::PUBLISHED;
    }

    public function isArchived()
    {
        return $this->status === self::ARCHIVED;
    }

    public function getFeaturedImage()
    {
        $media = $this->media()
                      ->get();
        $featured = null;

        /** @var Media $item */
        foreach ($media as $item) {
            if ($item->hasCustomProperty('is_featured')) {
                $featured = $item;
            }
        }

        if (!$featured) {
            $featured = $this->media()
                             ->first();
        }

        if ($featured) {
            return asset($featured->getUrl());
        }

        return null;
    }

    public function getCarouselImages()
    {
        $media = $this->media()
                      ->get();
        $carousel = collect();
        /** @var Media $item */
        foreach ($media as $item) {
            if (!$item->hasCustomProperty('is_featured')) {
                $carousel->push($item);
            }
        }

        return $carousel;
    }

    public function wasRead()
    {
        $this->read_count++;
        $this->save();
    }

    public function canBePublished()
    {
        return $this->translations()
                    ->count() === 2;
    }

    public function unArchive()
    {
        $this->status = self::DRAFT;
        $this->save();
        return $this;
    }

    public function activities()
    {
        return $this->morphMany(ActivityLog::class, 'subject')
                    ->orderBy(self::CREATED_AT, 'desc');
    }

    public function createNotification(Device $device)
    {
        /** @var User $user */
        $user = $device->user;
        if ($user) {
            Notification::query()
                        ->updateOrCreate([
                            'user_id'    => $user->id,
                            'model_id'   => $this->id,
                            'model_type' => 'Post',
                        ], [
                            'user_id'     => $user->id,
                            'model_id'    => $this->id,
                            'model_type'  => 'Post',
                            'is_read'     => false,
                            'description' => 'POST_PUBLISHED',
                        ]);
        }
    }

}

Zerion Mini Shell 1.0