area-point-api/app/Http/Controllers/Api/Exam/PapersController.php

<?php

namespace App\Http\Controllers\Api\Exam;

use App\Http\Controllers\Controller;
use App\Repositories\Enums\Exam\TypeEnum;
use App\Repositories\Enums\ModelStatusEnum;
use App\Repositories\Enums\ResponseCodeEnum;
use App\Repositories\Models\Exam\Paper;
use App\Repositories\Models\Exam\PaperResult;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Jiannei\Response\Laravel\Support\Facades\Response;
use Prettus\Validator\Contracts\ValidatorInterface;
use App\Contracts\Repositories\Exam\PaperRepository;
use App\Repositories\Validators\Exam\PaperValidator;

/**
 * Class PapersController.
 *
 * @package namespace App\Http\Controllers\Exam;
 */
class PapersController extends Controller
{
    /**
     * @var PaperRepository
     */
    protected $repository;

    /**
     * @var PaperValidator
     */
    protected $validator;

    /**
     * PapersController constructor.
     *
     * @param PaperRepository $repository
     * @param PaperValidator $validator
     */
    public function __construct(PaperRepository $repository, PaperValidator $validator)
    {
        $this->repository = $repository;
        $this->validator = $validator;
    }

    /**
     * 试卷列表
     * @param Request $request
     * @return mixed
     * Author: Mead
     */
    public function index(Request $request)
    {
        $lists = $this->repository->paginate($request->get('per_page', self::PAGE_NUM));
        return Response::success($lists);
    }

    /**
     * 创建试卷
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource|void
     * @throws \Illuminate\Validation\ValidationException
     * Author: Mead
     */
    public function store(Request $request)
    {
        $this->validate($request, $this->validator->getRules(ValidatorInterface::RULE_CREATE));
        try {
            $data = $request->only(array_keys($this->validator->getRules(ValidatorInterface::RULE_CREATE)));

            $data['user_id'] = login_user_id();
            $data['slug'] = Str::random();

            if (!in_array('published_at', $data) || empty($data['published_at'])) {
                $data['published_at'] = Carbon::now();
            }

            $model = $this->repository->create($data);
            return Response::success($model);
        } catch (\Exception $e) {
            return $this->errorStore($e);
        }
    }

    /**
     * 修改试卷
     * @param Request $request
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     * Author: Mead
     */
    public function update(Request $request, $id)
    {
        $this->validate($request, $this->validator->getRules(ValidatorInterface::RULE_UPDATE));

        if (!Paper::query()->where('user_id', login_user_id())->where('id', $id)->exists()) {
            return $this->error('您暂无编辑权限！');
        }

        try {
            $data = $request->only(array_keys($this->validator->getRules(ValidatorInterface::RULE_UPDATE)));

            if (!in_array('published_at', $data) || empty($data['published_at'])) {
                $data['published_at'] = Carbon::now();
            }

            $model = $this->repository->update($data, $id);
            return Response::success($model);
        } catch (\Exception $e) {
            $this->errorStore($e);
        }
    }

    /**
     * 删除
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function destroy($id)
    {
        if (!Paper::query()->where('user_id', login_user_id())->where('id', $id)->exists()) {
            return $this->error('您暂无删除权限！');
        }

        try {
            $this->repository->delete($id);
            return Response::success(null, T('successfully delete.'));
        } catch (\Exception $exception) {
            return Response::fail(T('Delete failed.'), ResponseCodeEnum::SERVICE_UPDATE_DATA_ERROR);
        }
    }

    /**
     * 详情
     * @param $slug
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function show($slug)
    {
        $model = $this->repository->where('slug', $slug)->first();
        if (!$model) {
            return $this->error('找不到资源');
        }
        $model = $this->repository->parserResult($model);
        return Response::success($model);
    }

    /**
     * 考试
     * @param Request $request
     * Author: Mead
     */
    public function examination(Request $request)
    {
        $this->validate($request, [
            'paper_id' => 'required|integer',
            'result' => 'required|array',
        ]);
        $paper_id = $request->get('paper_id');
        $results = $request->get('result');

        $paper = Paper::query()->where('id', $paper_id)->where('status', ModelStatusEnum::OK)->first();
        if (!$paper) {
            return $this->error('找不到资源');
        }

        if ((int)$paper->topic_nums != count($results)) {
            if ($paper->topic_nums > count($results)) {
                return $this->error('试卷有未答试题！');
            }
            return $this->error('试题与答案不匹配！');
        }

        $user_id = login_user_id();
        $is_submit = PaperResult::query()->where('user_id', $user_id)->where('paper_id', $paper_id)->where('status', ModelStatusEnum::OK)->exists();
        if ($is_submit) {
            return $this->error('请勿重复提交');
        }
        //计算分
        $mark = 0;
        $is_examines = 0;
        $n_results = [];
        foreach ($paper->topic_lists as $key => $topic) {
//            if (!isset($results[$key]['value'])) {
            if (!isset($results[$key])) {
                return $this->error('试题与答案不匹配！');
            }
//            $result = $results[$key]['value'];
            $result = $results[$key];
            $n_results[$key]['value'] = $result;
            $n_results[$key]['mark'] = 0;
            $n_results[$key]['point'] = $topic->point;
            $n_results[$key]['is_examines'] = 0;
            $f = false;
            switch ($topic->type) {
                case TypeEnum::XUANZE:
                    //单选
                    $n_results[$key]['is_examines'] = 1;
                    if ($result == $topic->result) {
                        $mark += $topic->point;
                        $n_results[$key]['mark'] = $topic->point;
                    }
                    break;
                case TypeEnum::PANDUAN:
                    $n_results[$key]['is_examines'] = 1;
                    if ($result == $topic->result) {
                        $mark += $topic->point;
                        $n_results[$key]['mark'] = $topic->point;
                    }
                    break;
                case TypeEnum::TIANKONG:
                    $n_results[$key]['is_examines'] = 0;
                    if ($result == $topic->result) {
                        $mark += $topic->point;
                        $n_results[$key]['mark'] = $topic->point;
                    }
                    $is_examines = 0;
                    $f = true;
                    break;
                case TypeEnum::JIANDA:
                    $is_examines = 0;
                    $f = true;
                    break;
                case TypeEnum::DUOXUAN:
                    $n_results[$key]['is_examines'] = 1;
                    if (count($result) <= count($topic->result)) {
                        if (count(array_intersect($result, $topic->result)) == count($topic->result)) {
                            $mark += $topic->point;
                            $n_results[$key]['mark'] = $topic->point;
                        } else {
                            if (!count(array_diff($result, $topic->result))) {
                                $p = ceil($topic->point / 2);
                                $mark += $p;
                                $n_results[$key]['mark'] = $p;
                            }
                        }
                    }
                    break;
            }
        }

        if ($f) {
            $is_examines = 0;
        }

        PaperResult::query()->create([
            'user_id' => $user_id,
            'paper_id' => $paper_id,
            'result' => $n_results,
            'obiective_mark' => $mark,
            'subjective_mark' => 0,
            'mark' => $mark,
            'is_examines' => $is_examines,
            'total_mak' => $paper->mark,
        ]);

        $paper->submit_count++;
        $paper->save();

        return Response::success(null, '提交成功');
    }

    /**
     * 老师批阅试卷
     * Author: Mead
     */
    public function examines(Request $request)
    {
        $this->validate($request, [
            'paper_result_id' => 'required|integer',
            'result' => 'required|array',
        ]);
        $paper_result_id = $request->get('paper_result_id');
        $results = $request->get('result');
        $paper_result = PaperResult::query()->where('id', $paper_result_id)->where('status', ModelStatusEnum::OK)->first();
        if (!$paper_result) {
            return $this->error('找不到该记录');
        }

        $paper = Paper::query()->where('id', $paper_result['paper_id'])->first();
        if (!$paper) {
            return $this->error('找不到该试卷');
        }

        $topic_lists = $paper->topic_lists;
        $mark = 0;
        $subjective_mark = 0;
        foreach ($results as $key => $result) {
            $mark += $result['mark'];
            if (0 > $result['mark'] && $result['mark'] > $topic_lists[$key]['point']) {
                return $this->error('分值非法');
            }

            if ($topic_lists[$key]['type'] == TypeEnum::JIANDA) {
                $subjective_mark += $result['mark'];
            }
        }

        $paper_result->result = $results;
        $paper_result->mark = $mark;
        $paper_result->subjective_mark = $subjective_mark;
        $paper_result->is_examines = 1;
        $paper_result->save();
        return Response::success(null, '操作成功');
    }
}