auditionadmin/app/Http/Controllers/Admin/AuditionController.php

<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Http\Requests\AuditionStoreOrUpdateRequest;
use App\Http\Requests\BulkAuditionEditRequest;
use App\Models\Audition;
use App\Models\Event;
use App\Models\Room;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

use function compact;
use function redirect;
use function request;
use function response;
use function to_route;
use function view;

class AuditionController extends Controller
{
    public function index()
    {
        $auditions = Audition::with(['event'])->withCount('entries')->orderBy('score_order')->orderBy('created_at',
            'desc')->get();

        return view('admin.auditions.index', ['auditions' => $auditions]);
    }

    public function create()
    {
        $events = Event::orderBy('name')->get();

        return view('admin.auditions.create', ['events' => $events]);
    }

    public function store(AuditionStoreOrUpdateRequest $request)
    {
        $validData = $request->validated();

        if (empty($validData['scoring_guide_id'])) {
            $validData['scoring_guide_id'] = 0;
        }
        $validData['score_order'] = Audition::max('score_order') + 1;

        Audition::create([
            'event_id' => $validData['event_id'],
            'name' => $validData['name'],
            'entry_deadline' => $validData['entry_deadline'],
            'entry_fee' => $validData['entry_fee'] * 100,
            'minimum_grade' => $validData['minimum_grade'],
            'maximum_grade' => $validData['maximum_grade'],
            'for_seating' => $validData['for_seating'],
            'for_advancement' => $validData['for_advancement'],
            'scoring_guide_id' => $validData['scoring_guide_id'],
            'room_id' => 0,
            'score_order' => $validData['score_order'],
        ]);

        return to_route('admin.auditions.index')->with('success', 'Audition created successfully');
    }

    public function edit(Audition $audition)
    {
        $events = Event::orderBy('name')->get();

        return view('admin.auditions.edit', ['audition' => $audition, 'events' => $events]);
    }

    public function update(AuditionStoreOrUpdateRequest $request, Audition $audition)
    {
        $validData = $request->validated();

        $audition->update([
            'event_id' => $validData['event_id'],
            'name' => $validData['name'],
            'entry_deadline' => $validData['entry_deadline'],
            'entry_fee' => $validData['entry_fee'] * 100,
            'minimum_grade' => $validData['minimum_grade'],
            'maximum_grade' => $validData['maximum_grade'],
            'for_seating' => $validData['for_seating'],
            'for_advancement' => $validData['for_advancement'],
        ]);

        return to_route('admin.auditions.index')->with('success', 'Audition updated successfully');
    }

    public function bulkEditForm()
    {
        $auditions = Audition::with(['event'])->withCount('entries')->orderBy('score_order')->orderBy('created_at',
            'desc')->get()->groupBy('event_id');
        $events = Event::orderBy('name')->get();

        return view('admin.auditions.bulk_edit_form', compact('auditions', 'events'));

    }

    public function bulkUpdate(BulkAuditionEditRequest $request)
    {
        $validated = collect($request->validated());

        $auditions = Audition::whereIn('id', $validated['auditions'])->get();
        foreach ($auditions as $audition) {
            if ($validated->has('event_id')) {
                $audition->event_id = $validated['event_id'];
            }
            if ($validated->has('entry_deadline')) {
                $audition->entry_deadline = $validated['entry_deadline'];
            }
            if ($validated->has('entry_fee')) {

                $audition->entry_fee = $validated['entry_fee'];
            }
            if ($validated->has('minimum_grade')) {
                $originalMinimumGrade = $audition->minimum_grade;
                $audition->minimum_grade = $validated['minimum_grade'];
            }
            if ($validated->has('maximum_grade')) {
                $originalMaximumGrade = $audition->maximum_grade;
                $audition->maximum_grade = $validated['maximum_grade'];
            }
            if ($validated->has('for_seating')) {
                $audition->for_seating = $validated['for_seating'];
            }
            if ($validated->has('for_advancement')) {
                $audition->for_advancement = $validated['for_advancement'];
            }

            if ($audition->minimum_grade > $audition->maximum_grade) {
                $audition->minimum_grade = $originalMinimumGrade;
                $audition->maximum_grade = $originalMaximumGrade;
            }
            $audition->save();
        }

        return to_route('admin.auditions.index')->with('success', $auditions->count().' Auditions updated successfully');
    }

    public function reorder(Request $request)
    {
        $order = $request->order;
        foreach ($order as $index => $id) {
            $audition = Audition::find($id);
            $audition->update(['score_order' => $index]);
        }

        return response()->json(['status' => 'success']);
    }

    public function roomUpdate(Request $request)
    {
        $auditions = $request->all();
        /**
         * $auditions will be an array of arrays with the following structure:
         * [
         *      ['id' => 1, 'room_id' => 1, 'room_order' => 1],
         * ]
         * is is an audition id
         */
        foreach ($auditions as $audition) {
            $a = Audition::where('id', $audition['id'])
                ->update([
                    'room_id' => $audition['room_id'],
                    'order_in_room' => $audition['room_order'],
                ]);
        }

        return response()->json(['status' => 'success']);
    }

    /**
     * Update the scoring guide for an audition
     * Used by AJAX call on the scoring guide index page
     * request should include scoring_guide_id and audition_id
     *
     * @return JsonResponse
     */
    public function scoringGuideUpdate(Request $request)
    {

        $audition = Audition::find($request->audition_id);

        if ($audition) {
            $audition->update([
                'scoring_guide_id' => $request->new_guide_id,
            ]);

            return response()->json(['success' => true]);
        }

        return response()->json(['success' => false], 404);
    }

    public function destroy(Audition $audition)
    {
        if ($audition->entries->count() > 0) {
            return redirect()->route('admin.auditions.index')->with('error', 'Cannot delete an audition with entries.');
        }
        $audition->delete();

        return to_route('admin.auditions.index')->with('success', 'Audition deleted successfully');
    }
}