ContestAdminController::rejudge() - Code Metrics - Inspection of "Merge pull request #390 from ZsgsDesign/dev" - ZsgsDesign/NOJ - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b831b6...96f132 )

by John

created 2020-04-30 19:56 UTC

ContestAdminController::rejudge() A

↳ Parent: ContestAdminController

Complexity

Conditions	3
Paths	3

Size

Total Lines	19
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	10
c	1
b	0
f	0
nc	3
nop	1
dl	0
loc	19
rs	9.9332

<?php

namespace App\Http\Controllers\Ajax;

use App\Models\ContestModel;
use App\Models\Eloquent\ContestModel as EloquentContestModel;
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 Illuminate\Validation\Validator;
use Illuminate\Support\Facades\Storage;
use App\Jobs\GeneratePDF;
use App\Jobs\AntiCheat;
use Log;
use Auth;
use Cache;
use Response;

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);
    }

    public function getScrollBoardData(Request $request)
    {
        $request->validate([
            'cid' => 'required|integer',
        ]);
        $cid = $request->input('cid');
        $contestModel = new ContestModel();
        if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
            return ResponseModel::err(2001);
        }
        if($contestModel->remainingTime($cid) >= 0){
            return ResponseModel::err(4008);
        }
        if($contestModel->basic($cid)['froze_length'] == 0){
            return ResponseModel::err(4009);
        }
        $data = $contestModel->getScrollBoardData($cid);
        return ResponseModel::success(200, null, $data);
    }

    public function downloadCode(Request $request)
    {
        $request->validate([
            "cid"=>"required|integer",
        ]);
        $cid = $request->input('cid');
        $groupModel=new GroupModel();

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

        $zip_name=$contestModel->zipName($cid);
        if(!(Storage::disk("private")->exists("contestCodeZip/$cid/".$cid.".zip"))){
            $contestModel->GenerateZip("contestCodeZip/$cid/",$cid,"contestCode/$cid/",$zip_name);
        }

        $files=Storage::disk("private")->files("contestCodeZip/$cid/");
        response()->download(base_path("/storage/app/private/".$files[0]),$zip_name,[
            "Content-Transfer-Encoding" => "binary",
            "Content-Type"=>"application/octet-stream",
            "filename"=>$zip_name
        ])->send();

    }

    public function downloadPlagiarismReport(Request $request)
    {
        $request->validate([
            "cid"=>"required|integer",
        ]);
        $cid = $request->input('cid');
        $contestModel=new ContestModel();

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

        return response()->download(storage_path("app/contest/anticheat/$cid/report/report.zip"), "$name Code Plagiarism.zip");
    }

    public function generatePDF(Request $request)
    {
        $request->validate([
            "cid"=>"required|integer",
            "config.cover"=>"required",
            "config.advice"=>"required",
        ]);
        $cid = $request->input('cid');
        $config = [
            'cover'=>$request->input('config.cover')=='true',
            'advice'=>$request->input('config.advice')=='true'
        ];
        $contestModel=new ContestModel();
        if ($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
            return ResponseModel::err(2001);
        }
        if(!is_null(Cache::tags(['contest', 'admin', 'PDFGenerate'])->get($cid))) return ResponseModel::err(8001);
        $generateProcess=new GeneratePDF($cid,$config);
        dispatch($generateProcess)->onQueue('normal');
        Cache::tags(['contest', 'admin', 'PDFGenerate'])->put($cid, $generateProcess->getJobStatusId());
        return ResponseModel::success(200, null, [
            'JobStatusId'=>$generateProcess->getJobStatusId()
        ]);
    }

    public function anticheat(Request $request)
    {
        $request->validate([
            "cid"=>"required|integer"
        ]);
        $cid = $request->input('cid');
        $contestModel=new ContestModel();
        if ($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
            return ResponseModel::err(2001);
        }
        if(!is_null(Cache::tags(['contest', 'admin', 'anticheat'])->get($cid))) return ResponseModel::err(8001);
        if(EloquentContestModel::find($cid)->isJudgingComplete()) {
            $anticheatProcess=new AntiCheat($cid);
            dispatch($anticheatProcess)->onQueue('normal');
            Cache::tags(['contest', 'admin', 'anticheat'])->put($cid, $anticheatProcess->getJobStatusId());
            return ResponseModel::success(200, null, [
                'JobStatusId'=>$anticheatProcess->getJobStatusId()
            ]);
        }
        return ResponseModel::err(4010);
    }
}


1			<?php
2
3			namespace App\Http\Controllers\Ajax;
4
5			use App\Models\ContestModel;
6			use App\Models\Eloquent\ContestModel as EloquentContestModel;
7			use App\Models\GroupModel;
8			use App\Models\ResponseModel;
9			use App\Models\AccountModel;
10			use App\Http\Controllers\Controller;
11			use Illuminate\Http\Request;
12			use App\Jobs\ProcessSubmission;
13			use Illuminate\Validation\Validator;
14			use Illuminate\Support\Facades\Storage;
15			use App\Jobs\GeneratePDF;
16			use App\Jobs\AntiCheat;
17			use Log;
18			use Auth;
19			use Cache;
20			use Response;
21
22			class ContestAdminController extends Controller
23			{
24			public function assignMember(Request $request)
25			{
26			$request->validate([
27			'cid' => 'required\|integer',
28			'uid' => 'required\|integer'
29			]);
30			$cid = $request->input('cid');
31			$uid = $request->input('uid');
32
33			$groupModel = new GroupModel();
34			$contestModel = new ContestModel();
35
36			$contest_info = $contestModel->basic($cid);
37			if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
38			return ResponseModel::err(2001);
39			}
40
41			if($groupModel->judgeClearance($contest_info['gid'],$uid) < 2){
42			return ResponseModel::err(7004);
43			}
44
45			$contestModel->assignMember($cid,$uid);
46			return ResponseModel::success(200);
47			}
48
49			public function details(Request $request)
50			{
51			$request->validate([
52			'cid' => 'required\|integer',
53			]);
54			$cid = $request->input('cid');
55
56			$contestModel = new ContestModel();
57			$groupModel = new GroupModel();
58
59			$contest_problems = $contestModel->problems($cid);
60			$contest_detail = $contestModel->basic($cid);
61			$contest_detail['problems'] = $contest_problems;
62			$assign_uid = $contest_detail['assign_uid'];
63			$clearance = $contestModel->judgeClearance($cid,Auth::user()->id);
64			if($clearance != 3){
65			return ResponseModel::err(2001);
66			}
67			if($assign_uid != 0){
68			$assignee = $groupModel->userProfile($assign_uid,$contest_detail['gid']);
69			}else{
70			$assignee = null;
71			}
72			$ret = [
73			'contest_info' => $contest_detail,
74			'assignee' => $assignee,
75			'is_admin' => $clearance == 3,
76			];
77			return ResponseModel::success(200,null,$ret);
78			}
79
80			public function rejudge(Request $request)
81			{
82			$request->validate([
83			'cid' => 'required\|integer'
84			]);
85
86			$all_data=$request->all();
87			if (Auth::user()->id!=1) {
88			return ResponseModel::err(2001);
89			}
90
91			$contestModel=new ContestModel();
92			$rejudgeQueue=$contestModel->getRejudgeQueue($all_data["cid"]);
93
94			foreach ($rejudgeQueue as $r) {
95			dispatch(new ProcessSubmission($r))->onQueue($r["oj"]);
96			}
97
98			return ResponseModel::success(200);
99			}
100
101			public function update(Request $request)
102			{
103			$request->validate([
104			'cid' => 'required\|integer',
105			'name' => 'required\|max:255',
106			'problems' => 'required\|max:2550',
107			'begin_time' => 'required\|date',
108			'end_time' => 'required\|date\|after:begin_time',
109			'description' => 'string'
110			]);
111			$all_data = $request->all();
112			$cid = $all_data['cid'];
113
114			$contestModel = new ContestModel();
115			if($contestModel->judgeClearance($all_data['cid'],Auth::user()->id) != 3){
116			return ResponseModel::err(2001);
117			}
118
119			if($contestModel->remainingTime($cid) > 0){
120			$problems=explode(",", $all_data["problems"]);
121			if (count($problems)>26) {
122			return ResponseModel::err(4002);
123			}
124			$i=0;
125			$problemSet=[];
126			foreach ($problems as $p) {
127			if (!empty($p)) {
128			$i++;
129			$problemSet[]=[
130			"number"=>$i,
131			"pcode"=>$p,
132			"points"=>100
133			];
134			}
135			}
136			$allow_update = ['name','description','begin_time','end_time'];
137
138			foreach($all_data as $key => $value){
139			if(!in_array($key,$allow_update)){
140			unset($all_data[$key]);
141			}
142			}
143			$contestModel->contestUpdate($cid,$all_data,$problemSet);
144			return ResponseModel::success(200);
145			}else{
146			$allow_update = ['name','description'];
147
148			foreach($all_data as $key => $value){
149			if(!in_array($key,$allow_update)){
150			unset($all_data[$key]);
151			}
152			}
153			$contestModel->contestUpdate($cid,$all_data,false);
154			return ResponseModel::success(200,'
155			Successful! However, only the name and description of the match can be changed for the match that has been finished.
156			');
157			}
158
159			}
160
161			public function issueAnnouncement(Request $request){
162			$request->validate([
163			'cid' => 'required\|integer',
164			'title' => 'required\|string\|max:250',
165			'content' => 'required\|string\|max:65536',
166			]);
167
168			$all_data=$request->all();
169
170			$contestModel=new ContestModel();
171			$clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
172			if ($clearance<3) {
173			return ResponseModel::err(2001);
174			} else {
175			return ResponseModel::success(200, null, [
176			"ccid" => $contestModel->issueAnnouncement($all_data["cid"], $all_data["title"], $all_data["content"], Auth::user()->id)
177			]);
178			}
179			}
180
181			public function replyClarification(Request $request){
182			$request->validate([
183			'cid' => 'required\|integer',
184			'ccid' => 'required\|integer',
185			'content' => 'required\|string\|max:65536',
186			]);
187
188			$all_data=$request->all();
189
190			$contestModel=new ContestModel();
191			$clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
192			if ($clearance<3) {
193			return ResponseModel::err(2001);
194			} else {
195			return ResponseModel::success(200, null, [
196			"line" => $contestModel->replyClarification($all_data["ccid"], $all_data["content"])
197			]);
198			}
199			}
200
201			public function setClarificationPublic(Request $request){
202			$request->validate([
203			'cid' => 'required\|integer',
204			'ccid' => 'required\|integer',
205			'public' => 'required',
206			]);
207
208			$all_data=$request->all();
209
210			$contestModel=new ContestModel();
211			$clearance=$contestModel->judgeClearance($all_data["cid"], Auth::user()->id);
212			if ($clearance<3) {
213			return ResponseModel::err(2001);
214			} else {
215			return ResponseModel::success(200, null, [
216			"line" => $contestModel->setClarificationPublic($all_data["ccid"], $all_data["public"])
217			]);
218			}
219			}
220
221			public function generateContestAccount(Request $request)
222			{
223			$request->validate([
224			'cid' => 'required\|integer',
225			'ccode' => 'required\|min:3\|max:10',
226			'num' => 'required\|integer\|max:100'
227			]);
228
229			$all_data=$request->all();
230
231			$groupModel=new GroupModel();
232			$contestModel=new ContestModel();
233			$verified=$contestModel->isVerified($all_data["cid"]);
234			if(!$verified){
235			return ResponseModel::err(2001);
236			}
237			$gid=$contestModel->gid($all_data["cid"]);
238			$clearance=$groupModel->judgeClearance($gid, Auth::user()->id);
239			if ($clearance<3) {
240			return ResponseModel::err(2001);
241			}
242			$accountModel=new AccountModel();
243			$ret=$accountModel->generateContestAccount($all_data["cid"], $all_data["ccode"], $all_data["num"]);
244			$cache_data=Cache::tags(['contest', 'account'])->get($all_data["cid"]);
245			$cache_data[]=$ret;
246			Cache::tags(['contest', 'account'])->put($all_data["cid"], $cache_data);
247			return ResponseModel::success(200, null, $ret);
248			}
249
250			public function getScrollBoardData(Request $request)
251			{
252			$request->validate([
253			'cid' => 'required\|integer',
254			]);
255			$cid = $request->input('cid');
256			$contestModel = new ContestModel();
257			if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
258			return ResponseModel::err(2001);
259			}
260			if($contestModel->remainingTime($cid) >= 0){
261			return ResponseModel::err(4008);
262			}
263			if($contestModel->basic($cid)['froze_length'] == 0){
264			return ResponseModel::err(4009);
265			}
266			$data = $contestModel->getScrollBoardData($cid);
267			return ResponseModel::success(200, null, $data);
268			}
269
270			public function downloadCode(Request $request)
271			{
272			$request->validate([
273			"cid"=>"required\|integer",
274			]);
275			$cid = $request->input('cid');
276			$groupModel=new GroupModel();
			0 ignored issues – show Unused Code introduced 2020-04-30 20:02 UTC by Report Bug Copy Issue Report The assignment to `$groupModel` is dead and can be removed. Loading history...
277			$contestModel=new ContestModel();
278			if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
279			return ResponseModel::err(2001);
280			}
281
282			$zip_name=$contestModel->zipName($cid);
283			if(!(Storage::disk("private")->exists("contestCodeZip/$cid/".$cid.".zip"))){
284			$contestModel->GenerateZip("contestCodeZip/$cid/",$cid,"contestCode/$cid/",$zip_name);
285			}
286
287			$files=Storage::disk("private")->files("contestCodeZip/$cid/");
288			response()->download(base_path("/storage/app/private/".$files[0]),$zip_name,[
289			"Content-Transfer-Encoding" => "binary",
290			"Content-Type"=>"application/octet-stream",
291			"filename"=>$zip_name
292			])->send();
293
294			}
295
296			public function downloadPlagiarismReport(Request $request)
297			{
298			$request->validate([
299			"cid"=>"required\|integer",
300			]);
301			$cid = $request->input('cid');
302			$contestModel=new ContestModel();
303
304			if($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
305			return ResponseModel::err(2001);
306			}
307			$name=$contestModel->basic($cid)["name"];
308
309			return response()->download(storage_path("app/contest/anticheat/$cid/report/report.zip"), "$name Code Plagiarism.zip");
310			}
311
312			public function generatePDF(Request $request)
313			{
314			$request->validate([
315			"cid"=>"required\|integer",
316			"config.cover"=>"required",
317			"config.advice"=>"required",
318			]);
319			$cid = $request->input('cid');
320			$config = [
321			'cover'=>$request->input('config.cover')=='true',
322			'advice'=>$request->input('config.advice')=='true'
323			];
324			$contestModel=new ContestModel();
325			if ($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
326			return ResponseModel::err(2001);
327			}
328			if(!is_null(Cache::tags(['contest', 'admin', 'PDFGenerate'])->get($cid))) return ResponseModel::err(8001);
329			$generateProcess=new GeneratePDF($cid,$config);
330			dispatch($generateProcess)->onQueue('normal');
331			Cache::tags(['contest', 'admin', 'PDFGenerate'])->put($cid, $generateProcess->getJobStatusId());
332			return ResponseModel::success(200, null, [
333			'JobStatusId'=>$generateProcess->getJobStatusId()
334			]);
335			}
336
337			public function anticheat(Request $request)
338			{
339			$request->validate([
340			"cid"=>"required\|integer"
341			]);
342			$cid = $request->input('cid');
343			$contestModel=new ContestModel();
344			if ($contestModel->judgeClearance($cid,Auth::user()->id) != 3){
345			return ResponseModel::err(2001);
346			}
347			if(!is_null(Cache::tags(['contest', 'admin', 'anticheat'])->get($cid))) return ResponseModel::err(8001);
348			if(EloquentContestModel::find($cid)->isJudgingComplete()) {
349			$anticheatProcess=new AntiCheat($cid);
350			dispatch($anticheatProcess)->onQueue('normal');
351			Cache::tags(['contest', 'admin', 'anticheat'])->put($cid, $anticheatProcess->getJobStatusId());
352			return ResponseModel::success(200, null, [
353			'JobStatusId'=>$anticheatProcess->getJobStatusId()
354			]);
355			}
356			return ResponseModel::err(4010);
357			}
358			}
359

ZsgsDesign / NOJ

Push — master ( b831b6...96f132 )

ContestAdminController::rejudge() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like