ContestAdminController::replyClarification() - Code Metrics - Inspection of "remove useless class" - ZsgsDesign/NOJ - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — dev (b46dca)

by John

created 2019-08-04 18:18 UTC

ContestAdminController::replyClarification() A

↳ Parent: ContestAdminController

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	12
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	16
rs	9.8666

<?php

namespace App\Http\Controllers\Ajax;

use App\Models\ContestModel;
use App\Models\GroupModel;
use App\Models\ResponseModel;
use App\Models\AccountModel;
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Jobs\ProcessSubmission;
use Auth;
use Cache;

class ContestAdminController extends Controller
{
    public function assignMember(Request $request)
    {
        $request->validate([
            'cid' => 'required|integer',
            'uid' => 'required|integer'
        ]);
        $cid = $request->input('cid');
        $uid = $request->input('uid');

        $groupModel = new GroupModel();
        $contestModel = new ContestModel();

        $contest_info = $contestModel->basic($cid);
        if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
            return ResponseModel::err(2001);
        }

        if($groupModel->judgeClearance($contest_info['gid'],$uid) < 2){
            return ResponseModel::err(7004);
        }

        $contestModel->assignMember($cid,$uid);
        return ResponseModel::success(200);
    }

    public function details(Request $request)
    {
        $request->validate([
            'cid' => 'required|integer',
        ]);
        $cid = $request->input('cid');

        $contestModel = new ContestModel();
        $groupModel = new GroupModel();

        $contest_problems = $contestModel->problems($cid);
        $contest_detail = $contestModel->basic($cid);
        $contest_detail['problems'] = $contest_problems;
        $assign_uid = $contest_detail['assign_uid'];
        $clearance = $contestModel->judgeClearance($cid,Auth::user()->id);
        if($clearance != 3){
            return ResponseModel::err(2001);
        }
        if($assign_uid != 0){
            $assignee = $groupModel->userProfile($assign_uid,$contest_detail['gid']);
        }else{
            $assignee = null;
        }
        $ret = [
            'contest_info' => $contest_detail,
            'assignee' => $assignee,
            'is_admin' => $clearance == 3,
        ];
        return ResponseModel::success(200,null,$ret);
    }

    public function rejudge(Request $request)
    {
        $request->validate([
            'cid' => 'required|integer'
        ]);

        $all_data=$request->all();
        if (Auth::user()->id!=1) {
            return ResponseModel::err(2001);
        }

        $contestModel=new ContestModel();
        $rejudgeQueue=$contestModel->getRejudgeQueue($all_data["cid"]);

        foreach ($rejudgeQueue as $r) {
            dispatch(new ProcessSubmission($r))->onQueue($r["oj"]);
        }

        return ResponseModel::success(200);
    }

    public function update(Request $request)
    {
        $request->validate([
            'cid' => 'required|integer',
            'name' => 'required|max:255',
            'problems' => 'required|max:2550',
            'begin_time' => 'required|date',
            'end_time' => 'required|date|after:begin_time',
            'description' => 'string'
        ]);
        $all_data = $request->all();
        $cid = $all_data['cid'];

        $contestModel = new ContestModel();
        if($contestModel->judgeClearance($all_data['cid'],Auth::user()->id) != 3){
            return ResponseModel::err(2001);
        }

        if($contestModel->remainingTime($cid) > 0){
            $problems=explode(",", $all_data["problems"]);
            if (count($problems)>26) {
                return ResponseModel::err(4002);
            }
            $i=0;
            $problemSet=[];
            foreach ($problems as $p) {
                if (!empty($p)) {
                    $i++;
                    $problemSet[]=[
                        "number"=>$i,
                        "pcode"=>$p,
                        "points"=>100
                    ];
                }
            }
            $allow_update = ['name','description','begin_time','end_time'];

            foreach($all_data as $key => $value){
                if(!in_array($key,$allow_update)){
                    unset($all_data[$key]);
                }
            }
            $contestModel->contestUpdate($cid,$all_data,$problemSet);
            return ResponseModel::success(200);
        }else{
            $allow_update = ['name','description'];

            foreach($all_data as $key => $value){
                if(!in_array($key,$allow_update)){
                    unset($all_data[$key]);
                }
            }
            $contestModel->contestUpdate($cid,$all_data,false);
            return ResponseModel::success(200,'
                Successful! However, only the name and description of the match can be changed for the match that has been finished.
            ');
        }

    }

    public function issueAnnouncement(Request $request){
        $request->validate([
            'cid' => 'required|integer',
            'title' => 'required|string|max:250',
            'content' => 'required|string|max:65536',
        ]);

        $all_data=$request->all();

        $contestModel=new ContestModel();
        $clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
        if ($clearance<3) {
            return ResponseModel::err(2001);
        } else {
            return ResponseModel::success(200, null, [
                "ccid" => $contestModel->issueAnnouncement($all_data["cid"], $all_data["title"], $all_data["content"], Auth::user()->id)
            ]);
        }
    }

    public function replyClarification(Request $request){
        $request->validate([
            'cid' => 'required|integer',
            'ccid' => 'required|integer',
            'content' => 'required|string|max:65536',
        ]);

        $all_data=$request->all();

        $contestModel=new ContestModel();
        $clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
        if ($clearance<3) {
            return ResponseModel::err(2001);
        } else {
            return ResponseModel::success(200, null, [
                "line" => $contestModel->replyClarification($all_data["ccid"], $all_data["content"])
            ]);
        }
    }

    public function setClarificationPublic(Request $request){
        $request->validate([
            'cid' => 'required|integer',
            'ccid' => 'required|integer',
            'public' => 'required',
        ]);

        $all_data=$request->all();

        $contestModel=new ContestModel();
        $clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
        if ($clearance<3) {
            return ResponseModel::err(2001);
        } else {
            return ResponseModel::success(200, null, [
                "line" => $contestModel->setClarificationPublic($all_data["ccid"], $all_data["public"])
            ]);
        }
    }

    public function generateContestAccount(Request $request)
    {
        $request->validate([
            'cid' => 'required|integer',
            'ccode' => 'required|min:3|max:10',
            'num' => 'required|integer|max:100'
        ]);

        $all_data=$request->all();

        $groupModel=new GroupModel();
        $contestModel=new ContestModel();
        $verified=$contestModel->isVerified($all_data["cid"]);
        if(!$verified){
            return ResponseModel::err(2001);
        }
        $gid=$contestModel->gid($all_data["cid"]);
        $clearance=$groupModel->judgeClearance($gid, Auth::user()->id);
        if ($clearance<3) {
            return ResponseModel::err(2001);
        }
        $accountModel=new AccountModel();
        $ret=$accountModel->generateContestAccount($all_data["cid"], $all_data["ccode"], $all_data["num"]);
        $cache_data=Cache::tags(['contest', 'account'])->get($all_data["cid"]);
        $cache_data[]=$ret;
        Cache::tags(['contest', 'account'])->put($all_data["cid"], $cache_data);
        return ResponseModel::success(200, null, $ret);
    }
}


1			<?php
2
3			namespace App\Http\Controllers\Ajax;
4
5			use App\Models\ContestModel;
6			use App\Models\GroupModel;
7			use App\Models\ResponseModel;
8			use App\Models\AccountModel;
9			use App\Http\Controllers\Controller;
10			use Illuminate\Http\Request;
11			use App\Jobs\ProcessSubmission;
12			use Auth;
13			use Cache;
14
15			class ContestAdminController extends Controller
16			{
17			public function assignMember(Request $request)
18			{
19			$request->validate([
20			'cid' => 'required\|integer',
21			'uid' => 'required\|integer'
22			]);
23			$cid = $request->input('cid');
24			$uid = $request->input('uid');
25
26			$groupModel = new GroupModel();
27			$contestModel = new ContestModel();
28
29			$contest_info = $contestModel->basic($cid);
30			if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
31			return ResponseModel::err(2001);
32			}
33
34			if($groupModel->judgeClearance($contest_info['gid'],$uid) < 2){
35			return ResponseModel::err(7004);
36			}
37
38			$contestModel->assignMember($cid,$uid);
39			return ResponseModel::success(200);
40			}
41
42			public function details(Request $request)
43			{
44			$request->validate([
45			'cid' => 'required\|integer',
46			]);
47			$cid = $request->input('cid');
48
49			$contestModel = new ContestModel();
50			$groupModel = new GroupModel();
51
52			$contest_problems = $contestModel->problems($cid);
53			$contest_detail = $contestModel->basic($cid);
54			$contest_detail['problems'] = $contest_problems;
55			$assign_uid = $contest_detail['assign_uid'];
56			$clearance = $contestModel->judgeClearance($cid,Auth::user()->id);
57			if($clearance != 3){
58			return ResponseModel::err(2001);
59			}
60			if($assign_uid != 0){
61			$assignee = $groupModel->userProfile($assign_uid,$contest_detail['gid']);
62			}else{
63			$assignee = null;
64			}
65			$ret = [
66			'contest_info' => $contest_detail,
67			'assignee' => $assignee,
68			'is_admin' => $clearance == 3,
69			];
70			return ResponseModel::success(200,null,$ret);
71			}
72
73			public function rejudge(Request $request)
74			{
75			$request->validate([
76			'cid' => 'required\|integer'
77			]);
78
79			$all_data=$request->all();
80			if (Auth::user()->id!=1) {
81			return ResponseModel::err(2001);
82			}
83
84			$contestModel=new ContestModel();
85			$rejudgeQueue=$contestModel->getRejudgeQueue($all_data["cid"]);
86
87			foreach ($rejudgeQueue as $r) {
88			dispatch(new ProcessSubmission($r))->onQueue($r["oj"]);
89			}
90
91			return ResponseModel::success(200);
92			}
93
94			public function update(Request $request)
95			{
96			$request->validate([
97			'cid' => 'required\|integer',
98			'name' => 'required\|max:255',
99			'problems' => 'required\|max:2550',
100			'begin_time' => 'required\|date',
101			'end_time' => 'required\|date\|after:begin_time',
102			'description' => 'string'
103			]);
104			$all_data = $request->all();
105			$cid = $all_data['cid'];
106
107			$contestModel = new ContestModel();
108			if($contestModel->judgeClearance($all_data['cid'],Auth::user()->id) != 3){
109			return ResponseModel::err(2001);
110			}
111
112			if($contestModel->remainingTime($cid) > 0){
113			$problems=explode(",", $all_data["problems"]);
114			if (count($problems)>26) {
115			return ResponseModel::err(4002);
116			}
117			$i=0;
118			$problemSet=[];
119			foreach ($problems as $p) {
120			if (!empty($p)) {
121			$i++;
122			$problemSet[]=[
123			"number"=>$i,
124			"pcode"=>$p,
125			"points"=>100
126			];
127			}
128			}
129			$allow_update = ['name','description','begin_time','end_time'];
130
131			foreach($all_data as $key => $value){
132			if(!in_array($key,$allow_update)){
133			unset($all_data[$key]);
134			}
135			}
136			$contestModel->contestUpdate($cid,$all_data,$problemSet);
137			return ResponseModel::success(200);
138			}else{
139			$allow_update = ['name','description'];
140
141			foreach($all_data as $key => $value){
142			if(!in_array($key,$allow_update)){
143			unset($all_data[$key]);
144			}
145			}
146			$contestModel->contestUpdate($cid,$all_data,false);
147			return ResponseModel::success(200,'
148			Successful! However, only the name and description of the match can be changed for the match that has been finished.
149			');
150			}
151
152			}
153
154			public function issueAnnouncement(Request $request){
155			$request->validate([
156			'cid' => 'required\|integer',
157			'title' => 'required\|string\|max:250',
158			'content' => 'required\|string\|max:65536',
159			]);
160
161			$all_data=$request->all();
162
163			$contestModel=new ContestModel();
164			$clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
165			if ($clearance<3) {
166			return ResponseModel::err(2001);
167			} else {
168			return ResponseModel::success(200, null, [
169			"ccid" => $contestModel->issueAnnouncement($all_data["cid"], $all_data["title"], $all_data["content"], Auth::user()->id)
170			]);
171			}
172			}
173
174			public function replyClarification(Request $request){
175			$request->validate([
176			'cid' => 'required\|integer',
177			'ccid' => 'required\|integer',
178			'content' => 'required\|string\|max:65536',
179			]);
180
181			$all_data=$request->all();
182
183			$contestModel=new ContestModel();
184			$clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
185			if ($clearance<3) {
186			return ResponseModel::err(2001);
187			} else {
188			return ResponseModel::success(200, null, [
189			"line" => $contestModel->replyClarification($all_data["ccid"], $all_data["content"])
190			]);
191			}
192			}
193
194			public function setClarificationPublic(Request $request){
195			$request->validate([
196			'cid' => 'required\|integer',
197			'ccid' => 'required\|integer',
198			'public' => 'required',
199			]);
200
201			$all_data=$request->all();
202
203			$contestModel=new ContestModel();
204			$clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
205			if ($clearance<3) {
206			return ResponseModel::err(2001);
207			} else {
208			return ResponseModel::success(200, null, [
209			"line" => $contestModel->setClarificationPublic($all_data["ccid"], $all_data["public"])
210			]);
211			}
212			}
213
214			public function generateContestAccount(Request $request)
215			{
216			$request->validate([
217			'cid' => 'required\|integer',
218			'ccode' => 'required\|min:3\|max:10',
219			'num' => 'required\|integer\|max:100'
220			]);
221
222			$all_data=$request->all();
223
224			$groupModel=new GroupModel();
225			$contestModel=new ContestModel();
226			$verified=$contestModel->isVerified($all_data["cid"]);
227			if(!$verified){
228			return ResponseModel::err(2001);
229			}
230			$gid=$contestModel->gid($all_data["cid"]);
231			$clearance=$groupModel->judgeClearance($gid, Auth::user()->id);
232			if ($clearance<3) {
233			return ResponseModel::err(2001);
234			}
235			$accountModel=new AccountModel();
236			$ret=$accountModel->generateContestAccount($all_data["cid"], $all_data["ccode"], $all_data["num"]);
237			$cache_data=Cache::tags(['contest', 'account'])->get($all_data["cid"]);
238			$cache_data[]=$ret;
239			Cache::tags(['contest', 'account'])->put($all_data["cid"], $cache_data);
240			return ResponseModel::success(200, null, $ret);
241			}
242			}
243

ZsgsDesign / NOJ

Branch — dev (b46dca)

ContestAdminController::replyClarification() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like