xoco70 / kendozone

app/Http/Controllers/TournamentController.php

<?php

namespace App\Http\Controllers;

use App\Category;
use App\Country;
use App\Exceptions\InvitationNeededException;
use App\FightersGroup;
use App\Grade;
use App\Http\Requests\TournamentRequest;
use App\Http\Requests\VenueRequest;
use App\Tournament;
use App\TournamentLevel;
use App\Venue;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Lang;
use Illuminate\Support\Facades\Response;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\URL;


class TournamentController extends Controller
{
    public function __construct()
    {
        $this->middleware('ownTournament')->except('index', 'show', 'register');
        $this->middleware('auth')->except('show', 'register');
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {

        if (Auth::user()->isSuperAdmin()) {
            $tournaments = Tournament::with('owner')
                ->withCount('competitors')
                ->orderBy('updated_at', 'desc')
                ->paginate(config('constants.PAGINATION')); // ,'uniqueTrees'
        } else {
            $tournaments = Auth::user()->tournaments()
                ->with('owner')->orderBy('updated_at', 'desc')
                ->paginate(config('constants.PAGINATION'));
        }
        $title = trans('core.tournaments_created');
        return view('tournaments.index', compact('tournaments', 'title'));

The expression return view('tournaments.index', compact('tournaments', 'title')) returns the type Illuminate\Contracts\View\Factory|Illuminate\View\View which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        $levels = TournamentLevel::getAllPlucked();
        $categories = Category::take(10)->orderBy('id', 'asc')->pluck('name', 'id');
        $tournament = new Tournament();
        $rules = config('options.rules');
        $rulesCategories = (new Category)->getCategorieslabelByRule();
        return view('tournaments.create', compact('levels', 'categories', 'tournament', 'rules', 'rulesCategories'));

The expression return view('tournaments.create', compact('levels', 'categories', 'tournament', 'rules', 'rulesCategories')) returns the type Illuminate\Contracts\View\Factory|Illuminate\View\View which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Store a new Tournament
     *
     * @param TournamentRequest $form
     * @return \Illuminate\Http\Response
     */
    public function store(TournamentRequest $form)
    {
        $tournament = $form->persist();
        $msg = trans('msg.tournament_create_successful', ['name' => $tournament->name]);
        flash()->success($msg);

Are you sure the usage of flash() is correct as it seems to always return null.

        return redirect(URL::action('TournamentController@edit', $tournament->slug));

The expression return redirect(Illuminate\Support\Facades\URL::action('TournamentController@edit', $tournament->slug)) returns the type Illuminate\Http\RedirectResponse|Illuminate\Routing\Redirector which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Display the Tournament.
     *
     * @param Request $request
     * @param $tournamentSlug
     * @return \Illuminate\Http\Response
     */
    public function show(Request $request, $tournamentSlug)

The parameter $tournamentSlug is not used and could be removed.

    {
        $teams = "";
        $grades = Grade::getAllPlucked();
        $tournament = FightersGroup::getTournament($request);
        $venue = $tournament->venue ?? new Venue;

The property venue does not seem to exist on Illuminate\Database\Eloquent\Builder.

        $countries = Country::getAll();

        return view('tournaments.show', compact('tournament', 'tournamentWithTrees', 'grades', 'teams', 'venue', 'countries'));

The expression return view('tournaments.show', compact('tournament', 'tournamentWithTrees', 'grades', 'teams', 'venue', 'countries')) returns the type Illuminate\Contracts\View\Factory|Illuminate\View\View which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Show the form for editing the Tournament.
     *
     * @param Tournament $tournament
     * @return \Illuminate\Http\Response
     */
    public function edit(Tournament $tournament)
    {

        $tournament = Tournament::with('competitors', 'championshipSettings', 'championships.settings', 'championships.category')
            ->withCount('competitors', 'teams')
            ->find($tournament->id);
        $selectedCategories = $tournament->categories->pluck('name','id'); // 3,4 ,240
        $defaultCategories = Category::take(7)->get()->sortBy('id')->pluck('name','id'); // 1 2 3 4 5 6 7

        $categories = $selectedCategories->union($defaultCategories)->toArray();



        // Statistics for Right Panel
        $countries = Country::getAllPlucked();
        $settingSize = $tournament->championshipSettings->count();
        $categorySize = $tournament->championships->count();
        $hanteiLimit = config('options.hanteiLimit');

        $grades = Grade::getAllPlucked();
        $venue = $tournament->venue ?? new Venue;
        $levels = TournamentLevel::getAllPlucked();

        return view('tournaments.edit', compact('tournament', 'levels', 'categories', 'settingSize', 'categorySize', 'grades', 'numCompetitors', 'rules', 'hanteiLimit', 'numTeams', 'countries', 'venue'));

The expression return view('tournaments.edit', compact('tournament', 'levels', 'categories', 'settingSize', 'categorySize', 'grades', 'numCompetitors', 'rules', 'hanteiLimit', 'numTeams', 'countries', 'venue')) returns the type Illuminate\Contracts\View\Factory|Illuminate\View\View which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Update the Tournament in storage.
     *
     * @param TournamentRequest $request
     * @param VenueRequest $venueRequest
     * @param Tournament $tournament
     * @return \Illuminate\Http\JsonResponse
     */
    public function update(TournamentRequest $request, VenueRequest $venueRequest, Tournament $tournament)
    {
        //TODO Shouldn't I have a Policy???
        $venue = $tournament->venue;
        if ($venue == null)
            $venue = new Venue;

        if ($venueRequest->has('venue_name')) {
            $venue->fill($venueRequest->all());
            $venue->save();
        } else {
            $venue = new Venue();
        }
        $res = $request->update($tournament, $venue);

        if ($request->ajax()) {
            $res == 0

The condition $res == 0 is always false.

                ? $result = Response::json(['msg' => trans('msg.tournament_update_error', ['name' => $tournament->name]), 'status' => 'error'])
                : $result = Response::json(['msg' => trans('msg.tournament_update_successful', ['name' => $tournament->name]), 'status' => 'success']);
            return $result;
        } else {
            $res == 0

The condition $res == 0 is always false.

                ? flash()->success(trans('msg.tournament_update_error', ['name' => $tournament->name]))
                : flash()->success(trans('msg.tournament_update_successful', ['name' => $tournament->name]));

Are you sure the usage of flash() is correct as it seems to always return null.

            return redirect(URL::action('TournamentController@edit', $tournament->slug))->with('activeTab', $request->activeTab);

The expression return redirect(Illuminate\Support\Facades\URL::action('TournamentController@edit', $tournament->slug))->with('activeTab', $request->activeTab) also could return the type Illuminate\Http\RedirectResponse|Illuminate\Routing\Redirector which is incompatible with the documented return type Illuminate\Http\JsonResponse.

        }
    }

    /**
     * Remove the Tournament from storage.
     *
     * @param Tournament $tournament
     * @return \Illuminate\Http\JsonResponse
     * @throws \Exception
     */
    public function destroy(Tournament $tournament)
    {
        if ($tournament->delete()) {
            return Response::json(['msg' => Lang::get('msg.tournament_delete_successful', ['name' => $tournament->name]), 'status' => 'success']);
        }
        return Response::json(['msg' => Lang::get('msg.tournament_delete_error', ['name' => $tournament->name]), 'status' => 'error']);
    }

    /**
     * @param $tournamentSlug
     * @return \Illuminate\Http\JsonResponse
     */
    public function restore($tournamentSlug)
    {
        $tournament = Tournament::withTrashed()->whereSlug($tournamentSlug)->first();
        if ($tournament->restore()) {
            return Response::json(['msg' => Lang::get('msg.tournament_restored_successful', ['name' => $tournament->name]), 'status' => 'success']);
        }

        return Response::json(['msg' => Lang::get('msg.tournament_restored_error', ['name' => $tournament->name]), 'status' => 'error']);

    }

    /**
     * Called when a user want to register an open tournament
     * @param Request $request
     * @param Tournament $tournament
     * @return mixed
     * @throws InvitationNeededException
     */
    public function register(Request $request, Tournament $tournament)

The parameter $request is not used and could be removed.

    {

        if (!Auth::check()) {
            Session::flash('message', trans('msg.please_create_account_before_playing', ['tournament' => $tournament->name]));
            return redirect(URL::action('Auth\LoginController@login'));
        }
        if ($tournament->isOpen() && Auth::check()) {
            App::setLocale(Auth::user()->locale);

            $grades = Grade::getAllPlucked();
            $tournament = Tournament::with('championships.category', 'championships.users')->find($tournament->id);
            return view("categories.register", compact('tournament', 'invite', 'currentModelName', 'grades'));
        }

        throw new InvitationNeededException();
    }

    /**
     * Get Deleted Tournaments
     * 
     * @return mixed
     */
    public function getDeleted()
    {
        $tournaments = Auth::user()->tournaments()->with('owner')
        ->onlyTrashed()
        ->latest()
        ->paginate(config('constants.PAGINATION'));

        if (Auth::user()->isSuperAdmin()) {
            $tournaments = Tournament::onlyTrashed()->with('owner')
                ->has('owner')
                ->latest()
                ->paginate(config('constants.PAGINATION'));
        }

        $title = trans('core.tournaments_deleted');
        return view('tournaments.deleted', compact('tournaments', 'title'));
    }


}