imgmongelli / mongicommerce

src/Http/Controllers/shop/ShopCartController.php

<?php
namespace Mongi\Mongicommerce\Http\Controllers\shop;

use App\Models\Product;

The type App\Models\Product was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Mongi\Mongicommerce\Http\Controllers\Controller;
use Mongi\Mongicommerce\Models\Cart;
use Mongi\Mongicommerce\Models\ProductItem;

class ShopCartController extends Controller
{
    public function page(){
        return view('mongicommerce.pages.cart');
    }
    /**
     * @param ProductItem $product
     * @return bool|\Illuminate\Http\JsonResponse
     */
    private function checkIfProductAvaible(ProductItem $product)
    {
        $num_avaibile_product = $product->quantity;

        $checkElement = Cart::where('product_item_id', $product->id)->first();
        //if is null it means the cart is empty
        if (is_null($checkElement)) {
            if($num_avaibile_product > 0){
                return true;
            }else{
                return false;
            }
        }else{
            //if there is something in the cart check the avaibility
            if ($checkElement->quantity + 1 <= $num_avaibile_product) {
                return true;
            } else {
                return false;
            }
        }
    }

    public function addToCart(Request $r)
    {
        $product_item_id = $r->get('product_item_id');
        $product = ProductItem::find($product_item_id);
        $check = $this->checkIfProductAvaible($product);

        if($check){
            //if i'am not authenticated
            if (!Auth::check()) {
                session()->push('products.ids', $product_item_id);
                session()->put('cart',self::getCountableCart(session('products.ids')));
                return response()->json(session('cart'));
            }else{
                //if number i want is less than number avaible product i can add into cart
                $mycart = Cart::where('product_item_id',$product->id)->where('user_id',Auth::user()->id)->first();

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

                if(is_null($mycart)){
                    $cart = new Cart();
                    $cart->user_id = Auth::user()->id;
                    $cart->product_item_id = $product_item_id;
                    $cart->quantity = 1;
                    $cart->save();
                }else{
                    $mycart->quantity = $mycart->quantity + 1;
                    $mycart->save();
                }
                return true;
            }
        }else{
            return response()->json([
                'errors' => "Prodotto non disponibile o terminato",
            ], 422);
        }

    }

    public static function calculateTotalPrice(array $cart)
    {
        $info_totale = [];

The assignment to $info_totale is dead and can be removed.

        $total = [];
        $totale_weight = [];
        foreach ($cart as $element) {
            $total[] = $element['total'];
            $totale_weight[] = $element['sum_weight'];
        }
        $info_totale = [
            'total' => array_sum($total),
            'totale_weight' => array_sum($totale_weight)
        ];

        return $info_totale;
    }

    public static function getCountableCart($arr)
    {
        if (!is_null($arr)) {
            return array_count_values($arr);
        } else {
            return [];
        }
    }

    public function getCartElements()
    {
        if (!Auth::check()) {
            if (!empty(session('products.ids'))) {
                return response()->json(count(session('cart')));

It seems like session('cart') can also be of type Illuminate\Session\SessionManager and Illuminate\Session\Store; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

            } else {
                return 0;
            }

        } else {
            $products_in_cart = Cart::where('user_id', Auth::user()->id)->count();

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

            return response()->json($products_in_cart);
        }
    }

    public function getCartProducts()
    {
        $products = [];
        if (!Auth::check()) {
            $ids = [];
            session()->forget('products.ids');
            $productsCart = session('cart');
            if(isset($productsCart)){
                foreach ($productsCart as $id => $count) {
                    $product = ProductItem::where('id', $id)->first();
                    $ids[] = $id;
                    $products[] = [
                        'detail' => $product,
                        'single_price' => $product->price,
                        'count' => $count,
                        'single_weight' => $product->weight,

The property weight does not seem to exist on Mongi\Mongicommerce\Models\ProductItem. Are you sure there is no database migration missing?

                        'sum_weight' => $product->weight * $count,
                        'total' => $product->price * $count
                    ];
                }
            }
            session()->put('products.ids',$ids);

        } else {
            $productsCart = Cart::where('user_id', Auth::user()->id)->get();

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

            foreach ($productsCart as $element) {
                $product = ProductItem::where('id', $element->product_item_id)->first();
                $products[] = [
                    'detail' => $product,
                    'single_price' => $product->price,
                    'count' => $element->quantity,
                    'single_weight' => 0,
                    'sum_weight' => 0,
                    'total' => $product->price * $element->quantity
                ];
            }
        }

        return response()->json(['product' => $products , 'total' => self::calculateTotalPrice($products)]);
    }

    public function incrementOrDecrementElementInCart(Request $r){
        $product_id = $r->get('product_id');
        $operator = $r->get('operator');
        $product = ProductItem::find($product_id);
        if (!Auth::check()) {
            $cart = session('cart');
            $count_product_in_session = $cart[$product_id];
            if($product->quantity > $count_product_in_session || $operator < 0){
                if($count_product_in_session > 1 || $operator > 0){
                    $cart[$product_id] = $count_product_in_session + $operator;
                    session()->put('cart',$cart);
                }
            }
        }else{
            $cart = Cart::where('product_item_id',$product_id)->first();
            if($product->quantity > $cart->quantity || $operator < 0){
                if($cart->quantity > 1 || $operator > 0){
                    $cart->quantity = $cart->quantity + $operator;
                    $cart->save();
                }
            }
        }

    }

    public function deleteFromCart(Request $r){
        $product_id = $r->get('product_id');
        if (!Auth::check()) {
            $cart_in_session = session('cart');
            unset($cart_in_session[$product_id]);
            session()->put('cart',$cart_in_session);
        }else{
            Cart::where('product_item_id',$product_id)->delete();
            return true;
        }
    }
}