ProductsRepository - Code Metrics - nyacide/amma - Measure and Improve Code Quality continuously with Scrutinizer

ProductsRepository C
last analyzed 2016-12-28 08:14 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	387
Duplicated Lines	3.36 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

Metric	Value
wmc	55
lcom	2
cbo	5
dl	13
loc	387
rs	6.8
c	0
b	0
f	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getModel()	0	4	1
A	getPublic()	0	6	1
A	find()	13	13	2
B	create()	0	16	10
C	update()	0	22	11
A	reformatDateString()	0	10	1
A	dateToTimestamp()	0	6	1
A	delete()	0	4	1
B	getSomeRandomProducts()	0	28	4
A	findDrafted()	0	7	1
A	getCount()	0	7	1
A	countInLotProduct()	0	6	1
B	search()	0	30	5
A	formatSale()	0	6	1
A	getSameProduct()	0	15	1
A	getPublicLatest()	0	9	1
A	getFeaturedPublic()	0	10	1
A	getPublicExpireSoon()	0	11	1
C	getExpireSoon()	0	24	7
A	createPlain()	0	18	1
A	saveProduct()	0	14	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like ProductsRepository often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use ProductsRepository, and based on these observations, apply Extract Interface, too.

<?php

namespace App\Repositories;

use App\ImprovedSpec;
use App\SpecPrice;
use App\Lot;
use App\Product;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
use Mockery\CountValidator\Exception;

class ProductsRepository extends Repository
{
    /**
     * @return Product
     */
    public function getModel()
    {
        return new Product();
    }

    /**
     * Get all published products
     *
     * @return mixed
     */
    public function getPublic()
    {
        return self::getModel()

            ->published()
            ->get();
    }

    /**
     * Find product by id/slug.
     *
     * @param $slug
     * @return Product
     */
    public function find($slug)

    {
        if (is_numeric($slug))
            return $this->getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->whereId((int) $slug)
//                ->whereIn('status', ['published', 'drafted', 'notverified', 'completed'])

                ->first();

        return $this->getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->whereSlug($slug)
//            ->whereIn('status', ['published', 'drafted', 'notverified', 'completed'])

            ->first();
    }

    /**
     * Create product.
     * 
     * @param array $data
     * @return Product
     */
    public function create(array $data)
    {
        return self::getModel()
            ->create([
                'vendor_id' => $data['vendor_id'],
                'name' => (isset($data['name']) ? $data['name'] : ''),
                'price' => (isset($data['price']) ? $data['price'] : ''),
                'sale' => (isset($data['sale'])) ? $data['sale'] : 0,
                'count' => (isset($data['count'])) ? $data['count'] : 1,
                'type' => (isset($data['type'])) ? $data['type'] : 'new',
                'status' => (isset($data['status'])) ? $data['status'] : 'drafted',
                'published_date' => (isset($data['published_date']) ? $data['published_date'] : Carbon::now()),
                'expiration_date' => (isset($data['expiration_date']) ? $data['expiration_date'] : Carbon::now()),
                'active' => (isset($data['active']) ? $data['active'] : 0)
            ]);
    }

    /**
     * Update data.
     *
     * @param $product
     * @param $data
     * @return mixed
     */
    public function update($product, $data)
    {
        if(! $product instanceof Model)
            throw new Exception('First argument MUST be an instance of '.Model::class);

        $product->fill([
            'name'            => (isset($data['name']) ? $data['name'] : $product->name),
            'price'           => (isset($data['price']) ? $data['price'] : $product->price),
            'sale'            => (isset($data['sale'])) ? $this->formatSale($data['sale']) : $product->sale,
            'count'           => (isset($data['count'])) ? $data['count'] : $product->count,
            'description'     => (isset($data['description'])) ? $data['description'] : $product->description,
            'type'            => (isset($data['type'])) ? $data['type'] : 'new',
            'status'          => ($product->status == 'drafted') ? 'notverified' : $product->status,
            'published_date'  => (isset($data['published_date']) ? $this->dateToTimestamp($data['published_date']) : $product->published_date),
            'expiration_date' => (isset($data['expiration_date']) ? $this->dateToTimestamp($data['expiration_date']) : $product->published_date),
            'active'          => 1
        ]);

        $product->save();

        return $product;
    }

    /**
     * Reformat date.
     *
     * @param $date
     * @param string $delimiter
     * @return mixed
     */
    public function reformatDateString($date, $delimiter = '.')
    {
        $datas = explode($delimiter, $date);

        $new_date['d'] = $datas[0];
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        $new_date['m'] = $datas[1];
        $new_date['y'] = $datas[2];

        return $new_date;
    }

    /**
     * Convert string date to \Carbon/Carbon timestamp.
     *
     * @param $date
     * @return static
     */
    public function dateToTimestamp($date)
    {
        $dates = $this->reformatDateString($date);

        return Carbon::createFromDate($dates['y'], $dates['m'], $dates['d']);
    }

    /**
     * Remove product row from table.
     *
     * @param $id
     * @return bool|null
     * @throws \Exception
     */
    public function delete($id)
    {
        return $this->find($id)->delete();
    }

    /**
     * Get random products.
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function getSomeRandomProducts()
    {
        $random_element_1 = rand(1, 2);
        $random_element_2 = rand(1, 2);
        $random_element_3 = rand(1, 2);

        $query = self::getModel()->select('*');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        if ($random_element_1 == 1) {
            $query->published();
        } else {
            $query->drafted();
        }

        if ($random_element_2 == 1) {
            $query->whereType('old');
        } else {
            $query->whereType('new');
        }

        if ($random_element_3 == 1) {
            $query->whereBetween('sale', [1, 50]);
        } else {
            $query->whereBetween('sale', [51, 100]);
        }

        return $query->get();
    }

    /**
     * Get drafted product by id.
     * 
     * @param $id
     * @return mixed
     */
    public function findDrafted($id)
    {
        return self::getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->whereId($id)
            ->drafted()
            ->first();
    }

    public function getCount($id)
    {
        return self::getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->whereId($id)
            ->pluck('count')
            ->first();
    }

    public function countInLotProduct($id)
    {
        return self::getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->where('lot_id',$id)
            ->count();
    }

    public function search($filters)
    {

        $product = $filters['search'];

        if(isset($filters['category']))
            $category = $filters['category'];

        if(empty($product) && (!isset($category)))
            return null;

        if(isset($category))
        {
            $query = $this->getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->select('products.*', 'categoryable.category_id')
                ->where('products.name', 'like', '%'.$product.'%')
                ->join('categoryable', 'products.id', '=', 'categoryable.categoryable_id')
                ->where('categoryable.categoryable_type', get_class(self::getModel()))
                ->where('categoryable.category_id', $category);
        } else
        {
            $query = $this->getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->where('name', 'like', '%'.$product.'%');
        }

        $query->where('products.active', 1);
            /*->whereIn('active', ['published', 'completed']);*/


        return $query->get();
    }

    /**
     * Remove percent from sale if it exists.
     *
     * @param $sale
     * @return int
     */
    private function formatSale($sale)
    {
        list($sale, $percent) = explode('%', $sale);
<?php

function returnThreeValues() {
    return array('a', 'b', 'c');
}

list($a, $b, $c) = returnThreeValues();

print $a . " - " . $c;

        return (int) $sale;
    }

    /**
     * Get same products.
     *
     * @param mixed
     */
    public function getSameProduct($id,$limit=10)
    {
        $query = $this->getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->select('products.*')
            ->where('sub_category_id',$id)
            ->where('products.active', 1)
            /*->where('lots.expire_date', '>', Carbon::now())*/

            ->limit($limit);

        $query->join('lots', 'lots.id', '=', 'products.lot_id')
            ->where('lots.verify_status', 'verified');

        return $query->get();

    }

    /**
     * Get public latest created products.
     *
     * @param int $count
     * @return mixed
     */
    public function getPublicLatest($count = 8)
    {
        return $this->getModel()

            ->active()
//            ->published() // todo: on production back it.

            ->orderBy('id', self::DESC)
            ->take($count)
            ->get();
    }

    /**
     * Get popular products.
     *
     * @return mixed
     */
    public function getFeaturedPublic($count = 8)
    {
        return $this->getModel()

//            ->published()
            ->featured()
            ->active()
            ->orderBy('id', self::DESC)
            ->take($count)
            ->get();
    }

    /**
     * Get expire soon products.
     *
     * @param int $count
     * @return mixed
     */
    public function getPublicExpireSoon($count = 8)
    {
        return $this->getModel()

//            ->published()
            ->active()
//            ->where('expiration_date', '>', Carbon::now())

//            ->orderBy('expiration_date', self::ASC)
            ->orderBy('id', self::ASC)
            ->take($count)
            ->get();
    }

    /**
     * Expire soon products.
     *
     * @param int $paginate
     * @return mixed
     */
    public function getExpireSoon($paginate = 10)
    {
        $query = $this->getModel()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->select('products.*')
            ->where('products.active', 1)
            ->where('lots.expire_date', '>', Carbon::now())
            ->orderBy('lots.expire_date', self::ASC);

        if(request()->get('name'))
            $query->orderBy('products.name', request()->get('name') == self::ASC ? self::ASC : self::DESC);

        if(request()->get('created_at'))
            $query->orderBy('products.created_at', request()->get('created_at') == self::ASC ? self::ASC : self::DESC);

        if(request()->get('price'))
            $query->orderBy('products.price', request()->get('price') == self::ASC ? self::ASC : self::DESC);

        $query->join('lots', 'lots.id', '=', 'products.lot_id')
            ->where('lots.status', Lot::STATUS_COMPLETE)
            ->where('lots.verify_status', Lot::STATUS_VERIFY_ACCEPTED);

//        return $query->orderBy('id', self::ASC)

            return $query->paginate($paginate);
    }

    /**
     * Create plain product for \App\Lot $lot
     *
     * @param Lot $lot
     * @return static
     */
    public function createPlain(Lot $lot)
    {
        $product = self::getModel()
            ->create([
                'lot_id' => $lot->id,
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                'uniqid' => substr(str_replace('.','',uniqid('00'.rand(),true)),0,10)

            ]);
        /*$spec_price =  SpecPrice::create([

            'product_id' => $product->id
        ]);
        ImprovedSpec::create([
            'product_id' => $product->id,
            'price_spec_id' => $spec_price->id
        ]);*/

        return $product;
    }

    public function saveProduct($product, array $data)
    {
        $product->fill([
            /*'name'            => isset($data['name']) ? $data['name'] : null,

            'old_price'       => isset($data['old_price']) ? $data['old_price'] : null,
            'price'           => isset($data['price']) ? $data['price'] : null,
            'sale'            => isset($data['sale']) ? $data['sale'] : null,*/
            'sub_category_id' => isset($data['sub_category']) ? $data['sub_category'] : null
        ]);

        $product->save();

        return $product;
    }
}

nyacide / amma

ProductsRepository C last analyzed 2016-12-28 08:14 UTC