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

<?php

namespace App\Http\Controllers;

use App\Enums\BalancedMenuType;
use App\Enums\RecipeFilter;
use App\Enums\RecipeFilterTimes;
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 BadMethodCallException;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

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', DB::table(resolve(Recipes::class)->getTable())
            ->select('id')->inRandomOrder()->get()->pluck('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 RecipeFilter::range()->value:
                $recipes = $recipes->whereHas('products.range', function ($q) use ($request) {
                    $q->where('ranges.slug', $request->value);
                });
                break;
            case RecipeFilter::consumption()->value:
                $recipes = $recipes->whereHas('consumptionTimes', function ($q) use ($request) {
                    $q->where('consumption_times.slug', $request->value);
                });
                break;
            case RecipeFilter::cooking()->value:
            case RecipeFilter::preparation()->value:
                switch ($request->value) {
                    case RecipeFilterTimes::less15()->value:
                        $recipes = $recipes->where(
                            RecipeFilter::make($request->type)->getDefinition() . '_time',
                            '<=',
                            15
                        );
                        break;
                    case RecipeFilterTimes::between15and30()->value:
                        $recipes = $recipes
                            ->where(RecipeFilter::make($request->type)->getDefinition() . '_time', '>=', 15)
                            ->where(RecipeFilter::make($request->type)->getDefinition() . '_time', '<=', 30);
                        break;
                    default:
                    case RecipeFilterTimes::more30()->value:
                        $recipes = $recipes
                            ->where(RecipeFilter::make($request->type)->getDefinition() . '_time', '>', 30);
                        break;
                }
                break;
        }


        $recipes = $recipes->paginate();
        $type = $request->type ? RecipeFilter::make($request->type) : null;
        try {
            $value = $request->value ? RecipeFilterTimes::make($request->value) : null;
        } catch (BadMethodCallException $e) {
            $value = null;
        }

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

    public function show(Recipes $recipe)
    {
        if (!$recipe->status) {
            abort('404');
        }
        $recipe->load('products.range', '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('status', 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())
            ->where('status', true)
            ->limit($recipesLimit)
            ->inRandomOrder()
            ->orderBy('highlight', 'desc')
            ->get();
        if (count($featuredRecipes) < $recipesLimit) {
            $featuredRecipes = $featuredRecipes->merge(Recipes::query()
                ->where('status', true)
                ->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)->where('status', true)->firstOrFail());
    }
}