<?php
/**
* 试卷-答卷表
* @author: houyingcai
* @email: 594609175@qq.com
* @date : 2017-05-19 17:51:32
* @version $Id$
*/
namespace Common\Service;
use Common\Common\AttachOperation;
use Common\Common\Cache;
use Common\Common\ExamHelper;
use Common\Common\Integral;
use Common\Common\Lcs;
use Common\Common\User;
use Common\Common\Department;
use Common\Common\TaskCenter;
use Common\Common\Train;
use Common\Model\AnswerDetailExtendModel;
use Common\Model\AnswerDetailModel;
use Common\Model\AnswerModel;
use Common\Model\CountModel;
use Common\Model\LikeModel;
use Common\Model\MedalModel;
use Common\Model\MedalRecordModel;
use Common\Model\MedalRelationModel;
use Common\Model\PaperModel;
use Common\Model\RightModel;
use Common\Model\SnapshotModel;
use Common\Model\StatisticsModel;
use Common\Model\TopicModel;
use Common\Model\AnswerAttachModel;
use Common\Common\StudyMap;
use VcySDK\Member;
use VcySDK\Service;
class AnswerService extends AbstractService
{
// 考试通过
const PASS = 1;
// 考试不通过
const UNPASS = 0;
// 不发送消息
const NOT_NEED_SEND_MSG = 0;
// 手动阅卷发送阅卷信息
const SEND_MSG_FOR_MARKING_USER = 1;
// 手动阅卷系统阅卷成绩出来
const SEND_MSG_FOR_JOIN_EXAM_USER = 2;
// 初始批阅状态
const DEFAULT_MARK_STATUS = 0;
// 答卷正常状态
const START_TYPE_INITIAL = 0;
// 答卷异常状态
const START_TYPE_END = 1;
/** @var AnswerAttachModel */
public $_answer_attach_model;
/** $var StatisticsModel */
public $_statistics_model;
/** @var AnswerDetailModel */
protected $_answer_detail_model;
/** @var TopicModel */
protected $_topic_model;
/** @var SnapshotModel */
protected $_snapshot_model;
/** @var LikeModel */
protected $_like_model;
/** @var MedalModel */
protected $_medal_model;
/** @var MedalRelationModel */
protected $_medal_relation_model;
/** @var MedalRecordModel */
protected $_medal_record_model;
/** @var PaperModel */
protected $paper_model;
/** @var RightModel */
protected $_right_model;
/** @var AnswerDetailExtendModel */
protected $_answer_detail_extend_model;
// 构造方法
public function __construct()
{
$this->_d = new AnswerModel();
$this->_like_model = new LikeModel();
$this->_answer_detail_model = new AnswerDetailModel();
$this->paper_model = new PaperModel();
$this->_snapshot_model = new SnapshotModel();
$this->_topic_model = new TopicModel();
$this->_medal_model = new MedalModel();
$this->_right_model = new RightModel();
$this->_medal_relation_model = new MedalRelationModel();
$this->_medal_record_model = new MedalRecordModel();
$this->_answer_attach_model = new AnswerAttachModel();
$this->_statistics_model = new StatisticsModel();
$this->_answer_detail_extend_model = new AnswerDetailExtendModel();
parent::__construct();
}
/**
* 查询考试排名数据
*
* @param int $ep_id 试卷ID
* @param string $uid 用户ID
* @param int $page 页码
* @param int $limit 每页条数
*
* @return array
*/
public function answer_list_all($ep_id = 0, $uid = '', $page = 1, $limit = 10)
{
$cache = &Cache::instance();
$rank_data = [];
try {
// 获取当前试卷缓存信息
$rank_data = $cache->get('Common.Exam_Rank_List_' . $ep_id);
} catch (\Exception $e) {
\Think\Log::record($e);
}
// 用户信息
$users = [];
// 缓存数据为空
if (empty($rank_data)) {
// 查询条件:当前试卷，已批阅状态
$conds = ['ep_id' => $ep_id, 'answer_status' => self::READ_OVER];
// 排序：成绩倒序，时间正序
$order_option = ['my_score' => 'DESC', 'my_time' => 'ASC'];
// 查询字段
$fields = 'uid,ea_id,my_score,my_time';
// 查询考试成绩列表
$data = $this->_d->list_by_conds($conds, null, $order_option, $fields);
// 获取用户信息
$uids = array_filter(array_unique(array_column($data, 'uid')));
sort($uids);
$userlist = $this->getUser($uids);
$k = 1;
foreach ($data as $v) {
if (!array_key_exists($v['uid'], $rank_data)) {
// 排名
$v['ranking'] = $k;
$user = $userlist[$v['uid']];
$v['memID'] = $user['memUid'] ? $user['memUid'] : '';
$v['memUsername'] = $user['memUsername'] ? $user['memUsername'] : '';
$v['memFace'] = $user['memFace'] ? $user['memFace'] : '';
$rank_data[$v['uid']] = $v;
$k++;
}
continue;
}
unset($data);
// 将排名列表存入缓存
$cache->set('Common.Exam_Rank_List_' . $ep_id, $rank_data);
}
$start = ($page - 1) * $limit;
// 取待返数据
$list = array_slice($rank_data, $start, $limit);
// 获取我的排名
$rank_data = array_combine_by_key($rank_data, 'uid');
$ranking = 0;
if (isset($rank_data[$uid]['ranking']) && !empty($rank_data[$uid]['ranking'])) {
$ranking = $rank_data[$uid]['ranking'];
}
// 答卷id集合
$ea_ids = array_column($list, 'ea_id');
// 获取我的点赞数据
$my_like_data = $this->_like_model->list_by_conds(['ea_id' => $ea_ids, 'uid' => $uid]);
// 我的点赞答卷id集合
$my_like_ea_ids = array_unique(array_column($my_like_data, 'ea_id'));
// 获取点赞数
$like_fields = 'ea_id,count(ea_id) as likes';
$likes_data = $this->_like_model->getLikeCount($ea_ids, $like_fields);
// ea_id为键，likes为值
$likes = array_column($likes_data, 'likes', 'ea_id');
$result = [];
foreach ($list as $v) {
// 答卷id
$v['ea_id'] = intval($v['ea_id']);
// 点赞数
$v['likes'] = array_key_exists($v['ea_id'], $likes) ? $likes[$v['ea_id']]['likes'] : 0;
// 是否点赞
$v['is_like'] = in_array($v['ea_id'], $my_like_ea_ids) ? self::SUCCES_STATE : self::FALSE_STATE;
unset($v['uid']);
$result[] = $v;
}
// 缓存不为空，$users为空
if (empty($users[$uid])) {
// 获取用户数据
$users = $this->getUser([$uid]);
}
return [
'ranking' => $ranking,
'memFace' => $users[$uid]['memFace'],
'total' => count($rank_data),
'list' => $result
];
}
/**
* 获取所有人的排名信息
*
* @param int $ep_id
*
* @return array
*/
public function get_rank_all_list($ep_id = 0)
{
// 查询条件:当前试卷，已批阅状态
$conds = ['ep_id' => $ep_id, 'answer_status' => self::READ_OVER];
// 排序：成绩倒序，时间正序
$order_option = ['my_score' => 'DESC', 'my_time' => 'ASC'];
// 查询字段
$fields = 'uid,ea_id,my_score,my_time';
// 查询考试成绩列表
$data = $this->_d->list_by_conds($conds, null, $order_option, $fields);
// 获取用户信息
$uids = array_filter(array_unique(array_column($data, 'uid')));
sort($uids);
$userlist = $this->getUser($uids);
$data_new = [];
$k = 1;
foreach ($data as $v) {
if (!array_key_exists($v['uid'], $data_new)) {
// 排名
$v['ranking'] = $k;
$user = $userlist[$v['uid']];
$v['memID'] = $user['memUid'] ? $user['memUid'] : '';
$v['memUsername'] = $user['memUsername'] ? $user['memUsername'] : '';
$v['memFace'] = $user['memFace'] ? $user['memFace'] : '';
$data_new[$v['uid']] = $v;
$k++;
}
continue;
}
unset($data);
return $data_new;
}
/**
* 获取答卷详情
* @author: 蔡建华
*
* @param array $params 传入参数
* @param array $user 当前用户
* @param array $answer 用户答卷记录
* @param array $paper 试卷信息
* @return array|bool
*/
public function answer_detail_info($params = [], $user = [], $answer = [], $paper = [])
{
$obj_id = 0;
if (isset($params['customtask_id']) && $params['customtask_id']) {
// 任务id
$obj_id = intval($params['customtask_id']);
} elseif (isset($params['plan_id']) && $params['plan_id']) {
// 培训计划id
$obj_id = intval($params['plan_id']);
}
// 考试答题用时为0：该考试尚未交卷
if ($answer['my_time'] == 0) {
E('_ERR_REPEAT_SUBMINT_END');
}
// 如果传递的参数为空，则获取答题记录中的任务、培训ID
if (empty($obj_id)) {
$obj_id = intval($answer['obj_id']);
}
// 判断用户是否有权限访问“任务类”数据
if (PaperService::TASK_TYPE == $paper['exam_type']) {
// 任务
$taskCenter = &TaskCenter::instance();
$taskCenter->checkCustomtaskRight($obj_id, $answer['ep_id'], $user);
}
// 判断用户是否有权限访问“线下培训”数据
if (PaperService::TRAIN_TYPE == $paper['exam_type']) {
// 培训计划
$train = &Train::instance();
$train->checkCustomTrainRight($obj_id, $answer['ep_id'], $user);
}
if (self::EC_CLOSE_STATES == $paper['cate_status']) {
// 试卷分类被禁用：试卷被禁用
E('_ERR_DATA_EXAM_DEL');
}
// 试卷状态
$ep_status = $this->paper_status($paper['exam_status'], $paper['begin_time'], $paper['end_time']);
if (in_array($ep_status, [self::STATUS_END, self::STATUS_STOP])) {
// 考试已结束或者已终止,则返回的查看权限为考试结束的权限
$is_see_after = $paper['is_see_after_over'];
} else {
// 如果考试未结束，则返回的权限为答卷完成的权限
$is_see_after = $paper['is_see_after_submit'];
}
// 答卷id
$ea_id = $answer['ea_id'];
// 答题列表
$my_answer_detail_list = $this->_answer_detail_model->list_by_conds(['ea_id' => $ea_id]);
// 答对的试题数据
$pass_answers = array_filter($my_answer_detail_list, function ($v) {
return $v['is_pass'] == self::MY_PASS;
});
// 做对题数
$my_success_num = count($pass_answers);
// 答错的题数(总答题数-作对的题数)
$my_error_num = count($my_answer_detail_list) - $my_success_num;
// 我的排名
$ranking = $this->get_my_rank($answer['ep_id'], $answer['uid'], $obj_id);
$list = [];
if ($is_see_after >= 2) {
// 如果权限为对错可见或者解析可见，则查询答卷情况格式化(全部解析)
$list = $this->get_answer_detail($my_answer_detail_list, self::ANSWER_TYPE_ALL_ANALYSIS);
}
// 剩余补考次数
$makeup_total = 0;
// 当前试卷待阅卷状态的记录数
$marking_count = 0;
if (self::OPEN_MAKEUP == $paper['is_open_makeup']) {
// 如果开启了补考，此处需要查询已经补考的次数
$makeup_num = $this->_d->count_by_conds(['ep_id' => $answer['ep_id'], 'uid' => $answer['uid'], 'is_makeup' => self::IS_MAKEUP, 'my_time>?' => 0]);
// 计算剩余补考次数
$makeup_total = $paper['makeup_num'] - $makeup_num;
if ($makeup_total < 0) {
$makeup_total = 0;
}
// 查询待批阅的答卷记录数
$marking_count = $this->_d->count_by_conds(['ep_id' => $answer['ep_id'], 'uid' => $answer['uid'], 'answer_status' => self::READ_WAITING]);
}
// 查询未交卷的记录数
$no_submit_count = $this->_d->count_by_conds(['ep_id' => $answer['ep_id'], 'uid' => $answer['uid'], 'my_time' => 0]);
return [
'ea_id' => intval($answer['ea_id']),
'ep_id' => intval($answer['ep_id']),
'ep_status' => $ep_status,
'my_score' => $answer['my_score'],
'my_time' => $answer['my_time'],
'my_error_num' => $my_error_num,
'memUid' => $user['memUid'],
'memFace' => User::instance()->avatar($user['memUid'], $user),
'ranking' => $ranking,
'my_is_pass' => intval($answer['my_is_pass']),
'paper_type' => intval($paper['paper_type']),
'exam_type' => intval($paper['exam_type']),
'marking_type' => intval($paper['marking_type']),
'is_see_after' => intval($is_see_after), // 可见性权限设置
'is_open_makeup' => intval($paper['is_open_makeup']), // 是否开启补考
'makeup_num' => $makeup_total, // 剩余补考次数
'makeup_start_time' => $paper['makeup_start_time'],
'makeup_end_time' => $paper['makeup_end_time'],
'marking_count' => intval($marking_count), // 待批阅的答卷记录数
'no_submit_count' => $no_submit_count,
'list' => $list
];
}
/**
* 获取我的考试排名
*
* @param int $ep_id 试卷ID
* @param string $uid 用户ID
* @param int $obj_id 任务id或培训安排id
*
* @return int|string 我的排名
*/
public function get_my_rank($ep_id = 0, $uid = '', $obj_id = 0)
{
// 我的排名
$ranking = 0;
$cache = &Cache::instance();
// 常规考试,排名从缓存读取
if (empty($obj_id)) {
$rank_data = [];
try {
// 获取当前试卷缓存信息
$rank_data = $cache->get('Common.Exam_Rank_List_' . $ep_id);
} catch (\Exception $e) {
\Think\Log::record($e);
}
// 缓存数据为空
if (empty($rank_data)) {
// 查询考试成绩列表
$conditions = [
'ep_id' => $ep_id,
'answer_status' => self::READ_OVER // 已批阅
];
$page_option = null;
// 排序方式：成绩倒序，用时正序
$order_option = ['my_score' => 'DESC', 'my_time' => 'ASC'];
// 查询字段
$fields = 'uid,ea_id,my_score,my_time';
// 按照成绩倒序查询已批阅的回答记录列表
$data = $this->_d->list_by_conds($conditions, $page_option, $order_option, $fields);
// 获取用户信息
$uids = array_filter(array_unique(array_column($data, 'uid')));
sort($uids);
$users = $this->getUser($uids);
// 排名列表
$data_new = [];
$k = 1;
foreach ($data as $v) {
// 用户不在新数组中，加入新数组,
if (!array_key_exists($v['uid'], $data_new)) {
// 因为成绩是按照倒序排列的，此处只取每个用户的第一条记录，即为用户的最高分
$v['ranking'] = $k; // 排名
$user_info = $users[$v['uid']];
$v['memUsername'] = $user_info['memUsername'] ? $user_info['memUsername'] : '';
$v['memFace'] = $user_info['memFace'] ? $user_info['memFace'] : '';
$data_new[$v['uid']] = $v;
$k++;
}
continue;
}
// 将排名列表存入缓存
$cache->set('Common.Exam_Rank_List_' . $ep_id, $rank_data);
}
$rank_data = array_combine_by_key($rank_data, 'uid');
if (isset($rank_data[$uid]['ranking']) && !empty($rank_data[$uid]['ranking'])) {
// 我的排名
$ranking = $rank_data[$uid]['ranking'];
}
return $ranking;
}
// 查询条件
$conditions = [
'ep_id' => $ep_id,
'obj_id' => $obj_id,
'answer_status' => self::READ_OVER, // 已批阅
];
// 查询字段
$fields = 'uid,ea_id,my_score,my_time';
// 排序方式：成绩倒序，用时正序
$order_option = ['my_score' => 'DESC', 'my_time' => 'ASC'];
// 如果是线下培训或者任务类，查询当前试卷的考试记录列表
$data = $this->_d->list_by_conds($conditions, null, $order_option, $fields);
// 排名数据列表
$data_new = [];
$k = 1;
$ranking = 0;
foreach ($data as $v) {
// 用户不在新数组中，加入新数组
if (!array_key_exists($v['uid'], $data_new)) {
$v['ranking'] = $k;
$data_new[$v['uid']] = $v;
if ($uid == $v['uid']) {
// 如果找到当前用户的排名
$ranking = $k;
break;
}
$k++;
}
continue;
}
unset($data);
return $ranking;
}
/**
* 开始考试
*
* @author: 蔡建华
* @param array $data 试卷信息数据
* @param string $uid 用户ID
* @param int $data_type 考试类型（1；常规，2：任务，3：培训）
* @param int $obj_id 培训计划或者任务ID
* @param int $is_makeup 是否是补考（0：否，1：是）
*
* @return array|bool
*/
public function paper_start_exam($data = [], $uid = '', $data_type = 1, $obj_id = 0, $is_makeup = 0)
{
$ep_id = $data['ep_id'];
$is_old = $data['is_old'];
$ep_type = $data['ep_type'];
// 组装考试开始基本数据
$base = [
'ep_id' => $ep_id,
'uid' => $uid,
'my_begin_time' => MILLI_TIME,
'paper_info' => serialize($data),
'my_time' => 0,
'my_error_num' => 0,
'my_is_pass' => 0,
'is_makeup' => $is_makeup,
'data_type' => $data_type,
'obj_id' => $obj_id
];
// 随机抽取
if (self::TOPIC_RANDOM == $ep_type) {
$answer_temp_serv = new AnswerTempService();
// 根据试卷ID从临时答卷表获取答卷
$snapshot = $answer_temp_serv->get_answer_temp($ep_id);
if (empty($snapshot)) {
// 实例化试卷Service
$paper = new PaperService();
// 兼容老数据
if ($is_old == self::OLD_DATA_STATE) {
$snapshot = $paper->get_temp_list_by_epid($ep_id, 1); // 0：后台抽题，1：前台抽题
} else {
// 题库信息
$bank_topic_data = unserialize($data['bank_topic_data']);
//题库ID集合
$bank_ids = array_column($bank_topic_data, 'eb_id');
// 选题规则
$rule_data = [];
if (!empty($data['rule'])) {
$rule_data = unserialize($data['rule']);
}
// 按照题库题目类型抽题
$snapshot = $paper->random_rule_topic($bank_ids, $data, $bank_topic_data, $rule_data);
}
}
// 按照单选、多选、判断、问答、语音重新组合数组
$singles = $multiples = $judgments = $questions = $voices = [];
foreach ($snapshot as $key => $val) {
// 单选
if (self::TOPIC_TYPE_SINGLE == $val['et_type']) {
$singles[] = $val;
}
// 多选
if (self::TOPIC_TYPE_MULTIPLE == $val['et_type']) {
$multiples[] = $val;
}
// 判断
if (self::TOPIC_TYPE_JUDGMENT == $val['et_type']) {
$judgments[] = $val;
}
// 问答
if (self::TOPIC_TYPE_QUESTION == $val['et_type']) {
$questions[] = $val;
}
// 语音
if (self::TOPIC_TYPE_VOICE == $val['et_type']) {
$voices[] = $val;
}
}
$snapshot = array_merge($singles, $multiples, $judgments, $questions, $voices);
} else {
// 获取从快照组获取题
$snapshot = $this->_snapshot_model->list_by_conds(['ep_id' => $ep_id]);
if (self::UPSET_TOPIC_YES == $data['is_upset_topic']) {
// 如果开启试题打乱
shuffle($snapshot);
}
}
// 获取试题失败
if (empty($snapshot)) {
E('_ERR_BANK_TOPIC_FAILED');
}
$topic = [];
try {
// 开始事务
$this->start_trans();
// 插入考试信息
$ea_id = $this->_d->insert($base);
foreach ($snapshot as $key => $value) {
if (array_key_exists('er_id', $value)) {
// 随机快照表
$esr_id = $value['er_id'];
} elseif (array_key_exists('es_id', $value)) {
// 试卷照表
$esr_id = $value['es_id'];
} else {
// 题库
$esr_id = 0;
}
// 考试试题拼接数据
if ($ep_type == self::TOPIC_RANDOM) {
$order_num = $key + 1;
} else {
$order_num = $value['order_num'];
}
$option_index = '';
if (self::UPSET_OPTION_YES == $data['is_upset_option'] && in_array($value['et_type'], [self::TOPIC_TYPE_SINGLE, self::TOPIC_TYPE_MULTIPLE])) {
// 如果开启了选项打乱且题目是单选或者多选，则此处需要打乱题目选项
$exam_help = new ExamHelper();
// 打乱选项，返回值为打乱的选项（如：A,C,B,D）
$option_index = $exam_help->options_shuffle($value['options']);
}
$val = [
'et_type' => $value['et_type'],
'ea_id' => $ea_id,
'order_num' => intval($order_num),
'is_pass' => 0,
'score' => $value['score'],
'my_score' => 0,
'paper_type' => $data['paper_type'], //试卷使用类型(0:测评试卷，1：模拟试卷)
'ep_id' => $data['ep_id'],
'esr_id' => $esr_id,
'et_id' => $value['et_id'],
'option_index' => $option_index
];
$topic[] = $val;
}
if (self::UPSET_TOPIC_YES == $data['is_upset_topic']) {
// 如果开启了试题打乱
// 打乱试题数组
shuffle($topic);
$topic_index = 1;
foreach ($topic as &$topinfo) {
// 重组题目顺序
$topinfo['order_num'] = $topic_index;
$topic_index++;
}
unset($topinfo);
}
// 插入试题
$this->_answer_detail_model->insert_all($topic);
// 开始创建答卷试题
$this->commit();
} catch (\Exception $e) {
$this->rollback();
E('_ERR_ADD_EXAM_FAILED');
return false;
}
// 返回答卷ID
return ['ea_id' => $ea_id];
}
/**
* 获取考试参与人员列表
*
* @author: 侯英才
* @param array $conds 查询条件参数列表
* @param array $page_option 分页参数
* @param array $order_option 排序参数
* @param string $fields 返回字段
*
* @return array|bool
*/
public function get_mock_join_list($conds, $page_option = null, $order_option = [], $fields = '*')
{
try {
return $this->_d->get_mock_answer_list($conds, $page_option, $order_option, $fields);
} catch (\Exception $e) {
E($e->getCode() . ':' . $e->getMessage());
return false;
}
}
/**
* 统计考试参与人员总数
* @author: 侯英才
* @param array $conds 查询条件参数列表
* @return array|bool
*/
public function count_mock_answer($conds)
{
try {
return $this->_d->count_mock_answer($conds);
} catch (\Exception $e) {
E($e->getCode() . ':' . $e->getMessage());
return false;
}
}
/**
* 获取试卷记录
*
* @author: 蔡建华
* @param array $params 请求参数
* @param string $uid 用户id
* @param int $type 0：不分页；1：分页
*
* @return array|bool
*/
public function test_record_list($params = [], $uid = '', $type = 0)
{
// 试卷id
$ep_id = intval($params['ep_id']);
// 试卷id为空
if (!$ep_id) {
E('_EMPTY_EP_ID');
}
$obj_id = 0;
// 任务id
if (isset($params['customtask_id']) && $params['customtask_id']) {
$obj_id = intval($params['customtask_id']);
} elseif (isset($params['plan_id']) && $params['plan_id']) {
// 培训计划id
$obj_id = intval($params['plan_id']);
}
// 获取我的答卷数据
$info = $this->get_answer_info($ep_id, $uid, $obj_id);
// 获取用户详情（为了兼容后台管理Apicp/Answer/JoinRecord接口，用户名、头像字段改为username、avatar）
$user_info = $this->getUser([$uid]);
$info['username'] = $user_info[$uid]['memUsername'];
$info['avatar'] = $user_info[$uid]['memFace'];
// 数据分页
if ($type) {
// 判断分页参数是否为空，为空赋默认值
$page = !empty($params['page']) ? intval($params['page']) : self::DEFAULT_PAGE;
$limit = !empty($params['limit']) ? intval($params['limit']) : self::DEFAULT_LIMIT;
// 分页
list($start, $limit) = page_limit($page, $limit);
// 分页参数
$page_option = [$start, $limit];
// 排序：发布时间倒序
$order_option['created'] = 'DESC';
// 答题记录查询条件（模拟考试有初始化＝0和已批阅=3两种状态，只查已批阅状态，）
$condition = [
'ep_id' => $ep_id,
'uid' => $uid,
'answer_status' => self::READ_OVER,
];
// 任务或培训ID存在
if ($obj_id) {
$condition['obj_id'] = $obj_id;
}
$total = $this->count_by_conds($condition);
// get_answer_info里面如果答卷数据为空，会抛错"尚未参加考试"，所以此处列表必有数据
$list = $this->list_by_conds($condition, $page_option, $order_option);
} else { // 数据不分页
// 不分页，直接取我的答卷数据返回的列表
$list = $info['my_answer_list_all'];
// 总数
$total = $limit = count($list);
// 页码
$page = 1;
}
unset($info['my_answer_list_all']);
$result = [
'page' => intval($page),
'limit' => intval($limit),
'total' => intval($total),
'list' => $this->format_testRecord($list) // 格式化模拟记录
];
return array_merge($info, $result);
}
/**
* 模拟试卷详情列表
*
* @author: 蔡建华
* @param string $ep_id 试卷ID
* @param string $uid 用户ID
* @param int $obj_id 任务、培训ID
*
* @return array|bool
*/
public function get_answer_info($ep_id = '', $uid = '', $obj_id = 0)
{
// 答题记录查询条件（模拟考试有初始化＝0和已批阅=3两种状态，只查已批阅状态，）
$condition = [
'ep_id' => $ep_id,
'uid' => $uid,
'answer_status' => self::READ_OVER,
];
// 任务或培训ID存在
if ($obj_id) {
$condition['obj_id'] = $obj_id;
}
// 分页
$page_option = null;
// 排序：发布时间倒序
$order_option['created'] = 'DESC';
// 查询字段
$fields = 'ea_id,uid,ep_id,my_score,my_time,my_is_pass,paper_info,answer_status,my_begin_time';
// 查询当前用户试卷的答题记录
$my_answer_list_all = $this->_d->list_by_conds($condition, $page_option, $order_option, $fields);
// 答题记录为空：尚未参加考试
if (empty($my_answer_list_all)) {
E('_ERR_MY_VISIT_NO');
}
// 试卷信息
$info = unserialize($my_answer_list_all[0]['paper_info']);
// 不是模拟试卷
if ($info['paper_type'] != self::SIMULATION_PAPER_TYPE) {
E('_ERR_SIMULATION_PAPER_TYPE');
}
// 试卷状态
$ep_status = $this->paper_status($info['exam_status'], $info['begin_time'], $info['end_time']);
// 历史最高成绩
$high_score = max(array_column($my_answer_list_all, 'my_score'));
// 累计模拟考试次数
$exam_times = count($my_answer_list_all);
// 通过考试的答卷数据
$pass_answers = array_filter($my_answer_list_all, function ($v) {
return $v['my_is_pass'] == self::PASS;
});
// 模拟考试通过次数（及格次数）
$pass_times = count($pass_answers);
// 我的排名
$ranking = $this->get_my_rank($ep_id, $uid);
return [
'high_score' => $high_score,
'pass_times' => intval($pass_times),
'ep_status' => $ep_status,
'exam_times' => intval($exam_times),
'exam_type' => intval($info['exam_type']),
'ranking' => intval($ranking),
'my_answer_list_all' => $my_answer_list_all
];
}
/**
* @author: 蔡建华
*
* 格式化模拟详情页面
*
* @param array $data
*
* @return array
*/
public function format_testRecord($data = [])
{
$result = [];
foreach ($data as $key => $val) {
$result[$key] = [
'ea_id' => intval($val['ea_id']),
'my_score' => $val['my_score'],
'my_time' => $val['my_time'],
'my_begin_time' => $val['my_begin_time'],
'status' => $val['answer_status']
];
}
return $result;
}
/**
* 判断试卷状态
*
* @author: 蔡建华
* @param $ea_id int 答卷ID
* @param $uid string 用户ID
*
* @return array|bool
*/
public function paper_answer_status($ea_id = 0, $uid = '')
{
//获取答卷信息
$ea_data = $this->get_by_conds(['ea_id' => $ea_id, 'uid' => $uid]);
// 答卷信息不存在
if (empty($ea_data)) {
E('_ERR_MY_VISIT_NO');
}
// 查询试卷信息
$ep_id = $ea_data['ep_id'];
$paper = $this->paper_model->get($ep_id);
// 判断试卷状态，其中包括分类状态和试卷状态
if (self::EC_CLOSE_STATES == $paper['cate_status'] || self::PAPER_STOP == $paper['exam_status']) {
E('_ERR_EC_CLOSE_STATES');
}
// 你已经交卷无法答题
if ($ea_data['answer_status'] >= self::READ_WAITING) {
E('_ERR_SUBMIT_ANSWER');
}
// 我的考试开始时间
$my_begin_time = $ea_data['my_begin_time'];
// 分钟
$paper_time = to_milli_time($paper['paper_time'] * 60);
$time = MILLI_TIME;
// 时间到了交卷
$end_time = $my_begin_time + $paper_time;
if ($time > $paper['end_time'] || $time > $end_time) {
$this->submit_papers($ea_id, $uid);
E('_ERR_EC_EXIT_FINISH');
}
// 考试结束时间大于时间结束时间
if ($end_time > $paper['end_time']) {
$left_time = $paper['end_time'] - $time;
// 考试结束时间小与时间结束时间
} else {
$left_time = $end_time - $time;
}
return [
'ep_name' => $paper['ep_name'],
'marking_type' => $paper['marking_type'],
'exam_type' => $paper['exam_type'],
'paper_type' => $paper['paper_type'],
'left_time' => $left_time, // 返回倒计时
'my_begin_time' => $my_begin_time,
'paper_time' => $paper['paper_time'],
'end_time' => $paper['end_time']
];
}
/**
* 根据条件读取数据
*
* @author: 侯英才
* @param array $conds 查询条件数组
* @param array $order_option 排序数组
* @param String $fields 查询字段
*
* @return array|bool
*/
public function get_by_conds($conds, $order_option = [], $fields = '*')
{
try {
return $this->_d->get_by_conds($conds, $order_option, $fields);
} catch (\Exception $e) {
E($e->getCode() . ':' . $e->getMessage());
return false;
}
}
/**
* 自动提交试卷
*
* @author: 蔡建华
* @param int $ea_id 答卷ID
* @param int $uid 用户ID
* @param array $award
* @param int $type 交卷类型 0,自动交卷 1手动交卷
* @param array $score_list 积分策略返回值
*
* @return bool
*/
public function submit_papers($ea_id = 0, $uid = 0, &$award = [], $type = 0, &$score_list = [])
{
// 判断答卷ID是否为空
if (!$ea_id) {
E('_EMPTY_EA_ID');
}
// 判断用户ID不能为空
if (!$uid) {
E('_EMPTY_UID');
}
//获取答卷信息
$ea_data = $this->get_by_conds(['ea_id' => $ea_id, 'uid' => $uid]);
// 答卷信息不存在
if (empty($ea_data)) {
E('_ERR_MY_VISIT_NO');
}
$ep_id = $ea_data['ep_id'];
$paper = $this->paper_model->get_by_conds(['ep_id' => $ep_id]);
$time = MILLI_TIME;
if (self::EC_CLOSE_STATES == $paper['cate_status'] || self::PAPER_STOP == $paper['exam_status']) {
E('_ERR_EC_CLOSE_STATES');
}
// 你已经交卷
if ($ea_data['answer_status'] > 0) {
E('_ERR_REPEAT_SUBMIT_EXAM');
}
// 分钟
$paper_time = to_milli_time($paper['paper_time'] * 60);
// 我的考试开始时间
$my_begin_time = $ea_data['my_begin_time'];
// 时间到了交卷
$end_time = $my_begin_time + $paper_time;
if ($time <= $paper['end_time'] && $time <= $end_time) {
$submit = 1;
//提前交卷
$my_time = ($time - $my_begin_time);
} else {
$submit = 2;
//时间到自动交卷
if ($end_time > $paper['end_time']) {
$my_time = ($paper['end_time'] - $my_begin_time);
} else {
$my_time = ($end_time - $my_begin_time);
}
}
$marking_type = $paper['marking_type'];
$count = 0;
// 交卷处理
try {
// 开始事务
$this->start_trans();
// 未作答的处理成已批阅 0分
$this->_answer_detail_model->update_by_conds([
'marking_status' => self::NO_DO_MK_STATE,
'is_status' => self::NO_DO_MK_STATE,
'ea_id' => $ea_id
], [
'marking_status' => self::DO_MK_STATE,
'my_score' => 0,
'is_pass' => self::NO_MY_PASS
]);
$this->update_paper_join_count($paper, $marking_type, $ep_id, $uid);
// 测评试卷手动阅卷
if (self::MANUAL_MARKING_TYPE == $marking_type && self::EVALUATION_PAPER_TYPE == $paper['paper_type']) {
// 查询已经作答且未批阅
$count = $this->_answer_detail_model->count_by_conds([
'marking_status' => self::NO_DO_MK_STATE,
'is_status' => self::DO_STATE,
'ea_id' => $ea_id,
'et_type' => [self::TOPIC_TYPE_QUESTION, self::TOPIC_TYPE_VOICE]
]);
}
// 手动阅卷有主观题
if ($count > 0) {
// 手动阅卷
$this->update(
['ea_id' => $ea_id],
['my_time' => $my_time, 'my_end_time' => $my_begin_time + $my_time, 'answer_status' => self::READ_WAITING]
);
// 发送消息给阅卷人
$result_status = self::SEND_MSG_FOR_MARKING_USER;
} else {
// 算分函数
$my_score = $this->_answer_detail_model->get_score(['ea_id' => $ea_id, 'marking_status' => 1]);
// 判断是否通过
if ($paper['pass_score'] > $my_score) {
$my_is_pass = 0;
} else {
$my_is_pass = 1;
}
$this->update(
['ea_id' => $ea_id],
[
'my_is_pass' => $my_is_pass, // 是否通过
'my_time' => $my_time, // 用时
'my_end_time' => $my_begin_time + $my_time, //交卷时间
'my_score' => $my_score, // 分数
'answer_status' => self::READ_OVER, // 已阅卷
'marking_time' => MILLI_TIME // 阅卷时间
]
);
// 积分策略业务ID=应用目录_数据ID
$businessid = sprintf('%s_%s', APP_DIR, $ep_id);
// 调用积分策略
$score_list = $this->get_score_list($uid, $paper, $my_score, $my_is_pass, $businessid);
if (self::MANUAL_MARKING_TYPE == $marking_type && self::EVALUATION_PAPER_TYPE == $paper['paper_type']) {
// 考试成绩已出，发送消息
$result_status = self::SEND_MSG_FOR_JOIN_EXAM_USER;
} else {
// 不发送消息
$result_status = self::NOT_NEED_SEND_MSG;
}
}
$this->commit();
} catch (\Exception $e) {
$this->rollback();
E('_ERR_SUBMIT_FAIL');
return false;
}
//添加积分勋章接口
$this->paper_statistics($paper, $uid);
// 添加积分勋章接口
$this->medal($ep_id, $uid, $award);
// 手动阅卷发送阅卷信息
if (self::SEND_MSG_FOR_MARKING_USER == $result_status) {
$this->send_cms_answer($ea_id, AnswerService::MARKING_USER_MSG);
} elseif (self::SEND_MSG_FOR_JOIN_EXAM_USER == $result_status) {
// 手动阅卷系统阅卷成绩出来
$this->send_cms_answer($ea_id, AnswerService::MARKING_RESULT_MSG);
}
// 时间到自动交卷
if (!$type && self::MANUAL_MARKING_TYPE == $submit) {
E('_ERR_AUTO_SUBMIT_TIME');
}
return true;
}
/**
* 统计参加考试与未参加考试的人
*
* @param array $paper 试卷信息数组
* @param int $marking_type 试卷类型
* @param int $ep_id 试卷ID
*
* @param string $uid 考生uid
*/
public function update_paper_join_count($paper = [], $marking_type = 0, $ep_id = 0, $uid = '')
{
// 未参与人员
$unjoin_count = $paper['unjoin_count'] - 1;
if ($unjoin_count < 0) {
$unjoin_count = 0;
}
// 已参与人员
$join_count = $paper['join_count'] + 1;
if ($marking_type == self::MANUAL_MARKING_TYPE) {
// 如果是测评试卷，参与人加1
$this->paper_model->update_by_conds(['ep_id' => $ep_id],
['join_count' => $join_count, 'unjoin_count' => $unjoin_count]);
} else {
// 判断模拟试卷是否已有交卷记录
$submit_count = $this->get_by_conds(['ep_id' => $ep_id, 'uid' => $uid, 'answer_status>?' => self::READ_WAITING]);
if (!$submit_count) {
$this->paper_model->update_by_conds(['ep_id' => $ep_id],
['join_count' => $join_count, 'unjoin_count' => $unjoin_count]);
}
}
}
/**
* 根据积分策略获取积分
*
* @param string $uid 答卷人ID
* @param array $paper 试卷信息
* @param int $my_score 我的得分
* @param int $my_is_pass 是否通过考试（0=未通过，1=通过）
* @param string $businessid 积分策略业务ID
*
* @return array|mixed
*/
public function get_score_list($uid = '', $paper = [], $my_score = 0, $my_is_pass = 0, $businessid = '')
{
$score_list = [];
if (self::INTEGRAL_ACTION_TYPE_NO == $paper['integral_action_type'] && self::CREDIT_ACTION_TYPE_FALSE == $paper['credit_action_type']) {
// 如果不启用策略
return $score_list;
}
// 初始化积分模型
$integral = new Integral();
$count = new CountModel();
// 此处查询通过次数
$num_data = $count->get_by_conds(['uid' => $uid, 'paper_type' => $paper['paper_type']]);
// 组织策略规则
$triggerTypes = [
[
'triggerKey' => 'exam_score', // 考试分数
'value' => intval($my_score),
'remark' => '考试分数'
],
[
'triggerKey' => 'exam_score_range', //考试分数区间
'value' => intval($my_score),
'remark' => '考试分数区间'
]
];
if (!empty($num_data) && !empty($my_is_pass)) {
// 如果是模拟试卷，先查一下是否有已通过的记录
if (self::SIMULATION_PAPER_TYPE == $paper['paper_type']) {
$answer_serv = new AnswerModel();
$pass_total = $answer_serv->count_by_conds([
'uid' => $uid,
'ep_id' => $paper['ep_id'],
'my_is_pass' => 1
]);
// 如果不存在答题通过记录，则加次数
if ($pass_total == 0) {
$u_conds = [
'uid' => $uid,
'paper_type' => $paper['paper_type']
];
$pass_num = $num_data['num'] + 1;
$count->update_by_conds($u_conds, ['num' => $pass_num]);
$triggerTypes[] = [
'triggerKey' => 'pass_num', // 通过试卷数
'value' => intval($pass_num),
'remark' => '通过试卷数'
];
}
} else {
// 测评试卷
// 如果记录存在并且通过考试，则按条件进行数据更新
$u_conds = [
'uid' => $uid,
'paper_type' => $paper['paper_type']
];
$pass_num = $num_data['num'] + 1;
$count->update_by_conds($u_conds, ['num' => $pass_num]);
$triggerTypes[] = [
'triggerKey' => 'pass_num', // 通过试卷数
'value' => intval($pass_num),
'remark' => '通过试卷数'
];
}
} elseif (empty($num_data) && !empty($my_is_pass)) {
// 如果记录不存在并且通过考试，则插入记录
$pass_num = 1;
$i_data = [
'uid' => $uid,
'paper_type' => $paper['paper_type'],
'num' => $pass_num
];
$count->insert($i_data);
$triggerTypes[] = [
'triggerKey' => 'pass_num', // 通过试卷数
'value' => intval($pass_num),
'remark' => '通过试卷数'
];
}
// 如果开始通过
if ($my_is_pass) {
$triggerTypes[] = [
'triggerKey' => 'pass', // 通过
'value' => 1,
'remark' => '通过考试'
];
}
// 是否触发策略（默认不触发）
$is_score_flag = false;
// 初始化触发策略参数
$triggers = [];
// 开启积分策略
if (in_array($paper['integral_action_type'], [self::INTEGRAL_ACTION_TYPE_DEFAULT, self::INTEGRAL_ACTION_TYPE_MY])) {
$is_score_flag = true;
$triggers[] = [
'miType' => 'mi_type0',
'businessStrategyId' => $paper['integral_strategyid'] ? $paper['integral_strategyid'] : '',
];
}
// 开启学分策略
if (in_array($paper['credit_action_type'], [self::CREDIT_ACTION_TYPE_DEFAULT, self::CREDIT_ACTION_TYPE_CUSTOMIZE])) {
$is_score_flag = true;
$triggers[] = [
'miType' => 'mi_type1',
'businessStrategyId' => $paper['credit_strategyid'] ? $paper['credit_strategyid'] : '',
];
}
// 触发策略
if ($is_score_flag) {
// 默认为测评试卷
$businessAct = 'official_exam';
// 如果是模拟试卷
if (self::SIMULATION_PAPER_TYPE == $paper['paper_type']) {
$businessAct = 'mock_exam';
}
foreach ($triggers as $k => $trigger) {
$triggers[$k]['triggerTypes'] = $triggerTypes;
}
// 组装积分策略请求参数
$integral_param = [
'memUid' => $uid,
'businessId' => $businessid,
'businessKey' => 'exam_center',
'businessAct' => $businessAct,
'triggers' => $triggers,
];
$score_list = $integral->changeScore($integral_param);
}
return $score_list;
}
/**
* 更新参与未参与人数
*
* @author: 蔡建华
* @param $data array 试题
*
* @param $uid string 用户ID
*/
public function paper_statistics($data = [], $uid = '')
{
$count = $this->_d->count_by_conds(['ep_id' => $data['ep_id'], 'uid' => $uid, 'my_time>?' => 0]);
if (!$count) {
if (!$data['unjoin_count']) {
$data['unjoin_count'] = 1;
}
$this->paper_model->update_by_paper(
['ep_id' => $data['ep_id']],
['join_count' => $data['join_count'] + 1, 'unjoin_count' => $data['unjoin_count'] - 1]
);
}
}
/**
* 考试激励处理
*
* @author: 蔡建华
* @param int $ep_id 试卷ID
* @param string $uid 用户ID
* @param array &$award 返回数据
*
* @return bool
*/
public function medal($ep_id, $uid = '', &$award = [])
{
// 获取用户信息
$userServ = &User::instance();
$user = $userServ->getByUid($uid);
// 获取用户权限
$rightServ = new RightService();
$right = $rightServ->get_by_right($user);
$data['right'] = $right;
$data['er_type'] = self::RIGHT_MEDAL;
$medal = $this->_medal_model->fetch_all_medal($data);
// 查询出相关激励
if (empty($medal)) {
return true;
}
// 获取符合条件的激励IDS
$em_ids = array_column($medal, 'em_id');
// 查询激励关系列表
$list = $this->_medal_relation_model->list_by_conds(['em_id' => $em_ids]);
// 如果存在符合条件激励
if (empty($list)) {
return true;
}
// 获取激励列表IDS
$em_id_arr = array_column($list, 'em_id');
// 如果查询出激励IDS
if (empty($em_id_arr)) {
return true;
}
// 初始化勋章
$integral = new Integral();
// 获取勋章列表
$integral_list = $integral->listMedal();
// 获取激励列表
$integral_key_list = array_combine_by_key($integral_list, 'im_id');
// 获取激励列表
$result = $this->_medal_model->list_by_conds(['em_id' => $em_id_arr]);
// 实例化积分勋章
$integralUtil = &Integral::instance();
// 遍历激励列表
foreach ($result as $val) {
// 获取当前用户是否已经领取过当期激励
$count = $this->_medal_record_model->count_by_conds(['uid' => $uid, 'em_id' => $val['em_id']]);
// 如果已领取积分或者勋章
if ($count) {
continue;
}
// 查询勋章对应关系
$relate_total = $this->_medal_relation_model->count_by_conds(['ep_id' => $ep_id, 'em_id' => $val['em_id']]);
// 如果没有对应关系
if (!$relate_total) {
continue;
}
// 查出对应ep_list
$em_list = $this->_medal_relation_model->list_by_conds(['em_id' => $val['em_id']]);
$ep_ids = array_column($em_list, 'ep_id');
// 答题列表
$score_list = $this->_d->list_by_conds([
'ep_id' => $ep_ids,
'uid' => $uid,
'my_score >= ?' => $val['em_score']
]);
// 获取分数的epids
$score_ep_ids = array_unique(array_column($score_list, 'ep_id'));
// 判断满足条件的次数
if (count($score_ep_ids) >= $val['em_number']) {
// 获取勋章
if (self::EC_MEDAL_TYPE_MEDAL == $val['em_type']) {
$integralUtil->endowMedal($val['im_id'], $uid, $user['memUsername']);
$params = [
'name' => $integral_key_list[$val['im_id']]['name'],
'url' => '',
'uids' => [$uid],
'power_type' => self::ENDOW_END,
'title' => $val['title']
];
$this->send_msg($params, self::ENDOW_END);
// 激励信息
$award[] = [
'award_id' => intval($val['em_id']), // 激励ID
'award_action' => strval($val['title']), // 激励行为
'description' => strval($val['em_desc']), // 描述
'award_type' => intval($val['em_type']), // 激励类型（1=勋章；2=积分）
'medals' => [
'im_id' => intval($val['im_id']), // 勋章ID
'icon' => strval($integral_key_list[$val['im_id']]['icon']), // 勋章图标URL或者前端路径
'icon_type' => intval($integral_key_list[$val['im_id']]['icon_type']), // 勋章图标来源（1=用户上传；2=系统预设）
'name' => strval($integral_key_list[$val['im_id']]['name']), // 勋章名称
'desc' => strval($integral_key_list[$val['im_id']]['desc']), // 勋章描述
],
'integral' => intval($val['em_integral']), // 积分
];
// 满足次数加入记录
$this->_medal_record_model->insert([
'uid' => $uid,
'em_id' => $val['em_id']
]);
}
}
}
return true;
}
/**
* 发送考试消息
*
* @param int $ea_id
* @param int $type
*/
public function send_cms_answer($ea_id = 0, $type = 0)
{
$ea_data = $this->get_by_conds(['ea_id' => $ea_id]);
$ep_id = $ea_data['ep_id'];
$paper = $this->paper_model->get_by_conds(['ep_id' => $ep_id]);
switch ($type) {
case self::MARKING_RESULT_MSG:
// 获取阅卷人信息
$user = User::instance()->getByUid($ea_data['marking_uid']);
$params = [
'name' => $paper['ep_name'],
'is_cover_open' => $paper['is_cover_open'],
'img_id' => $paper['cover_id'],
'my_end_time' => $ea_data['marking_time'],
'user_name' => $ea_data['marking_uid'] ? $user['memUsername'] : '系统阅卷',
'uids' => ['memID' => $ea_data['uid']],
'ea_id' => $ea_id,
'id' => $ep_id,
'obj_id' => $ea_data['obj_id']
];
$this->send_msg($params, self::MARKING_RESULT_MSG);
break;
case self::MARKING_USER_MSG:
if (self::EVALUATION_PAPER_TYPE == $paper['paper_type'] && self::MANUAL_MARKING_TYPE == $paper['marking_type']) {
// 获取权限
$right = $this->_d_right->list_by_conds([
'epc_id' => $ep_id,
'er_type' => self::RIGHT_MARKING
]);
$uids = array_column($right, 'uid');
// 获取用户信息
$user = User::instance()->getByUid($ea_data['uid']);
$params = [
'name' => $paper['ep_name'],
'is_cover_open' => $paper['is_cover_open'],
'img_id' => $paper['cover_id'],
'user_name' => $paper['is_open_anonymous_marking'] == self::OPEN_ANONYMOUS_MARKING ? '匿名' : $user['memUsername'],
'user_time' => $ea_data['my_end_time'],
'exam_type' => $paper['exam_type'],
'uids' => $uids,
'ea_id' => $ea_id,
'id' => $ep_id
];
$this->send_msg($params, self::MARKING_USER_MSG);
}
break;
}
}
/**
* 判断试卷状态
*
* @author: 蔡建华
* @param $ea_id int 答卷ID
* @param $uid string 用户ID
*
* @return array|bool
*/
public function paper_answer_status_new($ea_id = 0, $uid = '')
{
//获取答卷信息
$ea_data = $this->get_by_conds(['ea_id' => $ea_id, 'uid' => $uid]);
// 答卷信息不存在
if (empty($ea_data)) {
E('_ERR_MY_VISIT_NO');
}
// 查询试卷信息
$ep_id = $ea_data['ep_id'];
$paper = $this->paper_model->get($ep_id);
// 判断试卷状态，其中包括分类状态和试卷状态
if (self::EC_CLOSE_STATES == $paper['cate_status'] || self::PAPER_STOP == $paper['exam_status']) {
E('_ERR_EC_CLOSE_STATES');
}
// 你已经交卷无法答题
if ($ea_data['answer_status'] >= self::READ_WAITING) {
E('_ERR_SUBMIT_ANSWER');
}
// 我的考试开始时间
$my_begin_time = $ea_data['my_begin_time'];
// 分钟
$paper_time = to_milli_time($paper['paper_time'] * 60);
$time = MILLI_TIME;
// 时间到了交卷
$end_time = $my_begin_time + $paper_time;
if ($time > $paper['end_time'] || $time > $end_time) {
E('_ERR_EC_EXIT_FINISH');
}
// 考试结束时间大于时间结束时间
if ($end_time > $paper['end_time']) {
$left_time = $paper['end_time'] - $time;
// 考试结束时间小与时间结束时间
} else {
$left_time = $end_time - $time;
}
return [
'ep_name' => $paper['ep_name'],
'exam_type' => $paper['exam_type'],
'marking_type' => $paper['marking_type'],
'paper_type' => $paper['paper_type'],
// 返回倒计时
'left_time' => $left_time,
'my_begin_time' => $my_begin_time,
'paper_time' => $paper['paper_time'],
'end_time' => $paper['end_time']
];
}
/**
* 自动提交试卷
*
* @author: 何岳龙
* @param int $ea_id 答卷ID
* @param int $uid 用户ID
* @param array $paper 试卷详情
*
* @return bool
*/
public function stop_submit_papers($ea_id = 0, $uid = 0, $paper = [])
{
// 判断答卷ID是否为空
if (!$ea_id) {
return false;
}
// 判断用户ID不能为空
if (!$uid) {
return false;
}
//获取答卷信息
$ea_data = $this->get_by_conds(['ea_id' => $ea_id, 'uid' => $uid]);
// 答卷信息不存在
if (empty($ea_data)) {
return false;
}
$ep_id = $ea_data['ep_id'];
$time = MILLI_TIME;
// 你已经交卷
if (PaperService::READ_OVER == $ea_data['answer_status']) {
return false;
}
// 分钟
$paper_time = to_milli_time($paper['paper_time'] * 60);
// 我的考试开始时间
$my_begin_time = $ea_data['my_begin_time'];
// 时间到了交卷
$end_time = $my_begin_time + $paper_time;
if ($time <= $paper['end_time'] && $time <= $end_time) {
// 提前交卷
$my_time = ($time - $my_begin_time);
} else {
// 时间到自动交卷
if ($end_time > $paper['end_time']) {
$my_time = ($paper['end_time'] - $my_begin_time);
} else {
$my_time = ($end_time - $my_begin_time);
}
}
$marking_type = $paper['marking_type'];
// 交卷处理
try {
// 开始事务
$this->start_trans();
// 未作答的处理成已批阅 0分
$this->_answer_detail_model->update_by_conds([
'marking_status' => self::NO_DO_MK_STATE,
'is_status' => self::DO_PASS_STATE,
'ea_id' => $ea_id
], [
'marking_status' => self::DO_MK_STATE,
'my_score' => 0
]);
// 更新未读人员数已读人员数
$this->update_paper_join_count($paper, $marking_type, $ep_id, $uid);
$my_is_pass = 0; // 未通过
$my_score = 0; // 我的得分
$this->update(
['ea_id' => $ea_id],
[
'my_is_pass' => $my_is_pass, // 是否通过
'my_time' => $my_time, // 用时
'my_end_time' => $my_begin_time + $my_time, //交卷时间
'my_score' => $my_score, // 分数
'answer_status' => self::READ_OVER, // 已阅卷
'marking_time' => MILLI_TIME, // 阅卷时间
]
);
// 积分策略业务ID=应用目录_数据ID
$businessid = sprintf('%s_%s', APP_DIR, $paper['ep_id']);
// 调用积分策略
$this->get_score_list($uid, $paper, $my_score, $my_is_pass, $businessid);
$this->commit();
} catch (\Exception $e) {
$this->rollback();
return false;
}
// 更新参与未参与人数
$this->paper_statistics($paper, $uid);
// 添加积分勋章接口（此处因为都是0分，所以不会触发发勋章）
// $this->medal($ep_id, $uid, $award);
return true;
}
/**
* 【微信端】 提交题目试卷验证
*
* @author: 何岳龙
* @param array $params
* @param string $uid
*
* @return bool
*/
public function end_time_validation($params = [], $uid = '')
{
// 获取答卷详情
$answer_info = $this->_answer_detail_model->get($params['ead_id']);
// 获取得分详情
$info = $this->_d->get($answer_info['ea_id']);
// 获取试卷详情
$paper_info = $this->paper_model->get($info['ep_id']);
// 如果考试考生考试开始时间+考试时长大于结束时间
if (($info['my_begin_time'] + (to_milli_time($paper_info['paper_time'] * 60))) > $paper_info['end_time']) {
// 如果当前时间大于或者等于结束时间
if ($paper_info['end_time'] <= MILLI_TIME) {
// 交卷
$this->submit_papers($answer_info['ea_id'], $uid);
return false;
}
} else {
// 如果当前时间大于开始的结束时间
if (MILLI_TIME >= ($info['my_begin_time'] + (to_milli_time($paper_info['paper_time'] * 60)))) {
// 交卷
$this->submit_papers($answer_info['ea_id'], $uid);
return false;
}
}
return true;
}
/**
* 批阅详情函数
*
* 蔡建华
* @param int $ep_id 试卷ID
* @param string $uid 阅卷人ID
*
* @return bool|array
*/
public function marking_detail($ep_id, $uid = '')
{
$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');
}
// 判断用户是否有权进行操作
$count = $this->_right_model->count_by_conds([
'epc_id' => $ep_id,
'er_type' => self::RIGHT_MARKING,
'uid' => $uid
]);
if (!$count) {
E('_ERR_MARKING_NO_QUIT');
}
// 当前试卷的批阅题数
if (self::TOPIC_CUSTOMER == $paper['ep_type']) {
// 自主选题，批阅题数从快照表中获取
$marking_topics = $this->_snapshot_model->count_by_conds([
'ep_id' => $ep_id,
'et_type' => [self::TOPIC_TYPE_QUESTION, self::TOPIC_TYPE_VOICE],
]);
} else {
// 非自主选题，批阅题数从出题规则中获取
$paper_rule = unserialize($paper['rule']);
$marking_topics = $paper_rule['question_count'] + $paper_rule['voice_count'];
}
// 待批阅人数
$marking_waiting_users = $this->_d->count_by_conds([
'ep_id' => $ep_id,
'answer_status' => self::READ_WAITING,
]);
// 是否是首次批阅
$is_first = $this->_d->count_by_conds([
'ep_id' => $ep_id,
'marking_uid' => $uid,
]);
// 组装格式化数据
$arr = [
'ep_id' => $paper['ep_id'],
'ep_name' => $paper['ep_name'], // 试卷名称
'total_score' => $paper['total_score'], // 考试总分
'pass_score' => $paper['pass_score'], // 及格分数
'topic_count' => intval($paper['topic_count']), // 总题数
'paper_time' => $paper['paper_time'], // 考试时长
'begin_time' => $paper['begin_time'], // 开始时间
'end_time' => $paper['end_time'], // 结束时间
'intro' => $paper['intro'], // 考试说明
'marking_topics' => intval($marking_topics), // 批阅题数
'marking_waiting_users' => intval($marking_waiting_users), // 待批阅人数
'check_status' => !$is_first ? self::FIRST_MARKING_PAPER : self::SECOND_MARKING_PAPER, // 批阅状态（1：首页批阅，2：再次批阅）
'exam_type' => intval($paper['exam_type']),
];
// 封面图片
if (self::IS_COVER_PIC_OPEN == $paper['is_cover_open']) {
$arr['cover_url'] = $this->format_cover($paper['cover_id']);
} else {
$arr['cover_url'] = '';
}
return $arr;
}
/**
* 阅卷交卷接口
*
* 蔡建华
* @param array $params 参数
* @param string $uid 用户ID
*
* @return bool
*/
public function marking_submit($params = [], $uid = '')
{
$ea_id = $params['ea_id'];
// 答卷ID不能为空
if (!$ea_id) {
E('_EMPTY_EA_ID');
}
// 查询答卷记录
$data = $this->_d->get($ea_id);
// 考试记录是否存在
if (empty($data)) {
E('_EMPTY_MARKING_INFO');
}
$ep_id = $data['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');
}
// 不是手动阅卷
if (self::AUTO_MARKING_TYPE == $paper['marking_type']) {
E('_ERR_MARKING_PAPER_TYPE');
}
// 阅卷是否在阅卷
if (self::READ_OVER == $data['answer_status']) {
E('_ERR_MARKING_FINISH');
}
// 判断阅卷人不相同
if ($data['marking_uid'] != $uid) {
E('_ERR_MARKING_NOT_SOME');
}
// 未作答的处理成已批阅 0分
$this->_answer_detail_model->update_by_conds([
'marking_status' => self::NO_DO_MK_STATE,
'is_status' => self::NO_DO_MK_STATE,
"ea_id" => $ea_id
], [
'marking_status' => self::DO_MK_STATE,
'my_score' => 0
]);
// 查询没有批阅的状态
$count = $this->_answer_detail_model->count_by_conds([
'marking_status' => self::NO_DO_MK_STATE,
'ea_id' => $ea_id
]);
// 是否有尚未批阅的题
if ($count) {
E('_ERR_CAN_NOT_FAILED');
}
// 计算总分数
$my_score = $this->_answer_detail_model->get_score([
'ea_id' => $ea_id,
'marking_status' => self::DO_MK_STATE
]);
try {
// 开始事务
$this->start_trans();
// 判断是否通过
if ($paper['pass_score'] > $my_score) {
// 未通过
$my_is_pass = 0;
} else {
// 通过
$my_is_pass = 1;
}
// 积分策略业务ID=应用目录_数据ID
$businessid = sprintf('%s_%s', APP_DIR, $ep_id);
// 调用积分策略（ 此处uid必须传答卷人ID）
$this->get_score_list($data['uid'], $paper, $my_score, $my_is_pass, $businessid);
// 阅卷交卷算分
$this->_d->update_by_conds(['ea_id' => $ea_id],
[
'my_score' => $my_score,
'my_is_pass' => $my_is_pass,
'answer_status' => self::READ_OVER,
'marking_time' => MILLI_TIME
]);
$this->commit();
} catch (\Exception $e) {
$this->rollback();
return false;
}
// 考试激励规则调用
$this->paper_statistics($paper, $data['uid']);
$award = [];
// 添加积分勋章接口
$this->medal($paper['ep_id'], $data['uid'], $award);
return true;
}
/**
* 通过试卷IDS查询对应试卷已参与人员统计列表
*
* @param array $ep_ids 试卷IDS
*
* @return array
*/
public function list_by_total($ep_ids = [])
{
// 如果试卷IDS为空
if (empty($ep_ids)) {
return [];
}
// 获取列表
$list = $this->_d->list_by_total($ep_ids);
return $list;
}
/**
* 执行自定义查询SQL语句（安装应用回调时用）
* @author 侯英才
* @param string $sql 执行的SQL语句
* @return mixed
*/
public function query($sql)
{
return $this->_d->query($sql);
}
/**
* 执行自定义非查询SQL语句（安装应用回调时用）
*
* @author 侯英才
* @param string $sql 执行的SQL语句
*
* @return mixed
*/
public function execute($sql)
{
return $this->_d->execute($sql);
}
/**
* 组装查询条件
*
* @param $paper array 试卷信息
* @param $params array 传入的参数
*
* @return array 返回组装完成的条件数组
*/
public function get_conditions($paper, $params)
{
// 查询条件初始化
$conditions = [
'ep_id' => $paper['ep_id'],
'my_time > ?' => 0
];
// 部门、岗位、角色的用户id交集
$djr_uids = $this->get_dp_job_role_uids($params, $paper['ep_id']);
if (!empty($djr_uids)) {
$conditions['uid'] = $djr_uids;
}
return $conditions;
}
/**
* 根据部门、岗位、角色、员工名称获取用户的id集合
*
* @param array $params
* + dpIds -部门ID数组
* + memJob -岗位ID
* + memRole -角色ID
* + memUsername -员工名称
* @param int $ep_id 试卷ID
*
* @return array
*/
public function get_dp_job_role_uids($params, $ep_id)
{
// 部门、岗位、角色的用户id交集
$djr_uids = [];
$user = User::instance();
// 【部门】
if (isset($params['dpIds']) && !empty($params['dpIds']) && is_array($params['dpIds'])) {
$params_dpids = $params['dpIds'];
$dpServ = &Department::instance();
// 取子级部门ID
$child_ids = $dpServ->list_childrens_by_cdid($params_dpids);
// 合并部门ID
$dp_ids = array_merge($params_dpids, array_values($child_ids));
$dp_conds = ['dpIdList' => $dp_ids];
$dp_users = $user->listAll($dp_conds);
if (!empty($dp_users)) {
// 选择部门下的员工id集合
$d_uids = array_column($dp_users, 'memUid');
} else {
$d_uids = [0];
}
// 组装查询条件
$dp_uids = $this->get_uids($ep_id, $d_uids);
if (!empty($djr_uids)) {
$djr_uids = array_intersect($djr_uids, $dp_uids);
if (empty($djr_uids)) {
// 空查询所有 为了避免查询所有传入0
$djr_uids = [0];
}
} else {
$djr_uids = $dp_uids;
}
}
// 【岗位】
if (isset($params['memJob']) && $params['memJob']) {
$job_ids = [$params['memJob']];
$job_conds = [
'jobIdList' => $job_ids
];
// 获取岗位的员工列表
$job_users = $user->listAll($job_conds);
if (!empty($job_users)) {
// 选择岗位下的员工id集合
$j_uids = array_column($job_users, 'memUid');
} else {
$j_uids = [0];
}
// 组装查询条件
$job_uids = $this->get_uids($ep_id, $j_uids);
if (!empty($djr_uids)) {
$djr_uids = array_intersect($djr_uids, $job_uids);
if (empty($djr_uids)) {
// 空查询所有 为了避免查询所有传入0
$djr_uids = [0];
}
} else {
$djr_uids = $job_uids;
}
}
// 【角色】
if (isset($params['memRole']) && $params['memRole']) {
$role_ids = [$params['memRole']];
// 查询条件：角色id数组
$role_conds = ['roleIdList' => $role_ids];
// 获取角色的员工列表
$role_users = $user->listAll($role_conds);
if (!empty($role_users)) {
// 角色的员工id集合
$r_uids = array_column($role_users, 'memUid');
} else {
$r_uids = [0];
}
// 组装查询条件
$role_uids = $this->get_uids($ep_id, $r_uids);
if (!empty($djr_uids)) {
$djr_uids = array_intersect($djr_uids, $role_uids);
if (empty($djr_uids)) {
// 空查询所有 为了避免查询所有传入0
$djr_uids = [0];
}
} else {
$djr_uids = $role_uids;
}
}
// 【标签】
if (isset($params['memTag']) && $params['memTag']) {
$tag_ids = [$params['memTag']];
// 查询条件：标签id数组
$tag_conds = ['tagIdList' => $tag_ids];
// 获取标签的员工列表
$tag_users = $user->listAll($tag_conds);
if (!empty($tag_users)) {
// 标签的员工id集合
$r_uids = array_column($tag_users, 'memUid');
} else {
$r_uids = [0];
}
// 组装查询条件
$tag_uids = $this->get_uids($ep_id, $r_uids);
if (!empty($djr_uids)) {
$djr_uids = array_intersect($djr_uids, $tag_uids);
if (empty($djr_uids)) {
// 空查询所有 为了避免查询所有传入0
$djr_uids = [0];
}
} else {
$djr_uids = $tag_uids;
}
}
// 【员工名称】
if (isset($params['memUsername']) && $params['memUsername']) {
$user_conds = ['memUsername' => $params['memUsername']];
// 查询
$sel_users = $user->listAll($user_conds);
// 检索员工存在
if (!empty($sel_users)) {
// 员工id
$memUserids = array_column($sel_users, 'memUid');
} else {
// 空查询所有 为了避免查询所有传入0
$memUserids = [0];
}
if (!empty($djr_uids)) {
$djr_uids = array_intersect($djr_uids, $memUserids);
if (empty($djr_uids)) {
// 空查询所有 为了避免查询所有传入0
$djr_uids = [0];
}
} else {
$djr_uids = $memUserids;
}
}
return $djr_uids;
}
/**
* 组装查询条件－部门、岗位或角色下答卷的员工id集合
*
* @param $ep_id string 试卷id
* @param $jr_uids array 岗位或角色下的员工id
*
* @return mixed 员工id
*/
public function get_uids($ep_id, $jr_uids)
{
// 返回结果初始化
$res = [];
// 答卷的员工id集合
$an_conds = [
'ep_id' => $ep_id,
'my_time > ?' => 0
];
$joins = $this->list_by_conds($an_conds);
if (!empty($joins)) {
// 答卷的员工id集合
$join_uids = array_unique(array_column($joins, 'uid'));
// 选择岗位/角色下的答卷的员工id(取交集)
$res_uids = array_intersect($jr_uids, $join_uids);
if (!empty($res_uids)) {
$res = $res_uids;
} else {
$res = [0];
}
}
return $res;
}
/**
* 根据键值查找数组
*
* @param array $arr 待查找数组
* @param string $key 键
* @param string $val 值
*
* @return array|mixed
*/
public function seekarr($arr = [], $key, $val)
{
// 初始化返回数组
$data = [];
foreach ($arr as $v) {
$str = json_encode($v);
preg_match_all("/\{[^\{]*\"" . $key . "\"\:\"" . $val . "\"[^\}]*\}/", $str, $m);
// 键值匹配
if ($m && $m[0]) {
foreach ($m[0] as $va) {
$res = json_decode($va, true);
array_push($data, $res);
}
}
}
return $data;
}
/**
*
*
* @param $ep_id int 试卷ID
* @param $paper array 试卷信息
* @param $params array 参数
*
* @return int
*/
public function get_un_total($ep_id, $paper, $params)
{
$conds = [
'epc_id' => $ep_id,
'er_type' => AnswerService::RIGHT_PAPER
];
// 获取未参与考试人员列表
$unjoin_data = $this->get_unjoin_data($conds, $ep_id, $paper['is_all']);
// 未参加人的列表
$unjoin_list = $unjoin_data['unjoin_list'];
// 【部门】
if (isset($params['dpIds']) && !empty($params['dpIds']) && is_array($params['dpIds'])) {
$params_dpids = $params['dpIds'];
$dpServ = &Department::instance();
// 取子级部门ID
$dp_ids = $dpServ->list_childrens_by_cdid($params_dpids, true);
sort($dp_ids);
$conditions['dpIdList'] = $dp_ids;
}
// 【岗位】
if (isset($params['memJob']) && $params['memJob']) {
$conditions['jobIdList'] = [$params['memJob']];
}
// 【角色】
if (isset($params['memRole']) && $params['memRole']) {
$conditions['roleIdList'] = [$params['memRole']];
}
// 【标签】
if (isset($params['memTag']) && $params['memTag']) {
$conditions['tagIdList'] = [$params['memTag']];
}
// 【员工名称】
if (isset($params['memUsername']) && $params['memUsername']) {
$conditions['memUsername'] = $params['memUsername'];
}
// 如果存在查询条件
if (!empty($conditions)) {
$user_select_list = User::instance()->listAllBasic($conditions);
if (!empty($user_select_list)) {
$unjoin_list = array_intersect($unjoin_list, array_column($user_select_list, 'memUid'));
} else {
$unjoin_list = [];
}
}
$total = 0;
if (!empty($unjoin_list)) {
sort($unjoin_list);
// 实例化
$member = new Member(Service::instance());
$member_conds = [
'memUids' => $unjoin_list,
];
// 获取未读人员列表
$list = $member->listAll($member_conds);
// 总人数
$total = $list['total'];
}
return $total;
}
/**
* 获取考试未参与考试人员列表及人数
*
* @author: 侯英才
* @param array $conds 查询权限条件
* @param int $ep_id 试卷ID
* @param int $is_all 是否是全公司
*
* @return array -返回参数
* + unjoin_list -未参与人列表
* + join_count -已参与人总数
*/
public function get_unjoin_data($conds, $ep_id, $is_all = 0)
{
$right_serv = new RightService();
// 参与考试的权限范围
if ($is_all != self::AUTH_ALL) {
$rights = $right_serv->list_by_conds($conds);
// 格式化权限范围
$right_view = $right_serv->format_db_data($rights);
}
$right_view['is_all'] = $is_all;
// 获取要参加考试的全部人员
$all_join = $right_serv->list_uids_by_right($right_view);
// 已经参加了考试的人员
$join = $this->_d->list_by_conds(['ep_id' => $ep_id, 'my_time > ?' => 0]);
$join = array_column($join, 'uid');
$join = array_unique($join);
// 初始未参加考试人员
$unjoin = [];
// 遍历全部邀请人员
foreach ($all_join as $key => $uid) {
// 如果不在已参加的人员中
if (!in_array($uid, $join) && !empty($uid)) {
$unjoin[] = $uid;
}
}
// 已参与总人数
$join_count = count($join);
return [
'unjoin_list' => $unjoin, // 未参与列表
'join_list' => $join,
'join_count' => (int)$join_count, // 已参与人数
];
}
/**
* 组装查询条件
*
* @param $paper array 试卷信息
* @param $params array 传入的参数
*
* @return array 返回组装完成的条件数组
*/
public function get_unjoin_conditions($paper, $params)
{
// 查询条件初始化
$conditions['ep_id'] = $paper['ep_id'];
// 部门、岗位、角色的用户id交集
$djr_uids = $this->get_dp_job_role_uids($params, $paper['ep_id']);
if (!empty($djr_uids)) {
$conditions['uid'] = $djr_uids;
}
return $conditions;
}
/**
* 交卷－全部试题
* @param array $params 参数
* + int $ea_id 答卷id
* + int $uid 用户id
* + array $qa_list 答题列表
* + Int $data_type 考试类型(1:常规试卷，2：任务类，3:线下培训)
* + Int $obj_id 任务、培训ID
* @param array $award 激励返回
* @param array $answer_info 答卷数据（answer表详情）
*
* @return mixed
*/
public function submit_all($params = [], &$award = [], $answer_info = [])
{
// 答卷信息
$ea_id = $params['ea_id'];
// 试卷id
$ep_id = $answer_info['ep_id'];
// 试卷信息
$paper = $this->paper_model->get($ep_id);
// 答卷信息不存在
if (empty($paper)) {
E('_EMPTY_PAPER_DATA');
}
// 试卷为禁止状态
if (self::EC_CLOSE_STATES == $paper['cate_status']) {
E('_ERR_EC_CLOSE_STATES');
}
// 已经交卷
if ($answer_info['answer_status'] > 0) {
E('_ERR_REPEAT_SUBMIT_EXAM');
}
// 当前毫秒时间
$now_time = MILLI_TIME;
// 考试时长
$paper_time = to_milli_time($paper['paper_time'] * 60);
// 判断用户是否有权限访问“学习地图类”数据
if (PaperService::OTHER_TYPE == $paper['exam_type']) {
$map_id = $params['map_id'];
$path_id = $params['path_id'];
if (!empty($map_id) && !empty($path_id)) {
$mapServ = new StudyMap($map_id);
$mapServ->checkRight($path_id, $ep_id, $params['user_info'], $app = '');
}
}
if (self::IS_MAKEUP == $answer_info['is_makeup']) {
// 如果是补考，考试结束时间为补考结束时间
$paper_end_time = $paper['makeup_end_time'];
} else {
// 如果不是补考
if (self::NOMAL_TYPE == $paper['exam_type']) {
// 常规试卷
$paper_end_time = $paper['end_time'];
} else {
// 任务类，线下培训类
$paper_end_time = $answer_info['my_begin_time'] + $paper_time;
}
}
// 考生考试开始时间
$my_begin_time = $answer_info['my_begin_time'];
// 考生交卷截止时间
$answer_end_time = $my_begin_time + $paper_time;
// 提前交卷
if ($now_time <= $answer_end_time && $now_time <= $paper_end_time) {
// 考生用时
$my_time = $now_time - $my_begin_time;
} else { // 到截止时间交卷
// 考生在考试结束时间之后交卷
if ($answer_end_time > $paper_end_time) {
// 考生用时：考试结束时间－考生考试开始时间
$my_time = $paper_end_time - $my_begin_time;
} else { // 考生在考试结束时间之前交卷
// 考试用时：考试交卷截止时间－考生考试开始时间
$my_time = $answer_end_time - $my_begin_time;
}
}
// 交卷所需数据
$data = [
'uid' => $answer_info['uid'],
'ea_id' => $ea_id,
'paper' => $paper,
'my_time' => $my_time,
'my_begin_time' => $my_begin_time,
'data_type' => $params['data_type'], // 数据类型
'obj_id' => $params['obj_id'] // 任务、培训ID
];
// 处理交卷 $score_list为积分策略返回值
$this->do_submit($data, $params['qa_list'], $result_status, $score_list, $answer_info['is_makeup']);
// 如果不是补考
if (self::IS_MAKEUP != $answer_info['is_makeup']) {
// 更新考试已参加与未参加人数
$this->paper_statistics($paper, $answer_info['uid']);
// 添加积分勋章接口，返回激励、积分策略信息$award
$this->medal($ep_id, $answer_info['uid'], $award);
}
// 手动阅卷发送阅卷信息
if (self::SEND_MSG_FOR_MARKING_USER == $result_status) {
$this->send_cms_answer($ea_id, AnswerService::MARKING_USER_MSG);
} elseif (self::SEND_MSG_FOR_JOIN_EXAM_USER == $result_status) {
// 手动阅卷系统阅卷成绩出来(过滤其他类型)
if (PaperService::OTHER_TYPE != $paper['exam_type']) {
$this->send_cms_answer($ea_id, AnswerService::MARKING_RESULT_MSG);
}
}
return [
'res' => true,
'score_list' => $score_list
];
}
/**
* 交卷
* @param array $data 函数所需数据
* @param array $qa_list 答题列表
* @param int $result_status 手动阅卷状态
* @param array $score_list 积分策略返回数据
* @param int $is_makeup 是否是补考（0：否，1：是）
*
* @return bool
*/
public function do_submit($data = [], $qa_list = [], &$result_status = 0, &$score_list = [], $is_makeup = 0)
{
// 答卷id
$ea_id = $data['ea_id'];
// 答卷详情列表
$detail_conds['ea_id'] = $ea_id;
$answer_detail_list = $this->_answer_detail_model->list_by_conds($detail_conds);
$answer_detail_list = array_combine_by_key($answer_detail_list, 'ead_id');
// 阅卷类型(1:自动阅卷 2:手动阅卷)
$marking_type = $data['paper']['marking_type'];
// 试卷id
$ep_id = $data['paper']['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');
// 交卷
try {
// 开始事务
$this->start_trans();
// 题目类型：问答题、语音题
$et_types = [
self::TOPIC_TYPE_QUESTION,
self::TOPIC_TYPE_VOICE
];
// 手动阅卷主观题数量
$count = 0;
// 回答中的图片附件
$at_ids = [];
// 循环处理答题列表
foreach ($qa_list as $key => $val) {
// 题目扩展信息
$extend_info = $answer_detail_extend_list[$answer_detail_list[$val['ead_id']]['et_id']];
// 题目详情
$et_detail = unserialize($extend_info['et_detail']);
// 获取答案字符串
$answer = $this->get_answer($val, $et_detail);
// 空答案，更改状态为不通过、未作答、已批阅，得分为0
if (!$answer) {
// 组装更新数据
$un_data = [
'my_answer' => '',
'my_score' => 0,
'is_pass' => self::NO_MY_PASS, // 答题状态 0未作答(没有卵用，代码中未使用此判断作答状态，而是使用的is_status) 1已通过 [2未通过]
'is_status' => self::DO_PASS_STATE, // 作答状态 [0未作答] 1已作答
'marking_status' => self::DO_MK_STATE // 批阅状态 0待批阅 [1已批阅]
];
$this->_answer_detail_model->update($val['ead_id'], $un_data);
} else {
$option_index = $answer_detail_list[$val['ead_id']]['option_index'];
// 如果该题目启用了选项打乱
if (!empty($option_index)) {
$exam_help = new ExamHelper();
// 装换用户提交的答案为标准题目选项对应的答案
$answer = $exam_help->change_option_save($answer, $option_index);
}
// 提交的答案不为空，保存答案
// ============= 事物 写入不能再方法内 =====================
// 更新答案、答题状态
$de_data = [
'my_answer' => $answer,
'is_status' => self::MY_PASS // 答题状态：已作答
];
$res = $this->_answer_detail_model->update($val['ead_id'], $de_data);
if ($et_detail['et_type'] == self::TOPIC_TYPE_VOICE) {
// 如果是语音题，并且答案是不为空的，取出其中的附件ID
$my_answer = unserialize($answer);
foreach ($my_answer as $at_info) {
// 如果回答中含有图片
if ($at_info['type'] == self::ANSWER_TYPE_IMG) {
// 取出图片ID
$at_ids[] = $at_info['opt'];
}
}
}
// 更新成功
if ($res) {
// 计算试题分数
$ead_id = $val['ead_id'];
$et_type = $et_detail['et_type'];
$detail_data = $this->_answer_detail_model->get($ead_id);
// 手动阅卷 && 题目类型是问答或语音
if (self::MANUAL_MARKING_TYPE == $marking_type &&
in_array($et_type, $et_types)
) {
// do nothing
} else {
// 自动阅卷
$arr = $this->get_topic_score($detail_data);
$arr['marking_status'] = self::DO_MK_STATE; // 批阅状态 0待批阅 [1已批阅]，此处默认已批阅
$this->_answer_detail_model->update($ead_id, $arr);
}
}
// ======================================================
}
// 开启手动阅卷 && 测评试卷 && 答案不为空 && 问答题或语音题
if (self::MANUAL_MARKING_TYPE == $marking_type
&& self::EVALUATION_PAPER_TYPE == $data['paper']['paper_type']
&& $answer
&& in_array($et_detail['et_type'], $et_types)
) {
$count++;
}
}
// 答卷表待更新数据
$read_data = [
'my_time' => $data['my_time'],
'my_end_time' => $data['my_begin_time'] + $data['my_time']
];
// 通知uc附件使用情况
$attrch_serv = new AttachOperation();
$attrch_serv->insert_attach(
APP_DIR,
'paper',
$ep_id,
['attach_ids' => $at_ids]
);
// 手动阅卷主观题存在（循环中，只有【开启手动阅卷】的【测评试卷】才会加数量，所以这里直接用这个数量判断就可以）
if ($count) {
// 追加答卷表待更新数据
$read_data['answer_status'] = self::READ_WAITING; // 批阅状态：待批阅
$result_status = self::SEND_MSG_FOR_MARKING_USER; // 手动阅卷发送阅卷信息
} else {
// 自动阅卷,直接出分,并更新状态是否已通过考试
// 计算已批阅的总分
$score_conds = [
'ea_id' => $ea_id,
'marking_status' => self::DO_MK_STATE // 批阅状态 0待批阅 [1已批阅]
];
// 考试得分
$my_score = $this->_answer_detail_model->get_score($score_conds);
// 及格分大于得分
if ($data['paper']['pass_score'] > $my_score) {
// 不通过
$my_is_pass = self::UNPASS;
} else {
// 通过
$my_is_pass = self::PASS;
}
// 追加答卷表待更新数据
$read_data['my_score'] = $my_score;
$read_data['my_is_pass'] = $my_is_pass;
$read_data['answer_status'] = self::READ_OVER; // 批阅状态 0初始化 1待批阅 2批阅中 [3已批阅]
$read_data['marking_time'] = MILLI_TIME;
// 开启手动阅卷 && 测评试卷
if (self::MANUAL_MARKING_TYPE == $marking_type
&& self::EVALUATION_PAPER_TYPE == $data['paper']['paper_type']
) {
// 手动阅卷系统阅卷成绩出来
$result_status = self::SEND_MSG_FOR_JOIN_EXAM_USER;
} else {
// 不发送消息
$result_status = self::NOT_NEED_SEND_MSG;
}
if ($data['paper']['exam_type'] == self::NOMAL_TYPE) {
// 积分策略业务ID=应用目录_数据ID
$businessid = sprintf('%s_%s', APP_DIR, $data['paper']['ep_id']);
$read_data['businessid'] = $businessid;
if (self::IS_MAKEUP != $is_makeup) {
// 不是补考，调用积分策略
$score_list = $this->get_score_list($data['uid'], $data['paper'], $my_score, $my_is_pass, $businessid);
}
} else {
$read_data['businessid'] = '';
}
}
// 更新答卷表数据
$read_cond['ea_id'] = $ea_id;
$read_data['data_type'] = $data['data_type']; // 数据类型(1:常规试卷，2：任务类，3:线下培训)
$read_data['obj_id'] = $data['obj_id']; // 任务、培训ID
// 此处查询是否存在最高分
$top_score = $this->get_by_conds(['ep_id' => $ep_id, 'is_score_top' => self::IS_SCORE_TOP_TRUE, 'uid' => $data['uid'], 'answer_status' => self::READ_OVER]);
// 默认不是最高分
$is_score_top = self::IS_SCORE_TOP_FALSE;
if (empty($top_score)) {
// 如果之前的最高分记录为空，设置为最高分
$is_score_top = self::IS_SCORE_TOP_TRUE;
} elseif ($top_score['my_score'] < $read_data['my_score']) {
// 如果之前的最高分小于当前得分，设置为最高分
$is_score_top = self::IS_SCORE_TOP_TRUE;
// 将之前的最高分记录置为非最高分
$this->update($top_score['ea_id'], ['is_score_top' => self::IS_SCORE_TOP_FALSE]);
}
$read_data['is_score_top'] = $is_score_top; // 是否最高分
$this->update($read_cond, $read_data);
$this->commit();
} catch (\Exception $e) {
$this->rollback();
E('_ERR_SUBMIT_FAIL');
return false;
}
return true;
}
/**
* 获取答案字符串
* @param array $val 答案数据
* @param array $et_detail 题目详情
*
* @return array|string 答案字符串
*/
public function get_answer($val = [], $et_detail = [])
{
$str_answer = '';
// 多选题
if (self::TOPIC_TYPE_MULTIPLE == $et_detail['et_type']) {
$answer = [];
if (isset($val['my_answer']) && !empty($val['my_answer'])) {
$answer = array_filter(array_column($val['my_answer'], 'opt'));
}
if (!empty($answer)) {
foreach ($answer as $key => &$value) {
$value = strtoupper(trim($value));
}
sort($answer);
$str_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']
) { // 问答、单选、判断题
$str_answer = '';
if (isset($val['my_answer']) && !empty($val['my_answer'])) {
$answer = array_filter(array_column($val['my_answer'], 'opt'));
$str_answer = implode(',', $answer);
// 单选题
if (self::TOPIC_TYPE_SINGLE == $et_detail['et_type'] && $answer[0]) {
// 答案转大写
$str_answer = strtoupper(trim($answer[0]));
}
}
} else { // 语音题
// 语音答案
$attach_cond['ead_id'] = $val['ead_id'];
$answerattr = $this->_answer_attach_model->list_by_conds($attach_cond);
// 媒体文件顺序编号
$order_ids = array_column($answerattr, 'order_id');
if ($val['my_answer']) {
$answer_arr = [];
foreach ($val['my_answer'] as $k => $v) {
// 语音答题
if (self::ANSWER_TYPE_VOICE == $v['type']) {
// 媒体文件存在
if ($v['opt'] && in_array($v['opt'], $order_ids)) {
$answer_arr[] = $v;
}
} else { // 其他
$answer_arr[] = $v;
}
}
// 答案不为空
if (!empty($answer_arr)) {
// 答案序列化
$str_answer = serialize($answer_arr);
}
}
}
return $str_answer;
}
/**
* 题目分数正确
*
* @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 {
// 题目扩展信息查询条件
$conditions_extend = [
'et_id' => intval($data['et_id']), // 题目id
'ep_id' => intval($data['ep_id']) // 试卷id
];
// 获取题目扩展信息
$answer_detail_extend = $this->_answer_detail_extend_model->get_by_conds($conditions_extend);
$et_detail = unserialize($answer_detail_extend['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没有被用来判断是否作答，而是使用is_status判断的，所以这里其实是无意义的
$is_pass = self::DO_PASS_STATE;
} 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 得分
*/
public 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
*/
public 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;
}
/**
* 保存答卷
* @param array $val 答案
* @param array $et_detail 题目详情
* @param int $marking_type 试卷类型(1:自动阅卷 2:手动阅卷)
*
* @return bool
*/
public function save_answer($val = [], $et_detail = [], $marking_type = self::AUTO_MARKING_TYPE)
{
// 获取答案字符串
$str_answer = $this->get_answer($val, $et_detail);
// 答案不为空，更新答卷信息
if ($str_answer) {
// 更新答案、答题状态
$de_cond['ead_id'] = $val['ead_id'];
$de_data = [
'my_answer' => $str_answer,
'is_status' => self::MY_PASS // 答题通过
];
$res = $this->_answer_detail_model->update_by_conds($de_cond, $de_data);
// 更新成功
if ($res) {
// 计算试题分数
$this->get_answer_score($val['ead_id'], $marking_type, $et_detail['et_type']);
}
return $res;
} 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->_answer_detail_model->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->_answer_detail_model->update_by_conds(['ead_id' => $ead_id], $arr);
return true;
}
/**
* 判断试卷状态
*
* @author: 蔡建华
* @param $ea_id int 答卷ID
* @param $uid string 用户ID
* @param $data_type int 数据类型(1:常规考试，2：任务类，3:线下培训)
* @param $obj_id int 任务、培训ID
*
* @return array|bool
*/
public function answer_status($ea_id = 0, $uid = '', $data_type = 1, $obj_id = 0)
{
// 初始化答卷状态
$start_type = self::START_TYPE_INITIAL;
// 用户答卷查询
$condition = ['ea_id' => $ea_id, 'uid' => $uid, 'obj_id' => $obj_id];
// 获取答卷信息
$ea_data = $this->get_by_conds($condition);
// 答卷信息不存在
if (empty($ea_data)) {
E('_ERR_MY_VISIT_NO');
}
// 查询试卷信息
$ep_id = $ea_data['ep_id'];
$paper = $this->paper_model->get($ep_id);
// 你已经交卷无法答题
if ($ea_data['answer_status'] >= self::READ_WAITING) {
// 已经交卷
$start_type = self::START_TYPE_END;
}
// 我的考试开始时间
$my_begin_time = $ea_data['my_begin_time'];
// 试卷时长
$paper_time = $paper['paper_time'] * 60 * 1000;
$time = MILLI_TIME;
// 结束时间
$end_time = $my_begin_time + $paper_time;
// 判断试卷状态，其中包括分类状态和试卷状态 (这里的试卷状态 0初始化，1草稿，2已发布，3终止)
if (self::EC_CLOSE_STATES == $paper['cate_status'] || self::PAPER_STOP == $paper['exam_status']) {
$start_type = self::START_TYPE_END;
}
// 如果考试时间到
if (($paper['exam_type'] == self::NOMAL_TYPE && $time > $paper['end_time']
|| $time > $end_time) || ($paper['exam_type'] != self::NOMAL_TYPE && $time > $end_time)) {
$start_type = self::START_TYPE_END;
// 答卷信息
$answer_info = $this->get($ea_id);
// 阅卷状态
if ($answer_info['answer_status'] == 0) {
// 查询条件：答卷id
$conds = ['ea_id' => $ea_id];
// 全部题目数量
$my_error_num = $this->_answer_detail_model->count_by_conds($conds);
// 此处查询是否存在最高分
$top_score = $this->get_by_conds(['ep_id' => $answer_info['ep_id'], 'is_score_top' => self::IS_SCORE_TOP_TRUE, 'uid' => $answer_info['uid'], 'answer_status' => self::READ_OVER]);
// 默认不是最高分
$is_score_top = self::IS_SCORE_TOP_FALSE;
if (empty($top_score)) {
// 设置为最高分
$is_score_top = self::IS_SCORE_TOP_TRUE;
}
// 交卷分数
$data = [
'answer_status' => self::READ_OVER,
'my_is_pass' => self::UNPASS,
'my_score' => 0,
'is_score_top' => $is_score_top,
'my_error_num' => $my_error_num,
'my_time' => $end_time - $my_begin_time,
'my_end_time' => $end_time,
'data_type' => $data_type, // 数据类型
'obj_id' => $obj_id // 任务、培训ID
];
// 交卷
$num = $this->update_by_conds($condition, $data);
// 交卷成功
if ($num) {
// 试卷使用类型(0:测评试卷，1：模拟试卷)
$paper_type = $paper['paper_type'];
// 是否更新参与人数（0=不更新，1=更新）
$is_update_join = 0;
// 测评试卷
if (self::EVALUATION_PAPER_TYPE == $paper_type) {
// 更新
$is_update_join = 1;
// 常规任务埋点：考试完成（测评试卷只要参加考试并交卷就算完成）
if (PaperService::TASK_TYPE == $paper['exam_type'] && $obj_id) {
$params = [
'uid' => $uid,
'customtask_id' => $obj_id,
'app_data_id' => $ep_id,
'action_key' => 'exam_pass',
'description' => '考试完成',
];
$taskCenter = &TaskCenter::instance();
$taskCenter->triggerCustomtask($params);
}
} elseif (self::SIMULATION_PAPER_TYPE == $paper_type) { // 模拟试卷
// 交卷次数
$condition = [
'ep_id' => $ep_id,
'uid' => $uid,
'answer_status' => self::READ_OVER, // 已批阅
'data_type' => self::NOMAL_TYPE, // 常规考试
];
$answer_count = $this->_d->count_by_conds($condition);
// 模拟试卷第一次交卷
if (1 == $answer_count) {
// 更新
$is_update_join = 1;
}
}
// 更新参与人数
if ($is_update_join) {
// 已参与人数加1，未参与人数减1
$update_data = [
'join_count' => $paper['join_count'] + 1,
'unjoin_count' => $paper['unjoin_count'] - 1
];
$this->paper_model->update($ep_id, $update_data);
}
// 培训id不为空, 类型为线下培训
if ($obj_id && PaperService::TRAIN_TYPE == $data_type) {
$Train = &Train::instance();
$Train->syncTrainStatus($obj_id, $ep_id);
}
}
}
}
// 考试结束时间大于时间结束时间
if ($end_time > $paper['end_time']) {
$left_time = $paper['end_time'] - $time;
// 考试结束时间小与时间结束时间
} else {
$left_time = $end_time - $time;
}
return [
'ep_name' => $paper['ep_name'],
'marking_type' => $paper['marking_type'],
'paper_type' => $paper['paper_type'],
'left_time' => $left_time, // 返回倒计时
'my_begin_time' => $my_begin_time,
'paper_time' => $paper['paper_time'],
'end_time' => $paper['end_time'],
'start_type' => intval($start_type)
];
}
/**
* 判断补考试卷状态
*
* @author: 蔡建华
* @param $ea_id int 答卷ID
* @param $uid string 用户ID
* @param $paper array 试卷数据
*
* @return array|bool
*/
public function answer_status_makeup($ea_id = 0, $uid = '', $paper = [])
{
// 初始化答卷状态
$start_type = self::START_TYPE_INITIAL;
// 用户答卷查询
$condition = ['ea_id' => $ea_id, 'uid' => $uid];
// 获取答卷信息
$ea_data = $this->get_by_conds($condition);
// 答卷信息不存在
if (empty($ea_data)) {
E('_ERR_MY_VISIT_NO');
}
// 你已经交卷无法答题
if ($ea_data['answer_status'] >= self::READ_WAITING) {
// 已经交卷
E('_ERR_SUBMIT_ANSWER');
}
// 我的考试开始时间
$my_begin_time = $ea_data['my_begin_time'];
// 试卷时长
$paper_time = $paper['paper_time'] * 60 * 1000;
$time = MILLI_TIME;
// 结束时间
$end_time = $my_begin_time + $paper_time;
if (self::EC_CLOSE_STATES == $paper['cate_status']) {
// 判断试卷状态，其中包括分类状态禁用
E('_ERR_DATA_EXAM_DEL');
}
// 如果考试时间到
if ($time > $paper['makeup_end_time'] || $time > $end_time) {
// 答卷信息
$answer_info = $this->get($ea_id);
// 阅卷状态
if ($answer_info['answer_status'] == 0) {
// 查询条件：答卷id
$conds = ['ea_id' => $ea_id];
// 全部题目数量
$my_error_num = $this->_answer_detail_model->count_by_conds($conds);
// 此处查询是否存在最高分
$top_score = $this->get_by_conds(['ep_id' => $answer_info['ep_id'], 'is_score_top' => self::IS_SCORE_TOP_TRUE, 'uid' => $answer_info['uid'], 'answer_status' => self::READ_OVER]);
// 默认不是最高分
$is_score_top = self::IS_SCORE_TOP_FALSE;
if (empty($top_score)) {
// 设置为最高分
$is_score_top = self::IS_SCORE_TOP_TRUE;
}
// 交卷分数
$data = [
'answer_status' => self::READ_OVER,
'my_is_pass' => self::UNPASS,
'my_score' => 0,
'is_score_top' => $is_score_top,
'my_error_num' => $my_error_num,
'my_time' => $end_time - $my_begin_time,
'my_end_time' => $end_time,
'data_type' => self::NOMAL_TYPE, // 数据类型
'obj_id' => 0 // 任务、培训ID
];
// 交卷
$this->update($ea_id, $data);
}
E('_ERR_AUTO_SUBMIT_TIME');
}
// 考试结束时间大于时间结束时间
if ($end_time > $paper['makeup_end_time']) {
$left_time = $paper['makeup_end_time'] - $time;
// 考试结束时间小与时间结束时间
} else {
$left_time = $end_time - $time;
}
return [
'ep_name' => $paper['ep_name'],
'marking_type' => $paper['marking_type'],
'paper_type' => $paper['paper_type'],
'left_time' => $left_time, // 返回倒计时
'my_begin_time' => $my_begin_time,
'paper_time' => $paper['paper_time'],
'end_time' => $paper['makeup_end_time'],
'start_type' => intval($start_type)
];
}
/**
* 删除答卷记录重新考试
*
* @param $ep_id int 试卷ID
* @param $conds array 条件
*
* @return bool
*/
public function delete_answer($ep_id, $conds)
{
$list = $this->_d->list_by_conds($conds);
if (empty($list)) {
E('_EMPTY_ANSWER_PAPER');
}
$user_uids = array_unique(array_column($list, 'uid'));
$paper = $this->paper_model->get($ep_id);
$ep_status = $this->paper_status($paper['exam_status'], $paper['begin_time'], $paper['end_time']);
if (self::STATUS_ING != $ep_status) {
E('_ERR_RESET_PAPER');
}
// 已参加人数减去要删除的
$join_count = $paper['join_count'] - count($user_uids);
// 未参加人数减去要删除的
$unjoin_count = $paper['unjoin_count'] + count($user_uids);
// 要删除的答卷
$ea_ids = array_column($list, 'ea_id');
// 查询要删除的试题
$detail_list = $this->_answer_detail_model->list_by_conds(['ea_id' => $ea_ids]);
if (empty($ea_ids)) {
E('_EMPTY_EA_ID');
}
$et_ids = array_column($detail_list, 'et_id');
try {
// 开始事务
$this->start_trans();
// 删除答卷信息
$rel = $this->_d->delete_by_conds(['ea_id' => $ea_ids]);
if (!$rel) {
$this->rollback();
E('_ERR_DELETE_ANSWER_FAILE');
}
// 更新试卷的参加人数
$rel = $this->paper_model->update_by_conds(
['ep_id' => $ep_id],
['join_count' => $join_count, 'unjoin_count' => $unjoin_count]
);
if (!$rel) {
$this->rollback();
E('_ERR_UPDATE_JOIN_PEOPLE');
}
// 数据减去使用次数
if ($et_ids) {
$rel = $this->_topic_model->MinusIncNum(['et_id' => $et_ids]);
if (!$rel) {
$this->rollback();
E('_ERR_UPDATE_TOPICS');
}
}
// 删除答卷详情
$rel = $this->_answer_detail_model->delete_by_conds(['ea_id' => $ea_ids]);
if (!$rel) {
$this->rollback();
E('_ERR_UPDATE_ANSWER_DETAIL');
}
$this->commit();
} catch (\Think\Exception $e) {
$this->rollback();
E('_ERR_DELETE_FAILE');
} catch (\Exception $e) {
$this->rollback();
E('_ERR_DELETE_FAILE');
}
// 发送消息
$params = [
'name' => $paper['ep_name'],
'begin_time' => $paper['begin_time'],
'end_time' => $paper['end_time'],
'uids' => $user_uids,
'id' => $paper['ep_id']
];
// 封面图片
if (self::IS_COVER_PIC_OPEN == $paper['is_cover_open']) {
$params['img_id'] = $paper['cover_id'];
} else {
$params['img_id'] = '';
}
$this->send_msg($params, self::RESET_USER_MSG);
return true;
}
/**
* 获取批阅列表
*
* @param array $conds 查询条件
* @param array $page_option 分页
* @param array $order_option 排序
*
* @return array|bool
*/
public function list_marking_paper($conds, $page_option = [], $order_option = [])
{
try {
return $this->_d->list_marking_paper($conds, $page_option, $order_option);
} catch (\Exception $e) {
E($e->getCode() . ':' . $e->getMessage());
return false;
}
}
/**
* 统计批阅列表总数
*
* @param array $conds 查询条件
*
* @return array|bool
*/
public function count_marking_paper($conds)
{
try {
return $this->_d->count_marking_paper($conds);
} catch (\Exception $e) {
E($e->getCode() . ':' . $e->getMessage());
return false;
}
}
/**
* 根据条件查询测评考试的参与人总数
* @param array $conds
* @return mixed
*/
public function count_by_where($conds = [])
{
return $this->_d->count_mock_answer($conds);
}
/**
* 根据条件分页查询测评考试的参与记录
* @param array $conds
* @param null $page_option
* @param array $order_by
* @param string $fields
* @return array|bool
*/
public function list_by_where($conds = [], $page_option = null, $order_by = [], $fields = '*')
{
return $this->_d->get_mock_answer_list($conds, $page_option, $order_by, $fields);
}
}