ProblemModel::removeSolution() - Code Metrics - ZsgsDesign/NOJ - Measure and Improve Code Quality continuously with Scrutinizer

ProblemModel::removeSolution() A
last analyzed 2021-11-04 16:36 UTC

↳ Parent: ProblemModel

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	2
dl	0
loc	7
rs	10
c	0
b	0
f	0

<?php

namespace App\Models;

use GrahamCampbell\Markdown\Facades\Markdown;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;
use App\Models\Submission\SubmissionModel;
use Illuminate\Support\Str;
use App\Models\Eloquent\OJ;
use Cache;

class ProblemModel extends Model
{
    protected $table='problem';
    protected $primaryKey='pid';
    const UPDATED_AT="update_date";

    public function detail($pcode, $cid=null)
    {
        $prob_detail=DB::table($this->table)->where("pcode", $pcode)->first();
        // [Depreciated] Joint Query was depreciated here for code maintenance reasons
        if (!is_null($prob_detail)) {
            if ($prob_detail["force_raw"]) {
                $prob_detail["parsed"]=[
                    "description"=>$prob_detail["description"],
                    "input"=>$prob_detail["input"],
                    "output"=>$prob_detail["output"],
                    "note"=>$prob_detail["note"],
                    "file"=>$prob_detail["file"]
                ];
            } elseif ($prob_detail["markdown"]) {
                $prob_detail["parsed"]=[
                    "description"=>clean(convertMarkdownToHtml($prob_detail["description"])),
                    "input"=>clean(convertMarkdownToHtml($prob_detail["input"])),
                    "output"=>clean(convertMarkdownToHtml($prob_detail["output"])),
                    "note"=>clean(convertMarkdownToHtml($prob_detail["note"])),
                    "file"=>clean(convertMarkdownToHtml($prob_detail["file"]))
                ];
            } else {
                $prob_detail["parsed"]=[
                    "description"=>$prob_detail["description"],
                    "input"=>$prob_detail["input"],
                    "output"=>$prob_detail["output"],
                    "note"=>$prob_detail["note"],
                    "file"=>$prob_detail["file"]
                ];
            }
            $prob_detail["pdf"]=false;
            $prob_detail["viewerShow"]=false;
            $prob_detail["file_ext"]=null;
            if ($prob_detail['file'] && !blank($prob_detail['file_url'])) {
                $prob_detail["file_ext"]=explode('.', basename($prob_detail['file_url']));
                $prob_detail["file_ext"]=end($prob_detail["file_ext"]);
                $prob_detail["pdf"]=Str::is("*.pdf", basename($prob_detail['file_url']));
                $prob_detail["viewerShow"]=blank($prob_detail["parsed"]["description"]) &&
                                            blank($prob_detail["parsed"]["input"]) &&
                                            blank($prob_detail["parsed"]["output"]) &&
                                            blank($prob_detail["parsed"]["note"]);
            }
            $prob_detail["update_date"]=date_format(date_create($prob_detail["update_date"]), 'm/d/Y H:i:s');
            $prob_detail["oj_detail"]=DB::table("oj")->where("oid", $prob_detail["OJ"])->first();
            $prob_detail["samples"]=DB::table("problem_sample")->where("pid", $prob_detail["pid"])->get()->all();
            $prob_detail["tags"]=DB::table("problem_tag")->where("pid", $prob_detail["pid"])->get()->all();
            if ($cid) {
                $frozen_time=strtotime(DB::table("contest")->where(["cid"=>$cid])->select("end_time")->first()["end_time"]);
                $prob_stat=DB::table("submission")->select(
                    DB::raw("count(sid) as submission_count"),
                    DB::raw("sum(verdict='accepted') as passed_count"),
                    DB::raw("sum(verdict='accepted')/count(sid)*100 as ac_rate")
                )->where([
                    "pid"=>$prob_detail["pid"],
                    "cid"=>$cid,
                ])->where("submission_date", "<", $frozen_time)->first();
                $prob_detail['vcid']=DB::table("contest")->where(["cid"=>$cid])->select("vcid")->first()['vcid'];
                $prob_detail["points"]=DB::table("contest_problem")->where(["cid"=>$cid, "pid"=>$prob_detail["pid"]])->select("points")->first()["points"];
            } else {
                $prob_stat=DB::table("submission")->select(
                    DB::raw("count(sid) as submission_count"),
                    DB::raw("sum(verdict='accepted') as passed_count"),
                    DB::raw("sum(verdict='accepted')/count(sid)*100 as ac_rate")
                )->where(["pid"=>$prob_detail["pid"]])->first();
                $prob_detail['vcid']=null;
                $prob_detail["points"]=0;
            }
            if ($prob_stat["submission_count"]==0) {
                $prob_detail["submission_count"]=0;
                $prob_detail["passed_count"]=0;
                $prob_detail["ac_rate"]=0;
            } else {
                $prob_detail["submission_count"]=$prob_stat["submission_count"];
                $prob_detail["passed_count"]=$prob_stat["passed_count"];
                $prob_detail["ac_rate"]=round($prob_stat["ac_rate"], 2);
            }
        }
        return $prob_detail;
    }

    public function basic($pid)
    {
        return DB::table($this->table)->where("pid", $pid)->first();
    }

    public function tags()
    {
        return DB::table("problem_tag")->groupBy('tag')->select("tag", DB::raw('count(*) as tag_count'))->orderBy('tag_count', 'desc')->limit(12)->get()->all();
    }

    public function ojs()
    {
        return DB::table("oj")->where("status", 1)->orderBy('oid', 'asc')->get()->all();
    }

    public function ojdetail($oid)
    {
        return DB::table("oj")->where('oid', $oid)->first();
    }

    public function solutionList($pid, $uid=null)
    {
        if (is_null($uid)) {
            $details=DB::table("problem_solution")->join(
                "users",
                "id",
                "=",
                "problem_solution.uid"
            )->where([
                'problem_solution.pid'=>$pid,
                'problem_solution.audit'=>1
            ])->orderBy(
                "problem_solution.votes",
                "desc"
            )->get()->all();
        } else {
            $votes=DB::table("problem_solution_vote")->where([
                "uid"=>$uid
            ])->get()->all();
            foreach ($votes as $v) {
                $userVotes[$v["psoid"]]=$v["type"];
            }
            $details=DB::table("problem_solution")->join(
                "users",
                "id",
                "=",
                "problem_solution.uid"
            )->where([
                'problem_solution.pid'=>$pid,
                'problem_solution.audit'=>1
            ])->select([
                "problem_solution.psoid as psoid",
                "problem_solution.uid as uid",
                "problem_solution.pid as pid",
                "problem_solution.content as content",
                "problem_solution.audit as audit",
                "problem_solution.votes as votes",
                "problem_solution.created_at as created_at",
                "problem_solution.updated_at as updated_at",
                "avatar",
                "name"
            ])->orderBy("problem_solution.votes", "desc")->get()->all();
            foreach ($details as &$d) {
                $d["type"]=isset($userVotes[$d["psoid"]]) ? $userVotes[$d["psoid"]] : null;

            }
            unset($d);
        }
        foreach ($details as &$d) {
            $d["content_parsed"]=clean(convertMarkdownToHtml($d["content"]));
        }
        return $details;
    }

    public function solution($pid, $uid)
    {
        $details=DB::table("problem_solution")->join("users", "id", "=", "uid")->where(['pid'=>$pid, 'uid'=>$uid])->first();
        return $details;
    }

    public function addSolution($pid, $uid, $content)
    {
        $details=DB::table("problem_solution")->where(['pid'=>$pid, 'uid'=>$uid])->first();
        if (empty($details)) {
            DB::table("problem_solution")->insert([
                "uid"=>$uid,
                "pid"=>$pid,
                "content"=>$content,
                "votes"=>0,
                "audit"=>$this->inteliAudit($uid, $content),
                "created_at"=>date("Y-m-d H:i:s"),
                "updated_at"=>date("Y-m-d H:i:s"),
            ]);
            return true;
        }
        return false;
    }

    private function inteliAudit($uid, $content)
    {
        if (strpos($content, '```')!==false) {
            $userSolutionHistory=DB::table("problem_solution")->where(['uid'=>$uid])->orderByDesc('updated_at')->first();
            if (!empty($userSolutionHistory) && $userSolutionHistory["audit"]==1) {
                return 1;
            }
        }
        return 0;
    }

    public function voteSolution($psoid, $uid, $type)
    {
        $val=$type ? 1 : -1;
        $details=DB::table("problem_solution")->where(['psoid'=>$psoid])->first();
        if (empty($details)) {
            return ["ret"=>false];
        }

        $userVote=DB::table("problem_solution_vote")->where(['uid'=>$uid, "psoid"=>$psoid])->first();

        if (!empty($userVote)) {
            DB::table("problem_solution_vote")->where(['uid'=>$uid, "psoid"=>$psoid])->delete();
            if ($userVote["type"]==$type) {
                DB::table("problem_solution")->where([
                    'psoid'=>$psoid
                ])->update([
                    "votes"=>$details["votes"]+($userVote["type"]==1 ?-1 : 1),
                ]);
                return ["ret"=>true, "votes"=>$details["votes"]+($userVote["type"]==1 ?-1 : 1), "select"=>-1]; //disvote
            } elseif ($userVote["type"]==1) {
                $val--;
            } else {
                $val++;
            }
        }

        DB::table("problem_solution")->where([
            'psoid'=>$psoid
        ])->update([
            "votes"=>$details["votes"]+$val,
        ]);

        DB::table("problem_solution_vote")->insert([
            "uid"=>$uid,
            "psoid"=>$psoid,
            "type"=>$type,
        ]);

        return ["ret"=>true, "votes"=>$details["votes"]+$val, "select"=>$type];
    }

    public function removeSolution($psoid, $uid)
    {
        if (empty(DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->first())) {
            return false;
        }
        DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->delete();
        return true;
    }

    public function updateSolution($psoid, $uid, $content)
    {
        if (empty(DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->first())) {
            return false;
        }
        DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->update([
            "content"=>$content,
            "audit"=>$this->inteliAudit($uid, $content),
            "updated_at"=>date("Y-m-d H:i:s"),
        ]);
        return true;
    }

    public function isBlocked($pid, $cid=null)
    {
        $conflictContests=DB::table("contest")
                            ->join("contest_problem", "contest.cid", "=", "contest_problem.cid")
                            ->where("end_time", ">", date("Y-m-d H:i:s"))
                            ->where(["verified"=>1, "pid"=>$pid])
                            ->select(["contest_problem.cid as cid"])
                            ->get()
                            ->all();
        if (empty($conflictContests)) {
            return false;
        }
        foreach ($conflictContests as $c) {
            if ($cid==$c["cid"]) {
                return false;
            }
        }
        // header("HTTP/1.1 403 Forbidden");
        // exit();
        return true;
    }

    public function list($filter, $uid=null)
    {
        // $prob_list = DB::table($this->table)->select("pid","pcode","title")->get()->all(); // return a array
        $submissionModel=new SubmissionModel();
        $preQuery=DB::table($this->table)->where('hide', '=', 0);
        if ($filter['oj']) {
            $OJ=OJ::find($filter['oj']);
            if (blank($OJ) || !$OJ->status) {
                return null;
            }
            $preQuery=$preQuery->where(["OJ"=>$filter['oj']]);
        }
        if ($filter['tag']) {
            $preQuery=$preQuery->join("problem_tag", "problem.pid", "=", "problem_tag.pid")->where(["tag"=>$filter['tag']]);
        }
        $paginator=$preQuery->select("problem.pid as pid", "pcode", "title")->orderBy(
            "OJ",
            "ASC"
        )->orderBy(
            "order_index",
            "ASC"
        )->orderBy(
            DB::raw("length(contest_id)"),
            "ASC"
        )->orderBy(
            "contest_id",
            "ASC"
        )->orderBy(
            DB::raw("length(index_id)"),
            "ASC"
        )->orderBy(
            "index_id",
            "ASC"
        )->orderBy(
            "pcode",
            "ASC"
        )->paginate(max(config('pagination.problem.per_page'), 1));
        $prob_list=$paginator->all();

        if (empty($prob_list)) {
            return null;
        }
        foreach ($prob_list as &$p) {
            $prob_stat=DB::table("submission")->select(
                DB::raw("count(sid) as submission_count"),
                DB::raw("sum(verdict='accepted') as passed_count"),
                DB::raw("sum(verdict='accepted')/count(sid)*100 as ac_rate")
            )->where(["pid"=>$p["pid"]])->first();
            if ($prob_stat["submission_count"]==0) {
                $p["submission_count"]=0;
                $p["passed_count"]=0;
                $p["ac_rate"]=0;
            } else {
                $p["submission_count"]=$prob_stat["submission_count"];
                $p["passed_count"]=$prob_stat["passed_count"];
                $p["ac_rate"]=round($prob_stat["ac_rate"], 2);
            }
            if (!is_null($uid)) {
                $prob_status=$submissionModel->getProblemStatus($p["pid"], $uid);
                if (empty($prob_status)) {
                    $p["prob_status"]=[
                        "icon"=>"checkbox-blank-circle-outline",
                        "color"=>"wemd-grey-text"
                    ];
                } else {
                    $p["prob_status"]=[
                        "icon"=>$prob_status["verdict"]=="Accepted" ? "checkbox-blank-circle" : "cisco-webex",
                        "color"=>$prob_status["color"]
                    ];
                }
            } else {
                $p["prob_status"]=[
                    "icon"=>"checkbox-blank-circle-outline",
                    "color"=>"wemd-grey-text"
                ];
            }
        }
        return [
            'paginator' => $paginator,
            'problems' => $prob_list,
        ];
    }

    public function existPCode($pcode)
    {
        $temp=DB::table($this->table)->where(["pcode"=>$pcode])->select("pcode")->first();
        return empty($temp) ? null : $temp["pcode"];
    }

    public function pid($pcode)
    {
        $temp=DB::table($this->table)->where(["pcode"=>$pcode])->select("pid")->first();
        return empty($temp) ? 0 : $temp["pid"];
    }

    public function pcode($pid)
    {
        $temp=DB::table($this->table)->where(["pid"=>$pid])->select("pcode")->first();
        return empty($temp) ? 0 : $temp["pcode"];
    }

    public function ocode($pid)
    {
        $temp=DB::table($this->table)->where(["pid"=>$pid])->select("OJ as oid")->first();
        return empty($temp) ? null : DB::table("oj")->where(["oid"=>$temp["oid"]])->select("ocode")->first()["ocode"];
    }

    public function oid($pid)
    {
        return DB::table($this->table)->where(["pid"=>$pid])->select("OJ as oid")->first()["oid"];
    }

    public function clearTags($pid)
    {
        DB::table("problem_tag")->where(["pid"=>$pid])->delete();
        return true;
    }

    public function addTags($pid, $tag)
    {
        DB::table("problem_tag")->insert(["pid"=>$pid, "tag"=>$tag]);
        return true;
    }

    public function getSolvedCount($oid)
    {
        return DB::table($this->table)->select("pid", "solved_count")->where(["OJ"=>$oid])->get()->all();
    }

    public function updateDifficulty($pid, $diff_level)
    {
        DB::table("problem_tag")->where(["pid"=>$pid])->update(["difficulty"=>$diff_level]);
        return true;
    }

    public function insertProblem($data)
    {
        $info=array_merge([
            'difficulty'=>-1,
            'update_date'=>date("Y-m-d H:i:s"),
        ], collect($data)->only([
            'file',
            'file_url',
            'title',
            'time_limit',
            'memory_limit',
            'OJ',
            'description',
            'input',
            'output',
            'note',
            'input_type',
            'output_type',
            'pcode',
            'contest_id',
            'index_id',
            'origin',
            'source',
            'solved_count',
            'tot_score',
            'partial',
            'markdown',
            'special_compiler',
            'order_index',
        ])->toArray());

        $pid=DB::table($this->table)->insertGetId($info);

        if (!empty($data["sample"])) {
            foreach ($data["sample"] as $d) {
                if (!isset($d['sample_note'])) {
                    $d['sample_note']=null;
                }
                DB::table("problem_sample")->insert([
                    'pid'=>$pid,
                    'sample_input'=>$d['sample_input'],
                    'sample_output'=>$d['sample_output'],
                    'sample_note'=>$d['sample_note'],
                ]);
            }
        }

        return $pid;
    }

    public function updateProblem($data)
    {
        DB::table($this->table)->where(["pcode"=>$data['pcode']])->update(array_merge([
            'difficulty'=>-1,
            'update_date'=>date("Y-m-d H:i:s"),
        ], collect($data)->only([
            'file',
            'file_url',
            'title',
            'time_limit',
            'memory_limit',
            'OJ',
            'description',
            'input',
            'output',
            'note',
            'input_type',
            'output_type',
            'contest_id',
            'index_id',
            'origin',
            'source',
            'solved_count',
            'tot_score',
            'partial',
            'markdown',
            'special_compiler',
            'order_index',
        ])->toArray()));

        $pid=$this->pid($data['pcode']);

        DB::table("problem_sample")->where(["pid"=>$pid])->delete();

        if (!empty($data["sample"])) {
            foreach ($data["sample"] as $d) {
                if (!isset($d['sample_note'])) {
                    $d['sample_note']=null;
                }
                DB::table("problem_sample")->insert([
                    'pid'=>$pid,
                    'sample_input'=>$d['sample_input'],
                    'sample_output'=>$d['sample_output'],
                    'sample_note'=>$d['sample_note'],
                ]);
            }
        }

        return $pid;
    }

    public function discussionList($pid)
    {
        $paginator=DB::table('problem_discussion')->join(
            "users",
            "id",
            "=",
            "problem_discussion.uid"
        )->where([
            'problem_discussion.pid'=>$pid,
            'problem_discussion.audit'=>1
        ])->orderBy(
            'problem_discussion.created_at',
            'desc'
        )->select([
            'problem_discussion.pdid',
            'problem_discussion.title',
            'problem_discussion.updated_at',
            'users.avatar',
            'users.name',
            'users.id as uid'
        ])->paginate(15);
        $list=$paginator->all();
        foreach ($list as &$l) {
            $l['updated_at']=formatHumanReadableTime($l['updated_at']);
            $l['comment_count']=DB::table('problem_discussion_comment')->where('pdid', '=', $l['pdid'])->count();
        }
        return [
            'paginator' => $paginator,
            'list' => $list,
        ];
    }

    public function discussionDetail($pdid)
    {
        $main=DB::table('problem_discussion')->join(
            "users",
            "id",
            "=",
            "problem_discussion.uid"
        )->where(
            'problem_discussion.pdid',
            '=',
            $pdid
        )->select([
            'problem_discussion.pdid',
            'problem_discussion.title',
            'problem_discussion.content',
            'problem_discussion.votes',
            'problem_discussion.created_at',
            'users.avatar',
            'users.name',
            'users.id as uid'
        ])->get()->first();
        $main['created_at']=formatHumanReadableTime($main['created_at']);
        $main['content']=clean(Markdown::convertToHtml($main["content"]));

        $comment_count=DB::table('problem_discussion_comment')->where('pdid', '=', $pdid)->count();

        $paginator=DB::table('problem_discussion_comment')->join(
            "users",
            "id",
            "=",
            "problem_discussion_comment.uid"
        )->where([
            'problem_discussion_comment.pdid'=>$pdid,
            'problem_discussion_comment.reply_id'=>null,
            'problem_discussion_comment.audit'=>1
        ])->select([
            'problem_discussion_comment.pdcid',
            'problem_discussion_comment.pdid',
            'problem_discussion_comment.content',
            'problem_discussion_comment.votes',
            'problem_discussion_comment.created_at',
            'users.avatar',
            'users.name',
            'users.id as uid'
        ])->paginate(10);
        $comment=$paginator->all();
        foreach ($comment as &$c) {
            $c['content']=clean(Markdown::convertToHtml($c["content"]));
            $c['created_at']=formatHumanReadableTime($c['created_at']);
            $c['reply']=DB::table('problem_discussion_comment')->join(
                "users",
                "id",
                "=",
                "problem_discussion_comment.uid"
            )->where(
                'problem_discussion_comment.pdid',
                '=',
                $pdid
            )->where(
                'problem_discussion_comment.reply_id',
                '!=',
                null
            )->where(
                'problem_discussion_comment.audit',
                '=',
                1
            )->select([
                'problem_discussion_comment.pdcid',
                'problem_discussion_comment.pdid',
                'problem_discussion_comment.content',
                'problem_discussion_comment.reply_id',
                'problem_discussion_comment.votes',
                'problem_discussion_comment.created_at',
                'users.avatar',
                'users.name',
                'users.id as uid'
            ])->get()->all();
            foreach ($c['reply'] as $k=>&$cr) {
                $cr['content']=clean(Markdown::convertToHtml($cr["content"]));
                $cr['reply_uid']=DB::table('problem_discussion_comment')->where(
                    'pdcid',
                    '=',
                    $cr['reply_id']
                )->get()->first()['uid'];
                $cr['reply_name']=DB::table('users')->where(
                    'id',
                    '=',
                    $cr['reply_uid']
                )->get()->first()['name'];
                $cr['created_at']=formatHumanReadableTime($cr['created_at']);
                if ($this->replyParent($cr['pdcid'])!=$c['pdcid']) {
                    unset($c['reply'][$k]);
                }
            }
        }
        return [
            'main' => $main,
            'comment_count' => $comment_count,
            'paginator' => $paginator,
            'comment' => $comment
        ];
    }

    public function replyParent($pdcid)
    {
        $reply_id=DB::table('problem_discussion_comment')->where('pdcid', '=', $pdcid)->get()->first()['reply_id'];
        $top=DB::table('problem_discussion_comment')->where('pdcid', '=', $reply_id)->get()->first()['reply_id'];
        if (isset($top)) {
            return $this->replyParent($reply_id);
        } else {
            return $reply_id;
        }
    }

    public function pcodeByPdid($dcode)
    {
        $pid=DB::table('problem_discussion')->where('pdid', '=', $dcode)->get()->first()['pid'];
        $pcode=$this->pcode($pid);
        return $pcode;
    }

    public function addDiscussion($uid, $pid, $title, $content)
    {
        $pdid=DB::table("problem_discussion")->insertGetId([
            "uid"=>$uid,
            "pid"=>$pid,
            "title"=>$title,
            "content"=>$content,
            "votes"=>0,
            "audit"=>1,
            "created_at"=>date("Y-m-d H:i:s"),
            "updated_at"=>date("Y-m-d H:i:s"),
        ]);
        return $pdid;
    }

    public function pidByPdid($pdid)
    {
        $pid=DB::table('problem_discussion')->where('pdid', '=', $pdid)->get()->first()['pid'];
        return $pid;
    }

    public function addComment($uid, $pdid, $content, $reply_id)
    {
        $pid=$this->pidByPdid($pdid);
        $pdcid=DB::table('problem_discussion_comment')->insertGetId([
            'pdid'=>$pdid,
            'uid'=>$uid,
            'pid'=>$pid,
            'content'=>$content,
            'reply_id'=>$reply_id,
            'votes'=>0,
            'audit'=>1,
            'created_at'=>date("Y-m-d H:i:s"),
            'updated_at'=>date("Y-m-d H:i:s"),
        ]);
        return $pdcid;
    }

    public function isHidden($pid)
    {
        return DB::table('problem')->where('pid', '=', $pid)->get()->first()['hide'];
    }
}


1			<?php
2
3			namespace App\Models;
4
5			use GrahamCampbell\Markdown\Facades\Markdown;
6			use Illuminate\Database\Eloquent\Model;
7			use Illuminate\Support\Facades\DB;
8			use App\Models\Submission\SubmissionModel;
9			use Illuminate\Support\Str;
10			use App\Models\Eloquent\OJ;
11			use Cache;
12
13			class ProblemModel extends Model
14			{
15			protected $table='problem';
16			protected $primaryKey='pid';
17			const UPDATED_AT="update_date";
18
19			public function detail($pcode, $cid=null)
20			{
21			$prob_detail=DB::table($this->table)->where("pcode", $pcode)->first();
22			// [Depreciated] Joint Query was depreciated here for code maintenance reasons
23			if (!is_null($prob_detail)) {
24			if ($prob_detail["force_raw"]) {
25			$prob_detail["parsed"]=[
26			"description"=>$prob_detail["description"],
27			"input"=>$prob_detail["input"],
28			"output"=>$prob_detail["output"],
29			"note"=>$prob_detail["note"],
30			"file"=>$prob_detail["file"]
31			];
32			} elseif ($prob_detail["markdown"]) {
33			$prob_detail["parsed"]=[
34			"description"=>clean(convertMarkdownToHtml($prob_detail["description"])),
35			"input"=>clean(convertMarkdownToHtml($prob_detail["input"])),
36			"output"=>clean(convertMarkdownToHtml($prob_detail["output"])),
37			"note"=>clean(convertMarkdownToHtml($prob_detail["note"])),
38			"file"=>clean(convertMarkdownToHtml($prob_detail["file"]))
39			];
40			} else {
41			$prob_detail["parsed"]=[
42			"description"=>$prob_detail["description"],
43			"input"=>$prob_detail["input"],
44			"output"=>$prob_detail["output"],
45			"note"=>$prob_detail["note"],
46			"file"=>$prob_detail["file"]
47			];
48			}
49			$prob_detail["pdf"]=false;
50			$prob_detail["viewerShow"]=false;
51			$prob_detail["file_ext"]=null;
52			if ($prob_detail['file'] && !blank($prob_detail['file_url'])) {
53			$prob_detail["file_ext"]=explode('.', basename($prob_detail['file_url']));
54			$prob_detail["file_ext"]=end($prob_detail["file_ext"]);
55			$prob_detail["pdf"]=Str::is("*.pdf", basename($prob_detail['file_url']));
56			$prob_detail["viewerShow"]=blank($prob_detail["parsed"]["description"]) &&
57			blank($prob_detail["parsed"]["input"]) &&
58			blank($prob_detail["parsed"]["output"]) &&
59			blank($prob_detail["parsed"]["note"]);
60			}
61			$prob_detail["update_date"]=date_format(date_create($prob_detail["update_date"]), 'm/d/Y H:i:s');
62			$prob_detail["oj_detail"]=DB::table("oj")->where("oid", $prob_detail["OJ"])->first();
63			$prob_detail["samples"]=DB::table("problem_sample")->where("pid", $prob_detail["pid"])->get()->all();
64			$prob_detail["tags"]=DB::table("problem_tag")->where("pid", $prob_detail["pid"])->get()->all();
65			if ($cid) {
66			$frozen_time=strtotime(DB::table("contest")->where(["cid"=>$cid])->select("end_time")->first()["end_time"]);
67			$prob_stat=DB::table("submission")->select(
68			DB::raw("count(sid) as submission_count"),
69			DB::raw("sum(verdict='accepted') as passed_count"),
70			DB::raw("sum(verdict='accepted')/count(sid)*100 as ac_rate")
71			)->where([
72			"pid"=>$prob_detail["pid"],
73			"cid"=>$cid,
74			])->where("submission_date", "<", $frozen_time)->first();
75			$prob_detail['vcid']=DB::table("contest")->where(["cid"=>$cid])->select("vcid")->first()['vcid'];
76			$prob_detail["points"]=DB::table("contest_problem")->where(["cid"=>$cid, "pid"=>$prob_detail["pid"]])->select("points")->first()["points"];
77			} else {
78			$prob_stat=DB::table("submission")->select(
79			DB::raw("count(sid) as submission_count"),
80			DB::raw("sum(verdict='accepted') as passed_count"),
81			DB::raw("sum(verdict='accepted')/count(sid)*100 as ac_rate")
82			)->where(["pid"=>$prob_detail["pid"]])->first();
83			$prob_detail['vcid']=null;
84			$prob_detail["points"]=0;
85			}
86			if ($prob_stat["submission_count"]==0) {
87			$prob_detail["submission_count"]=0;
88			$prob_detail["passed_count"]=0;
89			$prob_detail["ac_rate"]=0;
90			} else {
91			$prob_detail["submission_count"]=$prob_stat["submission_count"];
92			$prob_detail["passed_count"]=$prob_stat["passed_count"];
93			$prob_detail["ac_rate"]=round($prob_stat["ac_rate"], 2);
94			}
95			}
96			return $prob_detail;
97			}
98
99			public function basic($pid)
100			{
101			return DB::table($this->table)->where("pid", $pid)->first();
102			}
103
104			public function tags()
105			{
106			return DB::table("problem_tag")->groupBy('tag')->select("tag", DB::raw('count(*) as tag_count'))->orderBy('tag_count', 'desc')->limit(12)->get()->all();
107			}
108
109			public function ojs()
110			{
111			return DB::table("oj")->where("status", 1)->orderBy('oid', 'asc')->get()->all();
112			}
113
114			public function ojdetail($oid)
115			{
116			return DB::table("oj")->where('oid', $oid)->first();
117			}
118
119			public function solutionList($pid, $uid=null)
120			{
121			if (is_null($uid)) {
122			$details=DB::table("problem_solution")->join(
123			"users",
124			"id",
125			"=",
126			"problem_solution.uid"
127			)->where([
128			'problem_solution.pid'=>$pid,
129			'problem_solution.audit'=>1
130			])->orderBy(
131			"problem_solution.votes",
132			"desc"
133			)->get()->all();
134			} else {
135			$votes=DB::table("problem_solution_vote")->where([
136			"uid"=>$uid
137			])->get()->all();
138			foreach ($votes as $v) {
139			$userVotes[$v["psoid"]]=$v["type"];
140			}
141			$details=DB::table("problem_solution")->join(
142			"users",
143			"id",
144			"=",
145			"problem_solution.uid"
146			)->where([
147			'problem_solution.pid'=>$pid,
148			'problem_solution.audit'=>1
149			])->select([
150			"problem_solution.psoid as psoid",
151			"problem_solution.uid as uid",
152			"problem_solution.pid as pid",
153			"problem_solution.content as content",
154			"problem_solution.audit as audit",
155			"problem_solution.votes as votes",
156			"problem_solution.created_at as created_at",
157			"problem_solution.updated_at as updated_at",
158			"avatar",
159			"name"
160			])->orderBy("problem_solution.votes", "desc")->get()->all();
161			foreach ($details as &$d) {
162			$d["type"]=isset($userVotes[$d["psoid"]]) ? $userVotes[$d["psoid"]] : null;
			0 ignored issues – show Comprehensibility Best Practice introduced 2019-05-08 16:32 UTC by Report Bug Copy Issue Report The variable `$userVotes` seems to be defined by a `foreach` iteration on line `138`. Are you sure the iterator is never empty, otherwise this variable is not defined? Loading history...
163			}
164			unset($d);
165			}
166			foreach ($details as &$d) {
167			$d["content_parsed"]=clean(convertMarkdownToHtml($d["content"]));
168			}
169			return $details;
170			}
171
172			public function solution($pid, $uid)
173			{
174			$details=DB::table("problem_solution")->join("users", "id", "=", "uid")->where(['pid'=>$pid, 'uid'=>$uid])->first();
175			return $details;
176			}
177
178			public function addSolution($pid, $uid, $content)
179			{
180			$details=DB::table("problem_solution")->where(['pid'=>$pid, 'uid'=>$uid])->first();
181			if (empty($details)) {
182			DB::table("problem_solution")->insert([
183			"uid"=>$uid,
184			"pid"=>$pid,
185			"content"=>$content,
186			"votes"=>0,
187			"audit"=>$this->inteliAudit($uid, $content),
188			"created_at"=>date("Y-m-d H:i:s"),
189			"updated_at"=>date("Y-m-d H:i:s"),
190			]);
191			return true;
192			}
193			return false;
194			}
195
196			private function inteliAudit($uid, $content)
197			{
198			if (strpos($content, '```')!==false) {
199			$userSolutionHistory=DB::table("problem_solution")->where(['uid'=>$uid])->orderByDesc('updated_at')->first();
200			if (!empty($userSolutionHistory) && $userSolutionHistory["audit"]==1) {
201			return 1;
202			}
203			}
204			return 0;
205			}
206
207			public function voteSolution($psoid, $uid, $type)
208			{
209			$val=$type ? 1 : -1;
210			$details=DB::table("problem_solution")->where(['psoid'=>$psoid])->first();
211			if (empty($details)) {
212			return ["ret"=>false];
213			}
214
215			$userVote=DB::table("problem_solution_vote")->where(['uid'=>$uid, "psoid"=>$psoid])->first();
216
217			if (!empty($userVote)) {
218			DB::table("problem_solution_vote")->where(['uid'=>$uid, "psoid"=>$psoid])->delete();
219			if ($userVote["type"]==$type) {
220			DB::table("problem_solution")->where([
221			'psoid'=>$psoid
222			])->update([
223			"votes"=>$details["votes"]+($userVote["type"]==1 ?-1 : 1),
224			]);
225			return ["ret"=>true, "votes"=>$details["votes"]+($userVote["type"]==1 ?-1 : 1), "select"=>-1]; //disvote
226			} elseif ($userVote["type"]==1) {
227			$val--;
228			} else {
229			$val++;
230			}
231			}
232
233			DB::table("problem_solution")->where([
234			'psoid'=>$psoid
235			])->update([
236			"votes"=>$details["votes"]+$val,
237			]);
238
239			DB::table("problem_solution_vote")->insert([
240			"uid"=>$uid,
241			"psoid"=>$psoid,
242			"type"=>$type,
243			]);
244
245			return ["ret"=>true, "votes"=>$details["votes"]+$val, "select"=>$type];
246			}
247
248			public function removeSolution($psoid, $uid)
249			{
250			if (empty(DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->first())) {
251			return false;
252			}
253			DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->delete();
254			return true;
255			}
256
257			public function updateSolution($psoid, $uid, $content)
258			{
259			if (empty(DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->first())) {
260			return false;
261			}
262			DB::table("problem_solution")->where(['psoid'=>$psoid, 'uid'=>$uid])->update([
263			"content"=>$content,
264			"audit"=>$this->inteliAudit($uid, $content),
265			"updated_at"=>date("Y-m-d H:i:s"),
266			]);
267			return true;
268			}
269
270			public function isBlocked($pid, $cid=null)
271			{
272			$conflictContests=DB::table("contest")
273			->join("contest_problem", "contest.cid", "=", "contest_problem.cid")
274			->where("end_time", ">", date("Y-m-d H:i:s"))
275			->where(["verified"=>1, "pid"=>$pid])
276			->select(["contest_problem.cid as cid"])
277			->get()
278			->all();
279			if (empty($conflictContests)) {
280			return false;
281			}
282			foreach ($conflictContests as $c) {
283			if ($cid==$c["cid"]) {
284			return false;
285			}
286			}
287			// header("HTTP/1.1 403 Forbidden");
288			// exit();
289			return true;
290			}
291
292			public function list($filter, $uid=null)
293			{
294			// $prob_list = DB::table($this->table)->select("pid","pcode","title")->get()->all(); // return a array
295			$submissionModel=new SubmissionModel();
296			$preQuery=DB::table($this->table)->where('hide', '=', 0);
297			if ($filter['oj']) {
298			$OJ=OJ::find($filter['oj']);
299			if (blank($OJ) \|\| !$OJ->status) {
300			return null;
301			}
302			$preQuery=$preQuery->where(["OJ"=>$filter['oj']]);
303			}
304			if ($filter['tag']) {
305			$preQuery=$preQuery->join("problem_tag", "problem.pid", "=", "problem_tag.pid")->where(["tag"=>$filter['tag']]);
306			}
307			$paginator=$preQuery->select("problem.pid as pid", "pcode", "title")->orderBy(
308			"OJ",
309			"ASC"
310			)->orderBy(
311			"order_index",
312			"ASC"
313			)->orderBy(
314			DB::raw("length(contest_id)"),
315			"ASC"
316			)->orderBy(
317			"contest_id",
318			"ASC"
319			)->orderBy(
320			DB::raw("length(index_id)"),
321			"ASC"
322			)->orderBy(
323			"index_id",
324			"ASC"
325			)->orderBy(
326			"pcode",
327			"ASC"
328			)->paginate(max(config('pagination.problem.per_page'), 1));
329			$prob_list=$paginator->all();
330
331			if (empty($prob_list)) {
332			return null;
333			}
334			foreach ($prob_list as &$p) {
335			$prob_stat=DB::table("submission")->select(
336			DB::raw("count(sid) as submission_count"),
337			DB::raw("sum(verdict='accepted') as passed_count"),
338			DB::raw("sum(verdict='accepted')/count(sid)*100 as ac_rate")
339			)->where(["pid"=>$p["pid"]])->first();
340			if ($prob_stat["submission_count"]==0) {
341			$p["submission_count"]=0;
342			$p["passed_count"]=0;
343			$p["ac_rate"]=0;
344			} else {
345			$p["submission_count"]=$prob_stat["submission_count"];
346			$p["passed_count"]=$prob_stat["passed_count"];
347			$p["ac_rate"]=round($prob_stat["ac_rate"], 2);
348			}
349			if (!is_null($uid)) {
350			$prob_status=$submissionModel->getProblemStatus($p["pid"], $uid);
351			if (empty($prob_status)) {
352			$p["prob_status"]=[
353			"icon"=>"checkbox-blank-circle-outline",
354			"color"=>"wemd-grey-text"
355			];
356			} else {
357			$p["prob_status"]=[
358			"icon"=>$prob_status["verdict"]=="Accepted" ? "checkbox-blank-circle" : "cisco-webex",
359			"color"=>$prob_status["color"]
360			];
361			}
362			} else {
363			$p["prob_status"]=[
364			"icon"=>"checkbox-blank-circle-outline",
365			"color"=>"wemd-grey-text"
366			];
367			}
368			}
369			return [
370			'paginator' => $paginator,
371			'problems' => $prob_list,
372			];
373			}
374
375			public function existPCode($pcode)
376			{
377			$temp=DB::table($this->table)->where(["pcode"=>$pcode])->select("pcode")->first();
378			return empty($temp) ? null : $temp["pcode"];
379			}
380
381			public function pid($pcode)
382			{
383			$temp=DB::table($this->table)->where(["pcode"=>$pcode])->select("pid")->first();
384			return empty($temp) ? 0 : $temp["pid"];
385			}
386
387			public function pcode($pid)
388			{
389			$temp=DB::table($this->table)->where(["pid"=>$pid])->select("pcode")->first();
390			return empty($temp) ? 0 : $temp["pcode"];
391			}
392
393			public function ocode($pid)
394			{
395			$temp=DB::table($this->table)->where(["pid"=>$pid])->select("OJ as oid")->first();
396			return empty($temp) ? null : DB::table("oj")->where(["oid"=>$temp["oid"]])->select("ocode")->first()["ocode"];
397			}
398
399			public function oid($pid)
400			{
401			return DB::table($this->table)->where(["pid"=>$pid])->select("OJ as oid")->first()["oid"];
402			}
403
404			public function clearTags($pid)
405			{
406			DB::table("problem_tag")->where(["pid"=>$pid])->delete();
407			return true;
408			}
409
410			public function addTags($pid, $tag)
411			{
412			DB::table("problem_tag")->insert(["pid"=>$pid, "tag"=>$tag]);
413			return true;
414			}
415
416			public function getSolvedCount($oid)
417			{
418			return DB::table($this->table)->select("pid", "solved_count")->where(["OJ"=>$oid])->get()->all();
419			}
420
421			public function updateDifficulty($pid, $diff_level)
422			{
423			DB::table("problem_tag")->where(["pid"=>$pid])->update(["difficulty"=>$diff_level]);
424			return true;
425			}
426
427			public function insertProblem($data)
428			{
429			$info=array_merge([
430			'difficulty'=>-1,
431			'update_date'=>date("Y-m-d H:i:s"),
432			], collect($data)->only([
433			'file',
434			'file_url',
435			'title',
436			'time_limit',
437			'memory_limit',
438			'OJ',
439			'description',
440			'input',
441			'output',
442			'note',
443			'input_type',
444			'output_type',
445			'pcode',
446			'contest_id',
447			'index_id',
448			'origin',
449			'source',
450			'solved_count',
451			'tot_score',
452			'partial',
453			'markdown',
454			'special_compiler',
455			'order_index',
456			])->toArray());
457
458			$pid=DB::table($this->table)->insertGetId($info);
459
460			if (!empty($data["sample"])) {
461			foreach ($data["sample"] as $d) {
462			if (!isset($d['sample_note'])) {
463			$d['sample_note']=null;
464			}
465			DB::table("problem_sample")->insert([
466			'pid'=>$pid,
467			'sample_input'=>$d['sample_input'],
468			'sample_output'=>$d['sample_output'],
469			'sample_note'=>$d['sample_note'],
470			]);
471			}
472			}
473
474			return $pid;
475			}
476
477			public function updateProblem($data)
478			{
479			DB::table($this->table)->where(["pcode"=>$data['pcode']])->update(array_merge([
480			'difficulty'=>-1,
481			'update_date'=>date("Y-m-d H:i:s"),
482			], collect($data)->only([
483			'file',
484			'file_url',
485			'title',
486			'time_limit',
487			'memory_limit',
488			'OJ',
489			'description',
490			'input',
491			'output',
492			'note',
493			'input_type',
494			'output_type',
495			'contest_id',
496			'index_id',
497			'origin',
498			'source',
499			'solved_count',
500			'tot_score',
501			'partial',
502			'markdown',
503			'special_compiler',
504			'order_index',
505			])->toArray()));
506
507			$pid=$this->pid($data['pcode']);
508
509			DB::table("problem_sample")->where(["pid"=>$pid])->delete();
510
511			if (!empty($data["sample"])) {
512			foreach ($data["sample"] as $d) {
513			if (!isset($d['sample_note'])) {
514			$d['sample_note']=null;
515			}
516			DB::table("problem_sample")->insert([
517			'pid'=>$pid,
518			'sample_input'=>$d['sample_input'],
519			'sample_output'=>$d['sample_output'],
520			'sample_note'=>$d['sample_note'],
521			]);
522			}
523			}
524
525			return $pid;
526			}
527
528			public function discussionList($pid)
529			{
530			$paginator=DB::table('problem_discussion')->join(
531			"users",
532			"id",
533			"=",
534			"problem_discussion.uid"
535			)->where([
536			'problem_discussion.pid'=>$pid,
537			'problem_discussion.audit'=>1
538			])->orderBy(
539			'problem_discussion.created_at',
540			'desc'
541			)->select([
542			'problem_discussion.pdid',
543			'problem_discussion.title',
544			'problem_discussion.updated_at',
545			'users.avatar',
546			'users.name',
547			'users.id as uid'
548			])->paginate(15);
549			$list=$paginator->all();
550			foreach ($list as &$l) {
551			$l['updated_at']=formatHumanReadableTime($l['updated_at']);
552			$l['comment_count']=DB::table('problem_discussion_comment')->where('pdid', '=', $l['pdid'])->count();
553			}
554			return [
555			'paginator' => $paginator,
556			'list' => $list,
557			];
558			}
559
560			public function discussionDetail($pdid)
561			{
562			$main=DB::table('problem_discussion')->join(
563			"users",
564			"id",
565			"=",
566			"problem_discussion.uid"
567			)->where(
568			'problem_discussion.pdid',
569			'=',
570			$pdid
571			)->select([
572			'problem_discussion.pdid',
573			'problem_discussion.title',
574			'problem_discussion.content',
575			'problem_discussion.votes',
576			'problem_discussion.created_at',
577			'users.avatar',
578			'users.name',
579			'users.id as uid'
580			])->get()->first();
581			$main['created_at']=formatHumanReadableTime($main['created_at']);
582			$main['content']=clean(Markdown::convertToHtml($main["content"]));
583
584			$comment_count=DB::table('problem_discussion_comment')->where('pdid', '=', $pdid)->count();
585
586			$paginator=DB::table('problem_discussion_comment')->join(
587			"users",
588			"id",
589			"=",
590			"problem_discussion_comment.uid"
591			)->where([
592			'problem_discussion_comment.pdid'=>$pdid,
593			'problem_discussion_comment.reply_id'=>null,
594			'problem_discussion_comment.audit'=>1
595			])->select([
596			'problem_discussion_comment.pdcid',
597			'problem_discussion_comment.pdid',
598			'problem_discussion_comment.content',
599			'problem_discussion_comment.votes',
600			'problem_discussion_comment.created_at',
601			'users.avatar',
602			'users.name',
603			'users.id as uid'
604			])->paginate(10);
605			$comment=$paginator->all();
606			foreach ($comment as &$c) {
607			$c['content']=clean(Markdown::convertToHtml($c["content"]));
608			$c['created_at']=formatHumanReadableTime($c['created_at']);
609			$c['reply']=DB::table('problem_discussion_comment')->join(
610			"users",
611			"id",
612			"=",
613			"problem_discussion_comment.uid"
614			)->where(
615			'problem_discussion_comment.pdid',
616			'=',
617			$pdid
618			)->where(
619			'problem_discussion_comment.reply_id',
620			'!=',
621			null
622			)->where(
623			'problem_discussion_comment.audit',
624			'=',
625			1
626			)->select([
627			'problem_discussion_comment.pdcid',
628			'problem_discussion_comment.pdid',
629			'problem_discussion_comment.content',
630			'problem_discussion_comment.reply_id',
631			'problem_discussion_comment.votes',
632			'problem_discussion_comment.created_at',
633			'users.avatar',
634			'users.name',
635			'users.id as uid'
636			])->get()->all();
637			foreach ($c['reply'] as $k=>&$cr) {
638			$cr['content']=clean(Markdown::convertToHtml($cr["content"]));
639			$cr['reply_uid']=DB::table('problem_discussion_comment')->where(
640			'pdcid',
641			'=',
642			$cr['reply_id']
643			)->get()->first()['uid'];
644			$cr['reply_name']=DB::table('users')->where(
645			'id',
646			'=',
647			$cr['reply_uid']
648			)->get()->first()['name'];
649			$cr['created_at']=formatHumanReadableTime($cr['created_at']);
650			if ($this->replyParent($cr['pdcid'])!=$c['pdcid']) {
651			unset($c['reply'][$k]);
652			}
653			}
654			}
655			return [
656			'main' => $main,
657			'comment_count' => $comment_count,
658			'paginator' => $paginator,
659			'comment' => $comment
660			];
661			}
662
663			public function replyParent($pdcid)
664			{
665			$reply_id=DB::table('problem_discussion_comment')->where('pdcid', '=', $pdcid)->get()->first()['reply_id'];
666			$top=DB::table('problem_discussion_comment')->where('pdcid', '=', $reply_id)->get()->first()['reply_id'];
667			if (isset($top)) {
668			return $this->replyParent($reply_id);
669			} else {
670			return $reply_id;
671			}
672			}
673
674			public function pcodeByPdid($dcode)
675			{
676			$pid=DB::table('problem_discussion')->where('pdid', '=', $dcode)->get()->first()['pid'];
677			$pcode=$this->pcode($pid);
678			return $pcode;
679			}
680
681			public function addDiscussion($uid, $pid, $title, $content)
682			{
683			$pdid=DB::table("problem_discussion")->insertGetId([
684			"uid"=>$uid,
685			"pid"=>$pid,
686			"title"=>$title,
687			"content"=>$content,
688			"votes"=>0,
689			"audit"=>1,
690			"created_at"=>date("Y-m-d H:i:s"),
691			"updated_at"=>date("Y-m-d H:i:s"),
692			]);
693			return $pdid;
694			}
695
696			public function pidByPdid($pdid)
697			{
698			$pid=DB::table('problem_discussion')->where('pdid', '=', $pdid)->get()->first()['pid'];
699			return $pid;
700			}
701
702			public function addComment($uid, $pdid, $content, $reply_id)
703			{
704			$pid=$this->pidByPdid($pdid);
705			$pdcid=DB::table('problem_discussion_comment')->insertGetId([
706			'pdid'=>$pdid,
707			'uid'=>$uid,
708			'pid'=>$pid,
709			'content'=>$content,
710			'reply_id'=>$reply_id,
711			'votes'=>0,
712			'audit'=>1,
713			'created_at'=>date("Y-m-d H:i:s"),
714			'updated_at'=>date("Y-m-d H:i:s"),
715			]);
716			return $pdcid;
717			}
718
719			public function isHidden($pid)
720			{
721			return DB::table('problem')->where('pid', '=', $pid)->get()->first()['hide'];
722			}
723			}
724

ZsgsDesign / NOJ

ProblemModel::removeSolution() A last analyzed 2021-11-04 16:36 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ProblemModel::removeSolution() A
last analyzed 2021-11-04 16:36 UTC