Thinktomorrow\AssetLibrary\Asset

Complexity

Total Complexity

44

Size/Duplication

Total Lines	271
Duplicated Lines	0 %

Test Coverage

Coverage

96.97%

Importance

Changes	4
Bugs	0	Features	1

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getExtensionForFilter()	0	7	2
A	url()	0	9	2
A	exists()	0	3	1
A	filename()	0	3	1
A	hasFile()	0	3	2
A	getSize()	0	3	2
B	getExtensionType()	0	29	7
A	getHeight()	0	23	5
A	getWidth()	0	23	5
A	isMediaEmpty()	0	3	1
A	isImage()	0	3	1
A	crop()	0	14	2
A	getDimensions()	0	23	6
A	getMimeType()	0	3	2
A	isUsed()	0	5	1
A	registerMediaConversions()	0	16	3
A	isUnused()	0	5	1

<?php

namespace Thinktomorrow\AssetLibrary;

use Illuminate\Support\Str;
use Illuminate\Support\Facades\DB;
use Spatie\MediaLibrary\InteractsWithMedia;
use Spatie\MediaLibrary\MediaCollections\Models\Media;
use Illuminate\Database\Eloquent\Model;
use Spatie\MediaLibrary\HasMedia;
use Thinktomorrow\AssetLibrary\Exceptions\ConfigException;
use Thinktomorrow\AssetLibrary\Exceptions\CorruptMediaException;

class Asset extends Model implements HasMedia
{
    use InteractsWithMedia;

The trait Spatie\MediaLibrary\InteractsWithMedia requires some properties which are not provided by Thinktomorrow\AssetLibrary\Asset: $fallbackPath, $mediaConversionRegistrations, $forceDeleting, $fallbackUrl, $media, $collection_name

    private $order;

The private property $order is not used, and could be removed.

    /**
     * @return bool
     */
    public function hasFile(): bool
    {
        return ($this->getFirstMediaPath() && file_exists($this->getFirstMediaPath()));
    }

    /**
     * @param string $size
     * @return string
     */
    public function filename($size = ''): string
    {
        return basename($this->getFirstMediaPath('default', $size));
    }

    public function exists(): bool
    {
        return true;
    }

    /**
     * @param string $size
     * @return string
     */
    public function url($size = ''): string
    {
        $media = $this->getFirstMedia();

        if ($media == null) {
            return '';
        }

        return $media->getUrl($size);
    }

    /**
     * @return bool|string
     */
    public function getExtensionForFilter()
    {
        if ($extension = $this->getExtensionType()) {
            return $extension;
        }

        return '';
    }

    /**
     * @return null|string
     * @throws CorruptMediaException
     */
    public function getExtensionType(): ?string
    {
        $media = $this->getMedia()->first();

        if ($media == null) {
            throw CorruptMediaException::missingMediaRelation($this->id);
        }

        $extension = explode('.', $media->file_name);
        $extension = end($extension);

        // Remove any appends (query)
        if(strpos($extension, '?')) {
            $extension = substr($extension, 0, strpos($extension, '?'));
        }

        if ($extension) {
            if (in_array(strtolower($extension), ['xls', 'xlsx', 'numbers', 'sheets'])) {
                return 'xls';
            }
            if (in_array(strtolower($extension), ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp'])) {
                return 'image';
            }
            if (strtolower($extension) === 'pdf') {
                return 'pdf';
            }
        }

        return null;
    }

    /**
     * @return string
     */
    public function getMimeType(): string
    {
        return $this->isMediaEmpty() ? '' : $this->getMedia()[0]->mime_type;
    }

    /**
     * @return bool
     */
    public function isMediaEmpty(): bool
    {
        return $this->getMedia()->isEmpty();
    }

    /**
     * @return string
     */
    public function getSize(): string
    {
        return $this->isMediaEmpty() ? '' : $this->getMedia()[0]->human_readable_size;
    }

    /**
     * @param string|null $size
     * @return string
     */
    public function getDimensions($size = null): string
    {
        if ($this->isMediaEmpty()) {
            return '';
        }

        //TODO Check the other sizes as well
        if ($size === 'cropped') {
            $dimensions = explode(',', $this->getMedia()[0]->manipulations['cropped']['manualCrop']);

            return $dimensions[0].' x'.$dimensions[1];
        }

        $dimensions = '';
        $file_path = $this->getFirstMediaPath('default', $size??'');
        if (self::isImage($this->getMedia()[0]) && file_exists($file_path)) {

            if($imagesize = getimagesize($file_path)) {
                $dimensions = $imagesize[0].' x '.$imagesize[1];
            }
        }

        return $dimensions;
    }

    /**
     * @param string|null $size
     * @return string
     */
    public function getWidth($size = null): string
    {
        if ($this->isMediaEmpty()) {
            return '';
        }

        //TODO Check the other sizes as well
        if ($size === 'cropped') {
            $width = explode(',', $this->getMedia()[0]->manipulations['cropped']['manualCrop']);

            return $width[0];
        }

        $width = '';
        $file_path = $this->getFirstMediaPath('default', $size??'');
        if (self::isImage($this->getMedia()[0]) && file_exists($file_path)) {

            $imagesize = getimagesize($file_path);

            $width = $imagesize[0];
        }

        return $width;
    }

    /**
     * @param string|null $size
     * @return string
     */
    public function getHeight($size = null): string
    {
        if ($this->isMediaEmpty()) {
            return '';
        }

        //TODO Check the other sizes as well
        if ($size === 'cropped') {
            $height = explode(',', $this->getMedia()[0]->manipulations['cropped']['manualCrop']);

            return trim($height[1]);
        }

        $height = '';
        $file_path = $this->getFirstMediaPath('default', $size??'');
        if (self::isImage($this->getMedia()[0]) && file_exists($file_path)) {

            $imagesize = getimagesize($file_path);

            $height = $imagesize[1];
        }

        return $height;
    }


    /**
     * @param UploadedFile $file

The type Thinktomorrow\AssetLibrary\UploadedFile was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return bool
     */
    private static function isImage($file): bool
    {
        return Str::before($file->mime_type, '/') === 'image';
    }

    public function isUsed()
    {
        $pivots = DB::table('asset_pivots')->where('asset_id', $this->id)->where('unused', false)->get();

        return ! $pivots->isEmpty();
    }

    public function isUnused()
    {
        $pivots = DB::table('asset_pivots')->where('asset_id', $this->id)->where('unused', false)->get();

        return $pivots->isEmpty();
    }

    /**
     * @param $width
     * @param $height
     * @param $x
     * @param $y
     * @return $this
     * @throws ConfigException
     */
    public function crop($width, $height, $x, $y)
    {
        if (! config('thinktomorrow.assetlibrary.allowCropping')) {
            throw ConfigException::croppingDisabled();
        }
        $this->media[0]->manipulations = [

The property media does not seem to exist on Thinktomorrow\AssetLibrary\Asset. Are you sure there is no database migration missing?

            'cropped'   => [
                'manualCrop' => $width.', '.$height.', '.$x.', '.$y,
            ],
        ];

        $this->media[0]->save();

        return $this;
    }

    /**
     * Register the conversions that should be performed.
     *
     * @param Media|null $media
     * @throws \Spatie\Image\Exceptions\InvalidManipulation
     */
    public function registerMediaConversions(Media $media = null): void
    {
        $conversions = config('thinktomorrow.assetlibrary.conversions');

        foreach ($conversions as $key => $value) {
            $this->addMediaConversion($key)
                ->width($value['width'])
                ->height($value['height'])
                ->keepOriginalImageFormat()
                ->optimize();
        }

        if (config('thinktomorrow.assetlibrary.allowCropping')) {
            $this->addMediaConversion('cropped')
                ->keepOriginalImageFormat()
                ->optimize();
        }
    }
}