Hideyo\Ecommerce\Framework\Services\Content\ContentService

Complexity

Total Complexity

40

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getImageModel()	0	3	1
A	selectAllGroups()	0	3	1
A	findGroup()	0	3	1
A	updateGroupById()	0	11	2
A	rulesGroup()	0	12	2
A	destroy()	0	15	3
B	createImage()	0	53	7
A	updateImageEntity()	0	8	2
A	destroyGroup()	0	6	1
A	destroyImage()	0	20	5
A	createGroup()	0	15	2
A	updateGroupEntity()	0	8	2
A	updateImageById()	0	5	1
A	getGroupModel()	0	3	1
A	rules()	0	17	3
A	create()	0	13	2
A	updateById()	0	16	3
A	__construct()	0	3	1

<?php

namespace Hideyo\Ecommerce\Framework\Services\Content;

use Validator;
use File;
use Hideyo\Ecommerce\Framework\Services\Content\Entity\ContentRepository;
use Hideyo\Ecommerce\Framework\Services\BaseService;
 
class ContentService extends BaseService
{
	public function __construct(ContentRepository $taxRate)
	{
		$this->repo = $taxRate;

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

	} 

    /**
     * The validation rules for the model.
     *
     * @param  integer  $id id attribute model    
     * @return array
     */
    public function rules($contentId = false, $attributes = false)
    {
        if (isset($attributes['seo'])) {
            $rules = array(
                'meta_title'                 => 'required|between:4,65|unique_with:'.$this->repo->getModel()->getTable().', shop_id'
            );
        } else {
            $rules = array(
                'title'                 => 'required|between:4,65|unique_with:'.$this->repo->getModel()->getTable().', shop_id'
            );
            
            if ($contentId) {
                $rules['title'] =   'required|between:4,65|unique_with:'.$this->repo->getModel()->getTable().', shop_id, '.$contentId.' = id';
            }
        }

        return $rules;
    }

    public function create(array $attributes)
    {
        $attributes['shop_id'] = auth('hideyobackend')->user()->selected_shop_id;

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

        $validator = Validator::make($attributes, $this->rules());

        if ($validator->fails()) {
            return $validator;
        }

        $attributes['modified_by_user_id'] = auth('hideyobackend')->user()->id;

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

        $this->repo->getModel()->fill($attributes);
        $this->repo->getModel()->save();
        return $this->repo->getModel();
    }

    public function updateById(array $attributes, $id)
    {
        $attributes['shop_id'] = auth('hideyobackend')->user()->selected_shop_id;

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

        $validator = Validator::make($attributes, $this->rules($id));
        if ($validator->fails()) {
            return $validator;
        }

        $model = $this->find($id);
        $attributes['modified_by_user_id'] = auth('hideyobackend')->user()->id;

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

        if (count($attributes) > 0) {
            $model->fill($attributes);
            $model->save();
        }
        return $model;  
    } 

    public function destroy($newsId)
    {
        $this->model = $this->find($newsId);

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

        $this->model->save();

The method save() does not exist on null.

        if ($this->model->contentImages()->count()) {
            foreach ($this->model->contentImages()->get() as $image) {
                $this->contentImage->destroy($image->id);

The property contentImage does not exist on Hideyo\Ecommerce\Framework\Services\Content\ContentService. Did you maybe forget to declare it?

            }
        }

        $directory = app_path() . "/storage/files/".$this->model->shop_id."/content/".$this->model->id;
        File::deleteDirectory($directory);

        return $this->model->delete();
    }

    /**
     * The validation rules for the modelGroup.
     *
     * @return array
     */
    public function rulesGroup($contentGroupId = false, $attributes = false)

The parameter $attributes is not used and could be removed.

    {
        $rules = array(
            'title'                 => 'required|between:4,65|unique:'.$this->repo->getGroupModel()->getTable().''
        );
        
        if ($contentGroupId) {
            $rules['title'] =   'required|between:4,65|unique:'.$this->repo->getGroupModel()->getTable().',title,'.$contentGroupId;
        }


        return $rules;
    }


    public function createGroup(array $attributes)
    {
        $attributes['shop_id'] = auth('hideyobackend')->user()->selected_shop_id;

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

        $validator = Validator::make($attributes, $this->rulesGroup());

        if ($validator->fails()) {
            return $validator;
        }

        $attributes['modified_by_user_id'] = auth('hideyobackend')->user()->id;

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

            
        $this->repo->getGroupModel()->fill($attributes);
        $this->repo->getGroupModel()->save();
   
        return $this->repo->getGroupModel();
    }

    public function createImage(array $attributes, $contentId)
    {
        $userId = auth('hideyobackend')->user()->id;

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

        $shopId = auth('hideyobackend')->user()->selected_shop_id;

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

        $shop = ShopService::find($shopId);

The type Hideyo\Ecommerce\Framework\Services\Content\ShopService was not found. Maybe you did not declare it correctly or list all dependencies?

        $rules = array(
            'file'=>'required|image|max:1000',
            'rank' => 'required'
        );

        $validator = Validator::make($attributes, $rules);

        if ($validator->fails()) {
            return $validator;
        }

        $attributes['modified_by_user_id'] = $userId;

        $destinationPath = storage_path() . "/app/files/content/".$contentId;
        $attributes['user_id'] = $userId;
        $attributes['content_id'] = $contentId;
        $attributes['extension'] = $attributes['file']->getClientOriginalExtension();
        $attributes['size'] = $attributes['file']->getSize();
        
        $filename =  str_replace(" ", "_", strtolower($attributes['file']->getClientOriginalName()));
        $uploadSuccess = $attributes['file']->move($destinationPath, $filename);

        if ($uploadSuccess) {
            $attributes['file'] = $filename;
            $attributes['path'] = $uploadSuccess->getRealPath();
     
            $this->modelImage->fill($attributes);
            $this->modelImage->save();

            if ($shop->square_thumbnail_sizes) {
                $sizes = explode(',', $shop->square_thumbnail_sizes);
                if ($sizes) {

The expression $sizes of type string[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    foreach ($sizes as $valueSize) {
                        $image = Image::make($uploadSuccess->getRealPath());

The type Hideyo\Ecommerce\Framework\Services\Content\Image was not found. Maybe you did not declare it correctly or list all dependencies?

                        $explode = explode('x', $valueSize);
                        $image->resize($explode[0], $explode[1]);
                        $image->interlace();

                        if (!File::exists(public_path() . "/files/content/".$valueSize."/".$contentId."/")) {
                            File::makeDirectory(public_path() . "/files/content/".$valueSize."/".$contentId."/", 0777, true);
                        }
                        $image->save(public_path() . "/files/content/".$valueSize."/".$contentId."/".$filename);
                    }
                }
            }
            
            return $this->modelImage;
        }
    }

    public function updateGroupById(array $attributes, $newsGroupId)
    {
        $validator = Validator::make($attributes, $this->rulesGroup($newsGroupId, $attributes));

        if ($validator->fails()) {
            return $validator;
        }

        $attributes['modified_by_user_id'] = auth('hideyobackend')->user()->id;

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

        $this->modelGroup = $this->findGroup($newsGroupId);

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

        return $this->updateGroupEntity($attributes);
    }

    private function updateGroupEntity(array $attributes = array())
    {
        if (count($attributes) > 0) {
            $this->modelGroup->fill($attributes);
            $this->modelGroup->save();
        }

        return $this->modelGroup;
    }

    public function updateImageById(array $attributes, $contentId, $newsImageId)

The parameter $contentId is not used and could be removed.

    {
        $attributes['modified_by_user_id'] = auth('hideyobackend')->user()->id;

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

        $this->modelImage = $this->find($newsImageId);

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

        return $this->updateImageEntity($attributes);
    }

    private function updateImageEntity(array $attributes = array())
    {
        if (count($attributes) > 0) {
            $this->modelImage->fill($attributes);
            $this->modelImage->save();
        }

        return $this->modelImage;
    }

    public function destroyImage($newsImageId)
    {
        $this->modelImage = $this->findImage($newsImageId);

The method findImage() does not exist on Hideyo\Ecommerce\Framework\Services\Content\ContentService.

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

        $filename = storage_path() ."/app/files/content/".$this->modelImage->content_id."/".$this->modelImage->file;
        $shopId = auth('hideyobackend')->user()->selected_shop_id;

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

        $shop = ShopService::find($shopId);

        if (File::exists($filename)) {
            File::delete($filename);
            if ($shop->square_thumbnail_sizes) {
                $sizes = explode(',', $shop->square_thumbnail_sizes);
                if ($sizes) {

The expression $sizes of type string[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    foreach ($sizes as $valueSize) {
                        File::delete(public_path() . "/files/content/".$valueSize."/".$this->modelImage->content_id."/".$this->modelImage->file);
                    }
                }
            }
        }

        return $this->modelImage->delete();
    }

    public function destroyGroup($newsGroupId)
    {
        $this->modelGroup = $this->findGroup($newsGroupId);

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

        $this->modelGroup->save();

The method save() does not exist on null.

        return $this->modelGroup->delete();
    }

    public function getGroupModel()
    {
        return $this->repo->getGroupModel();
    }

    public function findGroup($id)
    {
        return $this->repo->findGroup($id);
    }

    public function selectAllGroups()
    {
        return $this->repo->selectAllGroups();
    }

    public function getImageModel()
    {
        return $this->repo->getImageModel();
    }
}