Thinktomorrow\AssetLibrary\Models\Asset::upload()

Complexity

Conditions	4
Paths	3

Size

Total Lines	24
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	4

Importance

Changes	2
Bugs	1	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	Asset::attachToModel()	0	16	4
A	Asset::hasFile()	0	4	1

<?php

namespace Thinktomorrow\AssetLibrary\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\File;
use Illuminate\Http\UploadedFile;
use Spatie\MediaLibrary\HasMedia\HasMediaTrait;
use Spatie\MediaLibrary\HasMedia\Interfaces\HasMediaConversions;
use Spatie\MediaLibrary\Media;
use Thinktomorrow\Locale\Locale;

class Asset extends Model implements HasMediaConversions
{
    use HasMediaTrait;

    /**
     * Attaches this asset instance to the given model and
     * sets the type and locale to the given values and
     * returns the model with the asset relationship.
     *
     * @param Model $model
     * @param string $type
     * @param null|string $locale
     * @return Model
     */
    public function attachToModel(Model $model, $type = '', $locale = null)
    {
        $asset = $model->assets->where('pivot.type', $type)->where('pivot.locale', $locale);

        if (! $asset->isEmpty() && $asset->first()->pivot->type !== '') {
            $model->assets()->detach($asset->first()->id);
        }

        if (! $locale) {

The expression $locale of type null|string is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            $locale = Locale::getDefault();
        }

        $model->assets()->attach($this, ['type' => $type, 'locale' => $locale]);

        return $model->load('assets');
    }

    public function hasFile()
    {
        return (bool) $this->getFileUrl('');
    }

    public function getFilename($size = '')
    {
        return basename($this->getFileUrl($size));
    }

    /**
     * @return string
     */
    public function getFileUrl($size = '')
    {
        $media = $this->getMedia();

        if ($media->count() < 1) {
            return asset('assets/back/img/other.png');
        }

        if (config('assetlibrary.conversionPrefix') && $size != '') {
            $conversionName = $media->first()->name . '_' . $size;
        } else {
            $conversionName = $size;
        }

        return $media->first()->getUrl($conversionName);
    }

    /**
     * Returns the image url or a fallback specific per filetype.
     *
     * @param string $type
     * @return string
     */
    public function getImageUrl($type = '')
    {
        if ($this->getMedia()->isEmpty()) {
            return asset('assets/back/img/other.png');
        }
        $extension = $this->getExtensionType();
        if ($extension === 'image') {
            return $this->getFileUrl($type);
        } elseif ($extension) {

The expression $extension of type string|false is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

            return asset('assets/back/img/'.$extension.'.png');
        }

        return asset('assets/back/img/other.png');
    }

    public function getExtensionForFilter()
    {
        if ($extension = $this->getExtensionType()) {
            return $extension;
        }

        return '';
    }

    public function getExtensionType()
    {
        $extension = explode('.', $this->getMedia()[0]->file_name);
        $extension = end($extension);

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

        return false;
    }

    public function getMimeType()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->isMediaEmpty() ? '' : $this->getMedia()[0]->mime_type;
    }

    public function isMediaEmpty()
    {
        return $this->getMedia()->isEmpty();
    }

    public function getSize()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->isMediaEmpty() ? '' : $this->getMedia()[0]->human_readable_size;
    }

    public function getDimensions()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->isMediaEmpty() ? '' : $this->getMedia()[0]->getCustomProperty('dimensions');
    }

    /**
     * Removes one or more assets by their ids.
     * @param $image_ids
     */
    public static function remove($image_ids)

The parameter $image_ids is not named in camelCase.

    {
        if (is_array($image_ids)) {
            foreach ($image_ids as $id) {
                self::where('id', $id)->first()->delete();
            }
        } else {
            self::find($image_ids)->first()->delete();
        }
    }

    /**
     * Returns a collection of all the assets in the library.
     * @return \Illuminate\Support\Collection
     */
    public static function getAllAssets()
    {
        return self::all()->sortByDesc('created_at');
    }

    /**
     * Generates the hidden field that links the file to a specific type.
     *
     * @param string $type
     * @param null $locale
     *
     * @return string
     */
    public static function typeField($type = '', $locale = null, $name = 'type')
    {
        $result = '<input type="hidden" value="'.$type.'" name="';

        if (! $locale) {
            return $result.$name.'">';
        }

        return $result.'trans['.$locale.'][files][]">';
    }

    /**
     * Generates the hidden field that links the file to translations.
     *
     * @param string $locale
     *
     * @return string
     */
    public static function localeField($locale = '')
    {
        return self::typeField($locale, null, 'locale');
    }

    /**
     * Register the conversions that should be performed.
     *
     * @param Media|null $media
     * @return array

Should the return type not be array|null? Also, consider making the array more specific, something like array<String>, or String[].

     */
    public function registerMediaConversions(Media $media = null)
    {
        $conversions        = config('assetlibrary.conversions');
        $conversionPrefix   = config('assetlibrary.conversionPrefix');

        foreach ($conversions as $key => $value) {
            if ($conversionPrefix) {
                $conversionName = $media->name.'_'.$key;
            } else {
                $conversionName = $key;
            }

            $this->addMediaConversion($conversionName)
                ->width($value['width'])
                ->height($value['height'])
                ->sharpen(15)
                ->keepOriginalImageFormat()
                ->optimize();
        }
    }
}