colleague / study-project · Files

<?php
/**
 * 考试-答卷详情表
 * @author: houyingcai
 * @email:    594609175@qq.com
 * @date :  2017-05-19 17:55:55
 * @version $Id$
 */

namespace Common\Service;

use Common\Common\ExamHelper;
use Common\Common\Lcs;
use Common\Common\User;
use Common\Model\AnswerAttachModel;
use Common\Model\AnswerDetailModel;
use Common\Model\AnswerDetailExtendModel;
use Common\Model\AnswerModel;
use Common\Model\PaperModel;
use Common\Model\RightModel;
use Common\Model\SnapshotModel;
use Common\Model\StatisticsModel;
use Common\Model\TopicModel;
use VcySDK\Service;

class AnswerDetailService extends AbstractService
{
    /** @var PaperModel 考试对象 */
    protected $paper_model;
    /** @var AnswerAttachModel 答卷附件对象 */
    public $_answer_attach_model;
    /** @var AnswerModel 答卷对象 */
    public $_answer_model;
    /** @var StatisticsModel 考试分数统计对象 */
    public $_statistics_model;
    /** @var SnapshotModel 试卷快照对象 */
    public $_snapshot_model;
    /** @var TopicModel 题目表对象 */
    public $_topic_model;
    /** @var RightModel 权限表对象 */
    public $_right_model;
    /** @var AnswerDetailExtendModel */
    protected $_answer_detail_extend_model;

    // 构造方法
    public function __construct()
    {
        $this->_d = new AnswerDetailModel();
        $this->_answer_attach_model = new AnswerAttachModel();
        $this->_answer_model = new AnswerModel();
        $this->paper_model = new PaperModel();
        $this->_statistics_model = new StatisticsModel();
        $this->_topic_model = new TopicModel();
        $this->_snapshot_model = new SnapshotModel();
        $this->_right_model = new RightModel();
        $this->_answer_detail_extend_model = new AnswerDetailExtendModel();
        parent::__construct();
    }

    /**
     * 格式化试题数据
     * @author: 蔡建华
     *
     * @param array $data 获取试题要格式化的数据
     * @param int $marking_type 1自动阅卷 2手动阅卷
     * @param int $type 0：获取答题试题，1：后台获取解析，2：前端获取解析，3：阅卷解析
     *
     * @return array
     */
    public function question_list_format($data = [], $marking_type = 0, $type = 0)
    {
        // 答卷详情id集合
        $ead_id = array_unique(array_column($data, 'ead_id'));

        // 答题附件新start
        $conditions_attach['ead_id'] = $ead_id;
        $order_option['ead_id'] = 'ASC';
        // 附件列表
        $attach_list = $this->_answer_attach_model->list_by_conds($conditions_attach, null, $order_option);

        $_attach_urls = [];
        if (!empty($attach_list)) {
            // 附件的媒体id集合
            $all_at_ids = array_column($attach_list, 'at_id');
            if (!empty($all_at_ids)) {

                sort($all_at_ids);
                $server = &Service::instance();
                $_attach_obj = new \VcySDK\Attach($server);
                $_attaches = $_attach_obj->listAll(['atIds' => $all_at_ids], 1, 1000);

                foreach ($_attaches['list'] as $_attach) {
                    // 获取本地的URL
                    $_attach_urls[$_attach['atId']] = $_attach['atAttachment']; // 附件资源访问地址
                }
            }
        }

        // 循环追加附件资源访问地址
        foreach ($attach_list as &$value) {
            // 附件资源访问地址
            $value['url'] = '';
            if (isset($_attach_urls[$value['at_id']]) && !empty($_attach_urls[$value['at_id']])) {

                $value['url'] = $_attach_urls[$value['at_id']];
            }
        }

        // 传引用的变量用完一定要删掉，否则下面再次使用会出错，切记，这是大坑
        unset($value);

        // 附件信息
        $attach = [];
        foreach ($attach_list as $value) {

            $val = [
                'order_id' => $value['order_id'], // 序号
                'media_id' => $value['media_id'], // 微信媒体id
                'is_complete' => intval($value['is_complete']), // 音频是否转换完毕(1:已转换,0:未转换)，其他类型文件值为1
                'type' => $value['type'], // 附件类型(voice:音频,image:图片)
                'length' => 0 // 音频长度
            ];

            $file_info = unserialize($value['file_info']);
            // 语音
            if (self::TYPE_VOICE == $value['type']) {
                // 音频长度重新赋值
                $val['length'] = $file_info['length'];
                $val['url'] = $value['url'];
            } else {
                // 图片访问地址
                $val['url'] = imgUrlReal($val['at_id']);
            }

            // 组装附件信息
            $attach[$value['ead_id']][$val['order_id']] = $val;
        }

        // 试卷id
        $ep_id = $data[0]['ep_id'];
        // 根据试卷id获取题目扩展信息列表
        $answer_detail_extend_list = $this->_answer_detail_extend_model->list_by_conds(['ep_id' => $ep_id]);
        $answer_detail_extend_list = array_combine_by_key($answer_detail_extend_list, 'et_id');

        $list = [];
        foreach ($data as $value) {
            // 题目扩展信息
            $extend_info = $answer_detail_extend_list[$value['et_id']];
            // 题目详情
            $et_detail = unserialize($extend_info['et_detail']);

            $et_option = [];
            if (in_array($value['et_type'], [self::TOPIC_TYPE_SINGLE, self::TOPIC_TYPE_MULTIPLE])) {

                // 如果问题类型是单选或者多选，则获取选项信息
                $et_option = unserialize($extend_info['et_option']);
            }


            $exam_help = new ExamHelper();

            if (!empty($value['option_index'])) {
                // 如果启用了选项打乱，则需将选项转换为用户答题时的选项顺序
                $et_option = $exam_help->options_shuffle_view($value['option_index'], $extend_info['et_option']);
            }

            // 答卷详情
            $detail_info = [
                'ead_id' => intval($value['ead_id']),
                'order_num' => intval($value['order_num']),
                'score' => $value['score'],
                'my_score' => $value['my_score'],
                'title' => $et_detail['title'],
                'title_pic' => $this->pic_url($et_detail['title_pic']),
                'et_type' => intval($et_detail['et_type']),
                'options' => $this->format_option($et_option)
            ];

            // 不是获取答卷题目
            if ($type) {

                if (!empty($value['option_index'])) {
                    // 如果启用了选项打乱，则需转换正确答案
                    $detail_info['answer'] = $exam_help->chang_answer_option($value['option_index'], $et_detail['answer']);
                } else {

                    // 正确答案
                    $detail_info['answer'] = $et_detail['answer'];
                }

                // 是否匹配关键字(0:否 ；1:是)
                $detail_info['match_type'] = intval($et_detail['match_type']);
                // 答案关键字
                $detail_info['answer_keyword'] = $et_detail['answer_keyword'];
                // 答案解析
                $detail_info['answer_resolve'] = $et_detail['answer_resolve'];
            }

            // 后台解析:1
            if (self::ANSWER_PC_ANALYSIS == $type) {
                // 如果未作答并且状态是已批阅
                $res = self::DO_PASS_STATE == $value['is_status']
                    && self::DO_MK_STATE == $value['marking_status']
                    && self::MANUAL_MARKING_TYPE == $marking_type
                    && (PaperService::TOPIC_TYPE_QUESTION == $value['et_type']
                        || self::TOPIC_TYPE_VOICE == $value['et_type']);

                if ($res) {

                    $detail_info['is_pass'] = self::SYSTEM_MY_PASS;
                } elseif (self::DO_PASS_STATE == $value['is_status']) { // 未作答

                    $detail_info['is_pass'] = self::DO_PASS_STATE;
                } elseif (self::MY_PASS == $value['is_pass']) { // 答对

                    $detail_info['is_pass'] = self::MY_PASS;
                } elseif (self::DO_STATE == $value['is_status'] && self::NO_MY_PASS == $value['is_pass']) { // 答错

                    $detail_info['is_pass'] = self::NO_MY_PASS;
                }
            } elseif (self::ANSWER_FRONTEND_ANALYSIS == $type) { // 前端获取解析:2
                // 未作答
                if (self::DO_PASS_STATE == $value['is_status']) {

                    $detail_info['status'] = self::DO_PASS_STATE;
                } elseif (self::MY_PASS == $value['is_pass']) { // 答对

                    $detail_info['status'] = self::MY_PASS;
                } elseif (self::DO_STATE == $value['is_status'] && self::NO_MY_PASS == $value['is_pass']) { // 答错

                    $detail_info['status'] = self::NO_MY_PASS;
                }
            } elseif (self::ANSWER_MARKING_ANALYSIS == $type) { // 阅卷解析:3

                $detail_info['status'] = intval($value['marking_status']);
                $detail_info['is_status'] = $value['is_status'];

            } else { // 获取答题试题:0

                $detail_info['status'] = intval($value['is_status']);
            }

            // 手动阅卷
            if (self::MANUAL_MARKING_TYPE == $marking_type) {
                // 语音题或者问答题
                if (self::TOPIC_TYPE_VOICE == $et_detail['et_type']
                    || self::TOPIC_TYPE_QUESTION == $et_detail['et_type']) {
                    // 后台解析
                    if (self::ANSWER_PC_ANALYSIS == $type) {
                        // 作答状态：已作答
                        if (self::DO_STATE == $value['is_status']) {
                            // 未批阅
                            if (self::NO_DO_MK_STATE == $value['marking_status']) {
                                // 待批阅
                                $detail_info['is_pass'] = self::NO_MARKING_DAIPIN;
                            } elseif (self::DO_MK_STATE == $value['marking_status']) { // 已批阅
                                // 手动阅卷
                                $detail_info['is_pass'] = self::NO_MARKING_OPTION;
                            }
                        }
                    } elseif (self::ANSWER_FRONTEND_ANALYSIS == $type) { // 前端获取解析
                        // 作答状态：已作答
                        if (self::DO_STATE == $value['is_status']) {
                            // 手动阅卷
                            $detail_info['status'] = self::NO_MARKING_OPTION;
                        }
                    }
                }
            }

            // 我的答案
            $my_answer = $value['my_answer'];

            if (!empty($value['option_index']) && !empty($my_answer)) {
                // 如果启用了选项打乱，则需转换我的答案
                $my_answer = $exam_help->change_option($my_answer, $value['option_index']);
            }

            // 试题类型：语音题
            if (self::TOPIC_TYPE_VOICE == $et_detail['et_type']) {
                // 我的答案详情
                $my_answer = unserialize($my_answer);
                // 附件信息
                $attach_info = $attach[$value['ead_id']];

                // 重组我的答案
                $news_my_answer = [];
                foreach ($my_answer as $v) {
                    // 试题类型
                    $v['type'] = intval($v['type']);
                    // 语音
                    if (self::ANSWER_TYPE_VOICE == $v['type']) {

                        if (array_key_exists($v['opt'], $attach_info)) {

                            $v['opt'] = $attach_info[$v['opt']];
                            $news_my_answer[] = $v;
                        }
                    } elseif (self::ANSWER_TYPE_TEXT == $v['type']) { // 文字

                        $news_my_answer[] = $v;
                    } elseif (self::ANSWER_TYPE_IMG == $v['type']) { // 图片

                        if ($v['opt']) {
                            // 图片
                            $v['opt'] = [
                                'atId' => $v['opt'],
                                'atAttachment' => imgUrlReal($v['opt'])
                            ];
                            $news_my_answer[] = $v;
                        }
                    }
                }

                $detail_info['my_answer'] = $news_my_answer;
            } else {

                $detail_info['my_answer'] = $this->format_answer($my_answer, $et_detail['et_type']);
            }

            $list[] = $detail_info;
        }

        return $list;
    }


    /**
     * 格式化题目列表
     * @param array $list 题目列表
     * @param int $is_upset_option 是否打乱题目选项（1：是，2：否）
     * @return array
     */
    public function format_question_list($list = [], $is_upset_option = 2)
    {
        $res_list = [];

        // 根据试卷id获取题目扩展信息列表
        $conditions['ep_id'] = $list[0]['ep_id'];
        $answer_detail_extend_list = $this->_answer_detail_extend_model->list_by_conds($conditions);
        $answer_detail_extend_list = array_combine_by_key($answer_detail_extend_list, 'et_id');

        $exam_help = new ExamHelper();

        foreach ($list as $v) {
            // 题目扩展信息
            $extend_info = $answer_detail_extend_list[$v['et_id']];
            // 题目详情
            $et_detail = unserialize($extend_info['et_detail']);

            $options = [];
            // 题目选项
            if (!empty($extend_info['et_option'])) {

                if (self::UPSET_OPTION_YES == $is_upset_option) {
                    // 如果开启选项打乱
                    if (empty($v['option_index'])) {
                        // 打乱选项后的选项顺序
                        $option_index = $exam_help->options_shuffle($extend_info['et_option']);
                    } else {

                        $option_index = $v['option_index'];
                    }

                    // 按打乱后的顺序重新组装选项数据
                    $et_option = $exam_help->options_shuffle_view($option_index, $extend_info['et_option']);

                } else {
                    // 不打乱选项
                    $et_option = unserialize($extend_info['et_option']);
                }

                $options = $this->format_option($et_option);
            }

            // 组装返回结果
            $res_list[] = [
                'ead_id' => intval($v['ead_id']),
                'order_num' => intval($v['order_num']),
                'et_type' => intval($v['et_type']),
                'title' => $et_detail['title'],
                'title_pic' => $this->pic_url($et_detail['title_pic']),
                'score' => $v['score'],
                'options' => $options
            ];
        }

        return $res_list;
    }

    /**
     * 图片数组
     *
     * @author: 蔡建华
     * @param string $str 题目图片
     *
     * @return array
     */
    public function pic_url($str)
    {
        $arr = [];
        $data = explode(',', $str);
        foreach ($data as $k => $v) {
            if (!empty($v)) {

                $arr[] = [
                    'atId' => $v,
                    'atAttachment' => imgUrlReal($v)
                ];
            }
        }

        return $arr;
    }

    /**
     * 选项格式化图片
     *
     * @author: 蔡建华
     * @param array $str 图片数组
     *
     * @return array
     */
    public function format_option($str)
    {
        $arr = [];
        foreach ($str as $v) {
            $arr[] = [
                'option_name' => $v['option_name'],
                'option_value' => $v['option_value'],
                'option_image_url' => empty($v['option_image_id']) ? '' : $this->format_cover($v['option_image_id']),
                'option_image_id' => $v['option_image_id']
            ];
        }

        return $arr;
    }

    /**
     * 格式化我的答案
     *
     * @author: 蔡建华
     * @param string $str 答案
     * @param int $type 题型
     *
     * @return array
     */
    public function format_answer($str, $type = 0)
    {
        $arr = [];
        $data = [];

        if (self::TOPIC_TYPE_SINGLE == $type || self::TOPIC_TYPE_MULTIPLE == $type) {
            // 试题类型：单选题
            $data = explode(',', $str);
        } elseif (self::TOPIC_TYPE_QUESTION == $type || self::TOPIC_TYPE_JUDGMENT == $type) {
            // 试题类型：判断题,问答题
            $data = [$str];
        }

        // 过滤信息
        array_filter($data);
        if (!empty($data)) {

            foreach ($data as $k => $v) {
                $arr[]['opt'] = $v;
            }
        }

        return $arr;
    }

    /**
     * 答题函数
     *
     * @author: 蔡建华
     * @param array $params 答题参数
     * @param array $data 题目信息
     * @param int $marking_type 1自动阅卷 2手动阅卷
     *
     * @return bool
     */
    public function answer_save($params = [], $data = [], $marking_type = 0)
    {
        $ead_id = intval($params['ead_id']);
        $my_answer = $params['my_answer'];

        // 如果答案为空设为0分;
        if (empty($my_answer)) {
            $this->update_by_conds(['ead_id' => $ead_id],
                [
                    'my_answer' => '',
                    'my_score' => 0,
                    'is_pass' => self::NO_DO_MK_STATE,
                    'is_status' => self::NO_DO_MK_STATE
                ]);

            return true;
        }

        $et_detail = unserialize($data['et_detail']);
        $et_option = unserialize($data['et_option']);

        // 多选题
        if (self::TOPIC_TYPE_MULTIPLE == $et_detail['et_type']) {

            $answer = array_column($my_answer, 'opt');
            $answer = array_filter($answer);
            if (count($answer) < 1) {

                E('_ERR_ANSWER_FIELD');
            }

            $arr = array_column($et_option, 'option_name');
            foreach ($arr as $k => $v) {

                $arr[$k] = strtoupper(trim($v));
            }

            foreach ($answer as $key => &$value) {
                $value = strtoupper(trim($value));
                if (!in_array($value, $arr)) {

                    E('_ERR_ANSWER_FIELD');
                }
            }

            sort($answer);
            $answer = implode(',', $answer);

        } elseif (self::TOPIC_TYPE_QUESTION == $et_detail['et_type']
            || self::TOPIC_TYPE_SINGLE == $et_detail['et_type']
            || self::TOPIC_TYPE_JUDGMENT == $et_detail['et_type']) {

            $answer = array_column($my_answer, 'opt');
            $answer = array_filter($answer);
            if (!count($answer)) {
                // 答案不能为空
                E('_EMPTY_ET_ANSWER');
            }

            if (count($answer) > 1) {
                // 作答失败
                E('_ERR_ANSWER_FIELD');
            }

            $answer = implode(',', $answer);

            if (self::TOPIC_TYPE_SINGLE == $et_detail['et_type']) {
                // 单选题
                $answer = strtoupper(trim($answer[0]));
                $arr = array_column($et_option, 'option_name');
                if (!in_array($answer, $arr)) {
                    // 作答失败
                    E('_ERR_ANSWER_FIELD');
                }

            } elseif (self::TOPIC_TYPE_SINGLE == $et_detail['et_type']) {
                // 判断题
                if (!in_array($answer, ['对', '错'])) {
                    // 作答失败
                    E('_ERR_ANSWER_FIELD');
                }
            }

        } else {
            // 语音答案
            $answerattr = $this->_answer_attach_model->list_by_conds(['ead_id' => $ead_id]);
            $order_ids = array_column($answerattr, 'order_id');

            if ($my_answer) {
                // 如果有答案走下面
                $answer_arr = [];
                foreach ($my_answer as $k => $v) {

                    if (self::ANSWER_TYPE_VOICE == $v['type']) {
                        // 语音答题
                        if (in_array($v['opt'], $order_ids)) {

                            $answer_arr[] = $v;
                        }
                    } else {
                        // 其他
                        $answer_arr[] = $v;
                    }
                }
                $answer = serialize($answer_arr);
            } else {

                $answer = '';
            }
        }
        // 更新答案信息
        $is_status = ($answer == '' ? 0 : 1);

        if ($is_status) {
            // 作答
            $rel = $this->update_by_conds(['ead_id' => $ead_id],
                [
                    'my_answer' => $answer,
                    'is_status' => $is_status
                ]);
            if ($rel) {

                $this->get_answer_score($ead_id, $marking_type, $et_detail['et_type']);
            }

            return $rel;

        } else {

            return false;
        }
    }

    /**
     * 试题分数计算
     *
     * @author: 蔡建华
     * @param $ead_id int 答卷ID
     * @param int $marking_type 1自动阅卷 2手动阅卷
     * @param int $et_type 题型
     *
     * @return int 返回分数
     */
    protected function get_answer_score($ead_id = 0, $marking_type = 0, $et_type = 0)
    {
        $data = $this->_d->get($ead_id);
        if (self::MANUAL_MARKING_TYPE == $marking_type
            && in_array($et_type, [self::TOPIC_TYPE_VOICE, self::TOPIC_TYPE_QUESTION])) {

            return false;
        }

        // 自动阅卷
        $arr = $this->get_topic_score($data);
        $arr['marking_status'] = self::DO_MK_STATE;
        $this->_d->update_by_conds(['ead_id' => $ead_id], $arr);

        return true;
    }

    /**
     * 题目分数正确
     *
     * @author: 蔡建华
     * @param array $data 题目信息
     *
     * @return array 返回 分数和答案是否正确
     */
    protected function get_topic_score($data = [])
    {
        if (empty($data['my_answer'])) {

            $my_score = 0;
            $is_pass = self::NO_MY_PASS;
        } else {

            $et_detail = unserialize($data['et_detail']);
            $et_type = $et_detail['et_type'];
            // 如果是选择题或者多选题
            if (self::TOPIC_TYPE_SINGLE == $et_type || self::TOPIC_TYPE_MULTIPLE == $et_type) {

                $answer = explode(',', $et_detail['answer']);
                // 循环我的回答，判断我的回答里有没有不在答案里的
                $my_answer_arr = explode(',', $data['my_answer']);
                $my_answer_arr = array_filter($my_answer_arr);
                $my_score = $data['score']; // 得分，默认是有分数的
                $is_pass = self::MY_PASS; // 已作答
                foreach ($my_answer_arr as $v) {
                    // 如果我的回答不在答案里，就是错的
                    if (!in_array($v, $answer)) {

                        $my_score = 0;
                        $is_pass = self::NO_MY_PASS;
                        break;
                    }
                }

                /*
                 * 如果我的回答里没有不在答案里的，再判断下我的回答数量和答案数量是否一致
                 * 数量一致就是正确的，否则就是少选了
                 */
                if ($my_score > 0 && count($my_answer_arr) != count($answer)) {
                    $my_score = 0;
                    $is_pass = self::NO_MY_PASS;
                }

            } elseif (self::TOPIC_TYPE_JUDGMENT == $et_type) {

                // 如果是判断题
                $my_answer = trim($data['my_answer']);

                if ($et_detail['answer'] == $my_answer) {

                    $my_score = $data['score'];
                    $is_pass = self::MY_PASS;

                } else {

                    $my_score = 0;
                    if (empty($my_answer)) {

                        $is_pass = self::NO_MY_PASS;

                    } else {

                        $is_pass = self::NO_MY_PASS;
                    }
                }
            } elseif (self::TOPIC_TYPE_VOICE == $et_type) {

                // 如果是语音题
                // 存在答案就认为得满分，不存在则为0
                $my_score = $data['score'];
                $is_pass = self::MY_PASS;

            } else {

                $my_answer = trim($data['my_answer']);

                // 如果是问答题
                if (self::KEYWORD_OPEN == $et_detail['match_type']) {

                    // 匹配关键字方式
                    $my_score = $this->_key_question_score($et_detail['answer_keyword'], $my_answer,
                        $data['score']);

                    // 得满分算回答正确，否则为回答错误
                    if ($my_score == $data['score']) {

                        $is_pass = self::MY_PASS;
                    } else {

                        $is_pass = self::NO_MY_PASS;
                    }
                } else {

                    // 覆盖率方式
                    $is_pass = $this->_coverage_question_score($et_detail['answer'], $et_detail['answer_coverage'],
                        $my_answer);
                    $my_score = $is_pass === true ? $data['score'] : 0;

                    // 得满分算回答正确，否则为回答错误
                    if ($my_score == $data['score']) {

                        $is_pass = self::MY_PASS;
                    } else {

                        $is_pass = self::NO_MY_PASS;
                    }
                }
            }
        }

        return [
            'is_pass' => $is_pass,
            'my_score' => $my_score
        ];
    }

    /**
     * @author: 蔡建华
     *
     * 计算问答题关键字匹配方式的分数
     * @param array $keywords 关键字数组
     * @param string $my_answer 我的回答
     * @param int $score 总分数
     *
     * @return int 得分
     */
    protected function _key_question_score($keywords, $my_answer, $score)
    {
        $my_score = 0; // 最后得分
        $match_all = true; // 是否全部匹配

        // 循环关键字
        foreach ($keywords as $v) {
            $keyWord = trim($v['keyword']);
            // 正则匹配关键字
            if (preg_match("/{$keyWord}/", $my_answer)) {

                $percent = (float)((int)$v['percent'] / 100.00);
                $my_score += $score * $percent;

            } else {
                // 有一个不匹配就记录全部匹配为false
                $match_all = false;
            }
        }
        // 如果全部匹配，就返回满分，否则返回对应的分数
        return $match_all === true ? $score : $my_score;
    }

    /**
     * @author: 蔡建华
     *
     * 计算问答题覆盖率方式的分数
     * @param string $sys_answer 答案
     * @param string $answer_coverage 合格覆盖率
     * @param string $my_answer 我的回答
     *
     * @return boolean 我的回答的覆盖率满足合格覆盖率返回true，否则返回false
     */
    protected function _coverage_question_score($sys_answer, $answer_coverage, $my_answer)
    {
        $answer_coverage = (float)(intval($answer_coverage) / 100.0);
        // 当类型为问答题，进行文本比对
        $user_answer = str_replace(["\r\n", "\r", "\n"], " ", $my_answer);
        $user_answer = preg_replace("/\s(?=\s)/", "\\1", $user_answer);

        $sys_answer = str_replace(["\r\n", "\r", "\n"], " ", $sys_answer);
        $sys_answer = preg_replace("/\s(?=\s)/", "\\1", $sys_answer);

        // 实例化对比类
        $lcs = new Lcs();
        // 我的答案的覆盖率
        $coverage = $lcs->getSimilar($user_answer, $sys_answer);
        return $coverage >= $answer_coverage;
    }

    /**
     * 阅卷批阅答题接口（一次性提交）
     *
     * @author: 蔡建华（houyingcai）
     * @param array $params
     *
     * @return mixed
     */
    public function marking_save($params = [])
    {
        $ea_id = intval($params['ea_id']);
        $submit_type = intval($params['submit_type']);

        if (!$ea_id) {
            // 答卷ID不能为空
        }

        if (!$submit_type) {
            // 阅卷提交类型不能为空
            E('_EMPTY_CHECK_SUBMIT_TYPE');
        }

        if (!in_array($submit_type, [self::CHECK_TYPE_SUBMIT, self::CHECK_TYPE_SUBMIT_NEXT])) {
            // 无效的阅卷提交方式
            E('_ERR_CHECK_SUBMIT_TYPE_INVALID');
        }

        if (empty($params['list'])) {
            // 批阅试题列表不能为空
            E('_EMPTY_CHECK_QUESTION_LIST');
        }

        // 答卷信息
        $answer = $this->_answer_model->get($ea_id);
        if (empty($answer)) {

            E("_EMPTY_MARKING_INFO");
        }

        // 判断阅卷状态是否是待批阅
        if ($answer['answer_status'] != self::READ_WAITING) {

            E("_ERR_MARKING_PAPER");
        }

        // 获取下一份待批阅的答卷ID
        $next_paper = [];
        if (self::CHECK_TYPE_SUBMIT_NEXT == $params['submit_type']) {
            $next_paper = $this->_answer_model->get_by_conds(
                [
                    'ep_id' => $answer['ep_id'],
                    'answer_status' => self::READ_WAITING,
                ],
                ['ea_id' => 'DESC']
            );
        }

        foreach ($params['list'] as $val) {

            if (!intval($val['ead_id'])) {
                // 判断ead_id是否存在
                E('_EMPTY_MARKING_EAD_ID');
            }

            $my_score = $val['my_score'];

            // 获取试题信息
            $data = $this->_d->get($val['ead_id']);
            // 判断分数不合法
            $score = $data['score'];
            if ($my_score < 0 || $my_score > $score) {

                E("_ERR_MARKING_SCORE_MIN");
            }

            // 更新答卷试题状态和分数
            $res = $this->_d->update_by_conds(
                ['ead_id' => $val['ead_id']],
                [
                    'my_score' => $my_score,
                    'is_pass' => $my_score == $score ? self::MY_PASS : self::NO_MY_PASS, // 得满分算正确，否则错误
                    'marking_status' => 1
                ]
            );
            // 判断数据库数据是否更新成功
            if (!$res) {

                return false;
            }
        }

        // 计算答题总分
        $my_score = $this->_d->list_by_conds(['ea_id' => $ea_id], [], [], 'my_score');

        // 返回总分和是否是最后一份答卷
        return [
            'my_score' => array_sum(array_column($my_score, 'my_score')),
            'next_ea_id' => !empty($next_paper) ? $next_paper['ea_id'] : 0,
        ];
    }

    /**
     * 获取待批阅的答卷试题列表（后台）
     *
     * @author: 蔡建华
     * @param array $params
     *
     * @return array
     */
    public function question_list_admin($params)
    {
        $ea_id = intval($params['ea_id']);

        // 答卷信息
        $answer = $this->_answer_model->get($ea_id);
        if (empty($answer)) {

            E("_EMPTY_MARKING_INFO");
        }

        // 判断是否是已批阅状态（type 列表类型（1=批阅，2=查看批阅详情））
        if (self::READ_OVER == $answer['answer_status'] && $params['type'] == 1) {

            E("_ERR_MARKING_PAPER");
        }

        $ep_id = $answer['ep_id'];
        $paper = $this->paper_model->get($ep_id);
        if (empty($paper)) {

            E("_EMPTY_EXAM_DELETED");
        }

        // 判断试卷类型
        if ($paper['paper_type'] != self::EVALUATION_PAPER_TYPE) {

            E("_ERR_EVALUATION_PAPER_TYPE");
        }

        $page = !empty($params['page']) ? intval($params['page']) : self::DEFAULT_PAGE;
        $limit = !empty($params['limit']) ? intval($params['limit']) : self::DEFAULT_LIMIT_ADMIN;

        // 分页
        list($start, $limit) = page_limit($page, $limit);
        $conds = [
            'et_type' => [
                self::TOPIC_TYPE_QUESTION,
                self::TOPIC_TYPE_VOICE
            ],
            'ea_id' => $ea_id,
            'is_status' => PaperService::DO_STATE,
        ];
        $total = $this->_d->count_by_conds($conds);

        $data = [];
        if ($total) {

            $order_option['order_num'] = 'ASC';
            $data = $this->_d->list_by_conds($conds, [$start, $limit], $order_option);
        } else {

            E('_EMPTY_TOP_PAPER_DATA');
        }

        // 获取考生信息
        $user_serv = User::instance();
        $user = $user_serv->getByUid($answer['uid']);

        // 格式化题目列表（阅卷解析）
        $list = $this->question_list_format(
            $data,
            $paper['marking_type'],
            self::ANSWER_MARKING_ANALYSIS
        );

        // 获取下一份该批阅的答卷信息
        $answer_next = $this->_answer_model->get_by_conds(['ea_id<>?' => $ea_id, 'ep_id' => $ep_id, 'answer_status' => self::READ_WAITING]);

        $next_ea_id = 0;
        if ($answer_next) {
            $next_ea_id = $answer_next['ea_id'];
        }

        return [
            'total' => intval($total),
            'limit' => intval($limit),
            'page' => intval($page),
            'ep_name' => $paper['ep_name'],
            'username' => $user['memUsername'],
            'total_score' => $paper['total_score'],
            'my_score' => $answer['my_score'],
            'my_end_time' => $answer['my_end_time'],
            'next_ea_id' => $next_ea_id,
            'list' => $list
        ];
    }

    /**
     * 根据条件计算数量
     *
     * @param array $conds 条件
     * @param string $fields 字段
     *
     * @return number 数量
     */
    public function count_by_conds($conds, $fields = '*')
    {
        return $this->_d->count_by_conds($conds, $fields);
    }

    /**
     * 考试统计处理
     *
     * @param array $datalist 多条考试统计信息处理
     * @param int $ep_id 试卷ID
     *
     * @return bool
     */
    public function cron_statistics($datalist = [], $ep_id = 0)
    {
        if (empty($datalist) || empty($ep_id)) {
            return false;
        }

        // 根据试卷id获取题目扩展信息列表
        $answer_detail_extend_list = $this->_answer_detail_extend_model->list_by_conds(['ep_id' => $ep_id]);

        if (empty($answer_detail_extend_list)) {

            return false;
        }

        // 格式化数据
        $extend_list = [];
        foreach ($answer_detail_extend_list as $val) {
            $extend_list[$val['ep_id']][$val['et_id']] = $val;
        }

        foreach ($datalist as $data) {
            $extend_info = $extend_list[$data['ep_id']][$data['et_id']];
            $this->cron_statistics_one($data, $extend_info);
        }

        return true;
    }

    /**
     * 单条考试统计信息处理
     *
     * @param array $data 单条考试试题数据
     * @param array $extend_info 扩展表信息
     *
     * @return bool
     */
    public function cron_statistics_one($data = [], $extend_info = [])
    {

        // 初始化状态
        $answer_num = 0;
        $options = [];
        $right_num = 0;
        $answer_total = 0;

        if (empty($data)) {

            return false;
        }
        // 将数字传递过来的答卷信息重新发给变量

        $ep_id = $data['ep_id']; // 试卷id
        $ead_id = $data['ead_id']; // 答卷详情
        $esr_id = $data['esr_id']; // 随机题库题目id 或者 快照表id
        $is_pass = $data['is_pass']; // 作答情况：0未作答，1回答正确，2回答错误
        $et_type = $data['et_type']; // 题目类型
        $my_answer = $data['my_answer']; // 用户填写答案
        $et_option = $extend_info['et_option']; // 选项序列化（包含正确答案）
        $is_status = $data['is_status']; // 作答状态（另一种作答状态0未作答，1已作答）
        $et_id = $data['et_id'];
        // 查询答卷基本表，通过ea_id获取答题详情
        $answer = $this->_answer_model->get($data['ea_id']);
        // 判断试卷成绩是否出来，如果出来统计
        // answer_status 0初始化，1待批阅，2批阅中，3已批阅
        if ($answer['answer_status'] < self::READ_OVER) {

            return false;
        }
        // 答卷表用户uid
        $uid = $answer['uid'];
        // 考试ID不存在赋值
        if (!$data['ep_id']) {

            $ep_id = $answer['ep_id'];
        }

        // 考试查询试卷信息表
        $paper = $this->paper_model->get($data['ep_id']);

        // 考试删除、未作答、随机题库题目id 或者 快照表id不存在等条件下不统计
        if (empty($paper) || !$is_status || empty($esr_id)) {

            $this->cron_status($ead_id);
            return false;
        }

        // 试卷类型
        $paper_type = $paper['paper_type']; // 0测评，1模拟
        // 试卷抽取类型 模拟模拟随机固定
        $ep_type = $paper['ep_type']; // 1自主，2固定，3随机

        // 新数据考试处理
        $where = [
            'b.ep_id' => $ep_id,
            'a.esr_id' => $esr_id, // 试卷快照表的（自主、固定）es_id; 随机临时题库的题目ID: er_id
            'b.uid' => $uid, // 用户uid
            'a.cron_status' => self::CRON_DO_STATE, // 计划任务处理状态
            'a.is_status' => self::DO_STATE
        ];
        //（考试统计参加人数是否已经统计）
        $is_member = $this->_d->answer_detail_count($where);


        $statistics = $this->_statistics_model->get_by_conds(['ep_id' => $ep_id, 'esr_id' => $esr_id]);
        // 如果统计数据存在执行如下程序
        if (!empty($statistics)) {
            // 作答人数
            $answer_num = $statistics['answer_num'];
            // 答案统计，序列化答案统计数  如：a:2:{s:1:"A";i:12;s:1:"B";i:13;
            $options = unserialize($statistics['options']);
            // 答对题数
            $right_num = $statistics['right_num'];
            // 题目使用总数
            $answer_total = $statistics['answer_total'];
        }

        if ($is_pass == self::MY_PASS) {
            // 答对题数
            $right_num = $right_num + 1;
        }

        // 题目使用总数
        $answer_total = $answer_total + 1;

        // 统计
        if (self::TOPIC_TYPE_SINGLE == $et_type || self::TOPIC_TYPE_MULTIPLE == $et_type) {
            // 单选和多选
            $answer_array = (array)explode(',', $my_answer);
            // 首次进行统计,没有记录
            $et_option = unserialize($et_option);
            // 选项数组初始化
            $option_common = array_column($et_option, 'option_name');
            if (empty($options)) {
                // 首次进行统计,没有记录
                foreach ($option_common as $v) {
                    // 答案选择中加一，否则不加
                    if (in_array($v, $answer_array)) {
                        $options[$v] = 1;
                    } else {
                        $options[$v] = 0;
                    }
                }
            } else {

                foreach ($options as $k => $v) {
                    if (in_array($k, $answer_array)) {
                        // 已经存在统计的加一1
                        $options[$k] = intval($v) + 1;
                    }
                }
            }
        } elseif (self::TOPIC_TYPE_JUDGMENT == $et_type) {
            // 答案统计
            if (empty($options)) {
                // 判断题首次统计
                if ('对' == $my_answer) {
                    // 判断题作对的统计
                    $options = ['right' => 1, 'error' => 0];
                } elseif ('错' == $my_answer) {
                    // 判断题作错的统计
                    $options = ['right' => 0, 'error' => 1];
                }
            } else {
                if ('对' == $my_answer) {
                    // 判断题作对的统计
                    $options['right'] = 1 + intval($options['right']);
                } elseif ('错' == $my_answer) {
                    // 判断题作错的统计
                    $options['error'] = 1 + intval($options['error']);
                }
            }
        } else {
            // 语音题
            $options = '';
        }

        // 答案统计格式化
        $options = serialize($options);
        if ($is_member == self::IS_MEMBER_STATE) {

            $answer_num += 1;
        }
        try {
            // 开始事务
            $this->start_trans();
            // 更新题目使用次数
            $rel = $this->_topic_model->AddIncNum(['et_id' => $et_id]);
            if (!$rel) {
                $this->rollback();
                return false;
            }
            if (!empty($statistics)) {
                $where = ['ep_id' => $ep_id, 'esr_id' => $esr_id];
                $params = [
                    'answer_num' => $answer_num,
                    'answer_total' => $answer_total,
                    'options' => $options,
                    'right_num' => $right_num
                ];
                $rel = $this->_statistics_model->update_by_conds($where, $params);
            } else {
                $params = [
                    'ep_id' => $ep_id,
                    'paper_type' => $paper_type,
                    'ep_type' => $ep_type,
                    'esr_id' => $esr_id,
                    'et_type' => $et_type,
                    'answer_num' => $answer_num,
                    'answer_total' => $answer_total,
                    'options' => $options,
                    'right_num' => $right_num
                ];
                $rel = $this->_statistics_model->insert($params);
            }
            if (!$rel) {
                $this->rollback();
                return false;
            }
            $rel = $this->_d->update_by_conds(['ead_id' => $ead_id], ['cron_status' => self::CRON_DO_STATE]);

            if ($rel) {

                $this->commit();
            } else {

                $this->rollback();
                return false;
            }
        } catch (\Exception $e) {
            \Think\Log::record($e);
            $this->_set_error($e->getMessage(), $e->getCode());
            // 事务回滚
            $this->rollback();
            return false;
        }
        return true;
    }

    /**
     *  更新统计状态
     *
     * @param $ead_id int 答题ID
     *
     * @return bool
     */
    public function cron_status($ead_id)
    {
        return $this->_d->update_by_conds(['ead_id' => $ead_id], ['cron_status' => self::CRON_DO_STATE]);
    }

    /**
     * 根据条件查询试卷列表
     *
     * @author: 蔡建华
     * @param $conds array 查询条件
     * @param null $page_option 分页参数
     * @param array $order_option 排序参数
     * @param string $fields 查询的字段
     *
     * @return array|bool
     */
    public function answer_detail_list($conds, $page_option = null, $order_option = [], $fields = '*')
    {
        return $this->_d->answer_detail_list($conds, $page_option, $order_option, $fields);
    }

    /**
     * 根据条件查询试卷
     *
     * @author: 蔡建华
     * @param $conds array 查询条件
     * @param null $page_option 分页参数
     * @param array $order_option 排序参数
     * @param string $fields 查询的字段
     *
     * @return array|bool
     */
    public function count_answer_detail_list($conds, $page_option = null, $order_option = [], $fields = '*')
    {
        return $this->_d->count_answer_detail_list($conds, $page_option, $order_option, $fields);
    }

}