Hideyo\Ecommerce\Framework\Services\News\Entity\NewsRepository

Complexity

Total Complexity

58

Size/Duplication

Total Lines	393
Duplicated Lines	0 %

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	getImageModel()	0	3	1
A	rules()	0	17	3
A	destroy()	0	14	3
A	destroyGroup()	0	5	1
B	refactorAllImagesByShopId()	0	22	8
B	createImage()	0	51	7
A	findImage()	0	3	1
A	updateGroupById()	0	11	2
A	create()	0	13	2
A	selectByGroupAndByShopIdAndPaginate()	0	16	1
A	findGroup()	0	3	1
A	__construct()	0	7	1
A	selectOneById()	0	7	1
A	createGroup()	0	15	2
A	selectByLimitAndOrderBy()	0	13	1
A	selectOneBySlug()	0	4	1
A	selectAllByShopIdAndPaginate()	0	13	1
A	updateImageById()	0	5	1
A	updateGroupEntity()	0	8	2
A	selectOneGroupByShopIdAndSlug()	0	8	2
A	selectAllGroups()	0	3	1
A	updateById()	0	11	2
A	destroyImage()	0	20	5
A	rulesGroup()	0	17	3
A	selectAllByBlogCategoryId()	0	8	1
A	selectAllActiveGroupsByShopId()	0	3	1
A	getGroupModel()	0	3	1
A	updateImageEntity()	0	8	2

<?php 

namespace Hideyo\Ecommerce\Framework\Services\News\Entity;
 
use Hideyo\Ecommerce\Framework\Services\News\Entity\News;
use Hideyo\Ecommerce\Framework\Services\News\Entity\NewsImage;
use Hideyo\Ecommerce\Framework\Services\News\Entity\NewsGroup;
use Carbon\Carbon;
use Image;
use File;
use Validator;
use Hideyo\Ecommerce\Framework\Services\BaseRepository;

class NewsRepository  extends BaseRepository 
{

    /**
     * Note: please keep logic in this repository. Put logic not in models,
     * Information about models in Laravel: http://laravel.com/docs/5.1/eloquent
     * @author     Matthijs Neijenhuijs <matthijs@hideyo.io>
     * @copyright  DutchBridge - dont share/steel!
     */

    protected $model;

    public function __construct(News $model, NewsImage $modelImage, NewsGroup $modelGroup)
    {
        $this->model = $model;
        $this->modelImage = $modelImage;

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

        $this->modelGroup = $modelGroup;

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

        $this->storageImagePath = storage_path() .config('hideyo.storage_path'). "/news/";

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

        $this->publicImagePath = public_path() .config('hideyo.public_path'). "/news/";

The property publicImagePath 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($newsId = false, $attributes = false)
    {
        if (isset($attributes['seo'])) {
            $rules = array(
                'meta_title'                 => 'required|between:4,65|unique_with:'.$this->model->getTable().', shop_id'
            );
        } else {
            $rules = array(
                'title'                 => 'required|between:4,65|unique:'.$this->model->getTable().''
            );
            
            if ($newsId) {
                $rules['title'] =   'required|between:4,65|unique:'.$this->model->getTable().',title,'.$newsId;
            }
        }

        return $rules;
    }

    public function rulesGroup($newsGroupId = false, $attributes = false)
    {
        if (isset($attributes['seo'])) {
            $rules = array(
                'meta_title'                 => 'required|between:4,65|unique_with:'.$this->modelGroup->getTable().', shop_id'
            );
        } else {
            $rules = array(
                'title'                 => 'required|between:4,65|unique:'.$this->modelGroup->getTable()
            );
            
            if ($newsGroupId) {
                $rules['title'] =   'required|between:4,65|unique:'.$this->modelGroup->getTable().',title,'.$newsGroupId;
            }
        }

        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->model->fill($attributes);
        $this->model->save();
        return $this->model;
    }

    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;
        }

        $this->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?

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

    public function createImage(array $attributes, $newsId)
    {
        $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\News\Entity\ShopService was not found. Maybe you did not declare it correctly or list all dependencies?

        $attributes['modified_by_user_id'] = $userId;
        $destinationPath = $this->storageImagePath.$newsId;
        $attributes['user_id'] = $userId;
        $attributes['news_id'] = $newsId;
        $attributes['extension'] = $attributes['file']->getClientOriginalExtension();
        $attributes['size'] = $attributes['file']->getSize();
       
        $rules = array(
            'file'=>'required|image|max:1000',
            'rank' => 'required'
        );

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

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

        $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->thumbnail_square_sizes) {
                $sizes = explode(',', $shop->thumbnail_square_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 $valueImage) {
                        $image = Image::make($uploadSuccess->getRealPath());
                        $explode = explode('x', $valueImage);
                        $image->resize($explode[0], $explode[1]);
                        $image->interlace();

                        if (!File::exists($this->publicImagePath.$valueImage."/".$newsId."/")) {
                            File::makeDirectory($this->publicImagePath.$valueImage."/".$newsId."/", 0777, true);
                        }
                        $image->save($this->publicImagePath.$valueImage."/".$newsId."/".$filename);
                    }
                }
            }
            
            return $this->modelImage;
        }
        
    }


    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->modelGroup->fill($attributes);
        $this->modelGroup->save();
   
        return $this->modelGroup;
    }
    
    public function refactorAllImagesByShopId($shopId)
    {
        $result = $this->modelImage->get();
        $shop = ShopService::find($shopId);
        foreach ($result as $productImage) {
            if ($shop->thumbnail_square_sizes) {
                $sizes = explode(',', $shop->thumbnail_square_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 $valueImage) {
                        if (!File::exists($this->publicImagePath.$valueImage."/".$productImage->news_id."/")) {
                            File::makeDirectory($this->publicImagePath.$valueImage."/".$productImage->news_id."/", 0777, true);
                        }

                        if (!File::exists($this->publicImagePath.$valueImage."/".$productImage->news_id."/".$productImage->file)) {
                            if (File::exists($this->storageImagePath.$productImage->news_id."/".$productImage->file)) {
                                $image = Image::make(storage_path() .config('hideyo.storage_path'). "//news/".$productImage->news_id."/".$productImage->file);
                                $explode = explode('x', $valueImage);
                                $image->fit($explode[0], $explode[1]);
                            
                                $image->interlace();

                                $image->save(public_path() .config('hideyo.storage_path'). "/news/".$valueImage."/".$productImage->news_id."/".$productImage->file);
                            }
                        }
                    }
                }
            }
        }
    }

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

The parameter $newsId 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->findImage($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);
    }

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

        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);
    }

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

        return $this->modelGroup;
    }

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

        if ($this->model->newsImages->count()) {
            foreach ($this->model->newsImages as $image) {
                $this->newsImage->destroy($image->id);

The property newsImage does not exist on Hideyo\Ecommerce\Framework\Services\News\Entity\NewsRepository. Did you maybe forget to declare it?

            }
        }

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

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

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

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

        $filename = $this->storageImagePath.$this->modelImage->news_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->thumbnail_square_sizes) {
                $sizes = explode(',', $shop->thumbnail_square_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 $valueImage) {
                        File::delete($this->publicImagePath.$valueImage."/".$this->modelImage->news_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();
        return $this->modelGroup->delete();
    }

    public function selectAllGroups()
    {
       return $this->model->where('shop_id', auth('hideyobackend')->user()->selected_shop_id)->get();

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?

    }

    public function findGroup($groupId)
    {
        return $this->modelGroup->find($groupId);
    }

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

    public function findImage($imageId)
    {
        return $this->modelImage->find($imageId);
    }

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

    function selectOneBySlug($shopId, $slug)

It is generally recommended to explicitly declare the visibility for methods.

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

    {
        $dt = Carbon::now('Europe/Amsterdam');
        return $this->model->where('slug', $slug)->where('published_at', '<=', $dt->toDateString('Y-m-d'))->get()->first();

The call to Carbon\Carbon::toDateString() has too many arguments starting with 'Y-m-d'.

    }

    function selectAllByBlogCategoryId($newsCategoryId)

It is generally recommended to explicitly declare the visibility for methods.

    {
           return $this->model->with(array('extraFields' => function ($query) {

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

           }, 'taxRate', 'newsCategory',  'relatedBlogs' => function ($query) {
            $query->with('newsImages')->orderBy('rank', 'asc');
           }, 'newsImages' => function ($query) {
            $query->orderBy('rank', 'asc');
           }))->where('active', 1)->where('news_category_id', '=', $newsCategoryId)->get();
    }

    function selectOneById($shopId, $slug)

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

It is generally recommended to explicitly declare the visibility for methods.

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

    {
        $dt = Carbon::now('Europe/Amsterdam');
        $result = $this->model->with(array('newsCategory', 'relatedBlogs', 'newsImages' => function ($query) {
            $query->orderBy('rank', 'asc');
        }))->where('published_at', '<=', $dt->toDateString('Y-m-d'))->where('active', 1)->where('id', $id)->get()->first();

The variable $id seems to be never defined.

The call to Carbon\Carbon::toDateString() has too many arguments starting with 'Y-m-d'.

        return $result;
    }

    function selectAllActiveGroupsByShopId($shopId)

It is generally recommended to explicitly declare the visibility for methods.

    {
         return $this->modelGroup->where('shop_id', $shopId)->where('active', 1)->get();
    }

    function selectOneGroupByShopIdAndSlug($shopId, $slug)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $result = $this->modelGroup->where('shop_id', $shopId)->where('slug', $slug)->get();
        
        if ($result->isEmpty()) {
            return false;
        }
        return $result->first();
    }

    public function selectByLimitAndOrderBy($shopId, $limit, $orderBy)
    {
        $dt = Carbon::now('Europe/Amsterdam');

        return $this->model->with(
            array('newsImages' => function ($query) {
                $query->orderBy('rank', 'asc');
            })
        )
        ->limit($limit)
        ->where('shop_id', $shopId)
        ->where('published_at', '<=', $dt->toDateString('Y-m-d'))

The call to Carbon\Carbon::toDateString() has too many arguments starting with 'Y-m-d'.

        ->orderBy('created_at', $orderBy)->get();
    }

    function selectAllByShopIdAndPaginate($shopId, $totalPage, $filters = false)

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

It is generally recommended to explicitly declare the visibility for methods.

    {
        $dt = Carbon::now('Europe/Amsterdam');

           $result = $this->model
           ->where('shop_id', $shopId)
           ->where('published_at', '<=', $dt->toDateString('Y-m-d'));

The call to Carbon\Carbon::toDateString() has too many arguments starting with 'Y-m-d'.

            return array(
                'totals' => $result->get()->count(),
                'totalPages' => ceil($result->get()->count() / $totalPage),
                'result' => $result->paginate($totalPage),
                'totalOnPage' => $totalPage
            );
    }

    function selectByGroupAndByShopIdAndPaginate($shopId, $newsGroupSlug, $totalPage, $filters = false)

It is generally recommended to explicitly declare the visibility for methods.

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

    {
        $dt = Carbon::now('Europe/Amsterdam');

           $result = $this->model
           ->where('shop_id', $shopId)
           ->where('published_at', '<=', $dt->toDateString('Y-m-d'))

The call to Carbon\Carbon::toDateString() has too many arguments starting with 'Y-m-d'.

           ->whereHas('newsGroup', function ($query) use ($newsGroupSlug) {
            $query->where('slug', '=', $newsGroupSlug);
           });

            return array(
                'totals' => $result->get()->count(),
                'totalPages' => ceil($result->get()->count() / $totalPage),
                'result' => $result->paginate($totalPage),
                'totalOnPage' => $totalPage
            );
    }
}