ldc-legaulois/app/Http/Controllers/RecipesController.php

<?php

namespace App\Http\Controllers;

use App\Enums\BalancedMenuType;
use App\Enums\RecipeType;
use App\Http\Requests\RecipeIndexRequest;
use App\Http\Requests\RecipeRateRequest;
use App\Models\BalancedMenus;
use App\Models\ConsumptionTimes;
use App\Models\Products;
use App\Models\Ranges;
use App\Models\Recipes;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Http\Request;

class RecipesController extends Controller
{
    public function index(RecipeIndexRequest $request)
    {
        if (
            !session()->has('recipes.rand') ||
            (intval(session()->get('recipes.time', time())) - intval(time())) > (60 * 60 * 60) // 1 hour
        ) {
            session()->put('recipes.time', time());
            session()->put('recipes.rand', Recipes::all('id')->shuffle()->map(function ($obj) {
                return $obj->id;
            })->toArray());
            session()->save();
        }

        $recipes = Recipes::select('title', 'slug', 'picture', 'catch_phrase')
            ->where('status', true)
            ->orderByRaw(\sprintf('FIELD(id, %s)', implode(", ", session()->get('recipes.rand'))));

        if ($request->search) {
            $recipes = $recipes->where('title', 'like', '%' . implode('%', explode(' ', trim($request->search))) . '%');
        }
        if ($request->video_recipe) {
            $recipes = $recipes->where('type', '=', RecipeType::video()->value);
        }

        $ranges = Ranges::select('name', 'slug')
            ->where('status', true)
            ->orderBy('order')
            ->get();

        $consumptionTimes = ConsumptionTimes::select('name', 'slug')
            ->where('status', true)
            ->get();


        switch ($request->type) {
            case 'range':
                $recipes = $recipes->whereHas('products.range', function ($q) use ($request) {
                    $q->where('ranges.slug', $request->value);
                });
                break;
            case 'consumption':
                $recipes = $recipes->whereHas('consumptionTimes', function ($q) use ($request) {
                    $q->where('consumption_times.slug', $request->value);
                });
                break;
            case 'cooking':
            case 'preparation':
                switch ($request->value) {
                    case 'less15':
                        $recipes = $recipes->where($request->type . '_time', '<=', 15);
                        break;
                    case '15and30':
                        $recipes = $recipes
                            ->where($request->type . '_time', '>=', 15)
                            ->where($request->type . '_time', '<=', 30);
                        break;
                    default:
                    case 'more30':
                        $recipes = $recipes
                            ->where($request->type . '_time', '>', 30);
                        break;
                }
                break;
        }


        $recipes = $recipes->paginate();
        $type = $request->type;
        $value = $request->value;

        return view('front.recipes.index', compact(
            'recipes',
            'ranges',
            'consumptionTimes',
            'type',
            'value'
        ));
    }

    public function show(Recipes $recipe)
    {
        $recipe->load('products', 'articles', 'rating');
        return view('front.recipes.show', compact('recipe'));
    }

    public function rate(Recipes $recipe, RecipeRateRequest $request)
    {
        if ($recipe->hasBeenRatedByUser()) {
            return response()->json($recipe->rating->rating);
        }
        $recipe->setRateForUserAndSave($request->post('rating', 0));
        return response()->json(floatval($request->post('rating', 0)));
    }

    public function kitchenside()
    {
        $recipesLimit = 3;
        $featuredRecipes = Recipes::where('highlight', true)
            ->where('type', RecipeType::classic())
            ->limit($recipesLimit)
            ->inRandomOrder()
            ->get();
        // TODO: Create video recipes to test query and css in front
        $videoRecipes = Recipes::where('type', RecipeType::video())
            ->limit($recipesLimit)
            ->inRandomOrder()
            ->orderBy('highlight', 'desc')
            ->get();
        if (count($featuredRecipes) < $recipesLimit) {
            $featuredRecipes = $featuredRecipes->merge(Recipes::all()
                ->inRandomOrder()
                ->limit($recipesLimit - count($featuredRecipes))
                ->get());
        }
        return view('front.kitchenside', compact('featuredRecipes', 'videoRecipes'));
    }

    public function showForBalancedMenu(BalancedMenuType $type, Products $product, Request $request)
    {
        if (!$request->ajax()) {
            abort(400);
        }
        // NE vérifie pas balancedmenu status car il faut afficher la recette du produit si il est publié
        return response()->json(BalancedMenus::where('product_id', $product->id)
            ->where('type', $type)->firstOrFail());
    }
}