1

source/java/src/main/java/com/mindskip/xzs/service/FileUpload.java

+package com.mindskip.xzs.service;
+
+
+import java.io.InputStream;
+import java.util.Set;
+
+public interface FileUpload {
+
+    String uploadFile(InputStream inputStream, long size, String extName);
+
+}

source/java/src/main/java/com/mindskip/xzs/service/MessageService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.Message;
+import com.mindskip.xzs.domain.MessageUser;
+import com.mindskip.xzs.viewmodel.message.MessagePageRequestVM;
+import com.mindskip.xzs.viewmodel.student.user.MessageRequestVM;
+import com.github.pagehelper.PageInfo;
+
+import java.util.List;
+
+public interface MessageService {
+
+    List<Message> selectMessageByIds(List<Integer> ids);
+
+    PageInfo<MessageUser> studentPage(MessageRequestVM requestVM);
+
+    PageInfo<Message> page(MessagePageRequestVM requestVM);
+
+    List<MessageUser> selectByMessageIds(List<Integer> ids);
+
+    void sendMessage(Message message, List<MessageUser> messageUsers);
+
+    void read(Integer id);
+
+    Integer unReadCount(Integer userId);
+
+    Message messageDetail(Integer id);
+}

source/java/src/main/java/com/mindskip/xzs/service/QuestionService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.Question;
+import com.mindskip.xzs.viewmodel.question.QuestionEditRequestVM;
+import com.mindskip.xzs.viewmodel.question.QuestionPageRequestVM;
+import com.github.pagehelper.PageInfo;
+
+import java.util.List;
+
+public interface QuestionService extends BaseService<Question> {
+
+    PageInfo<Question> page(QuestionPageRequestVM requestVM);
+
+    Question insertFullQuestion(QuestionEditRequestVM model, Integer userId);
+
+    Question updateFullQuestion(QuestionEditRequestVM model);
+
+    QuestionEditRequestVM getQuestionEditRequestVM(Integer questionId);
+
+    QuestionEditRequestVM getQuestionEditRequestVM(Question question);
+
+    Integer selectAllCount();
+
+    List<Integer> selectMothCount();
+}

source/java/src/main/java/com/mindskip/xzs/service/SubjectService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.Subject;
+import com.mindskip.xzs.viewmodel.education.SubjectPageRequestVM;
+import com.github.pagehelper.PageInfo;
+
+import java.util.List;
+
+public interface SubjectService extends BaseService<Subject> {
+
+    List<Subject> getSubjectByLevel(Integer level);
+
+    List<Subject> allSubject();
+
+    Integer levelBySubjectId(Integer id);
+
+    PageInfo<Subject> page(SubjectPageRequestVM requestVM);
+}

source/java/src/main/java/com/mindskip/xzs/service/TaskExamCustomerAnswerService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.ExamPaper;
+import com.mindskip.xzs.domain.ExamPaperAnswer;
+import com.mindskip.xzs.domain.TaskExamCustomerAnswer;
+
+import java.util.Date;
+import java.util.List;
+
+public interface TaskExamCustomerAnswerService extends BaseService<TaskExamCustomerAnswer> {
+
+    void insertOrUpdate(ExamPaper examPaper, ExamPaperAnswer examPaperAnswer, Date now);
+
+    TaskExamCustomerAnswer selectByTUid(Integer tid, Integer uid);
+
+    List<TaskExamCustomerAnswer> selectByTUid(List<Integer> taskIds, Integer uid);
+}

source/java/src/main/java/com/mindskip/xzs/service/TaskExamService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.TaskExam;
+import com.mindskip.xzs.domain.User;
+import com.mindskip.xzs.viewmodel.task.TaskPageRequestVM;
+import com.mindskip.xzs.viewmodel.task.TaskRequestVM;
+import com.github.pagehelper.PageInfo;
+
+import java.util.List;
+
+public interface TaskExamService extends BaseService<TaskExam> {
+
+    PageInfo<TaskExam> page(TaskPageRequestVM requestVM);
+
+    void edit(TaskRequestVM model, User user);
+
+    TaskRequestVM taskExamToVM(Integer id);
+
+    List<TaskExam> getByGradeLevel(Integer gradeLevel);
+}

source/java/src/main/java/com/mindskip/xzs/service/TextContentService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.TextContent;
+
+import java.util.Date;
+import java.util.List;
+import java.util.function.Function;
+
+public interface TextContentService extends BaseService<TextContent> {
+
+    /**
+     * 创建一个TextContent，将内容转化为json，回写到content中，不入库
+     *
+     * @param list
+     * @param now
+     * @param mapper
+     * @param <T>
+     * @param <R>
+     * @return
+     */
+    <T, R> TextContent jsonConvertInsert(List<T> list, Date now, Function<? super T, ? extends R> mapper);
+
+    /**
+     * 修改一个TextContent，将内容转化为json，回写到content中，不入库
+     *
+     * @param textContent
+     * @param list
+     * @param mapper
+     * @param <T>
+     * @param <R>
+     * @return
+     */
+    <T, R> TextContent jsonConvertUpdate(TextContent textContent, List<T> list, Function<? super T, ? extends R> mapper);
+
+}

source/java/src/main/java/com/mindskip/xzs/service/UserEventLogService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.UserEventLog;
+import com.mindskip.xzs.viewmodel.user.UserEventPageRequestVM;
+import com.github.pagehelper.PageInfo;
+
+import java.util.List;
+
+public interface UserEventLogService extends BaseService<UserEventLog> {
+
+    List<UserEventLog> getUserEventLogByUserId(Integer id);
+
+    PageInfo<UserEventLog> page(UserEventPageRequestVM requestVM);
+
+    List<Integer> selectMothCount();
+}

source/java/src/main/java/com/mindskip/xzs/service/UserService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.other.KeyValue;
+import com.mindskip.xzs.domain.User;
+import com.mindskip.xzs.viewmodel.user.UserPageRequestVM;
+import com.github.pagehelper.PageInfo;
+
+import java.util.List;
+
+
+public interface UserService extends BaseService<User> {
+
+    /**
+     * getUsers
+     *
+     * @return List<User>
+     */
+    List<User> getUsers();
+
+    /**
+     * getUserById
+     *
+     * @param id id
+     * @return User
+     */
+    User getUserById(Integer id);
+
+    /**
+     * getUserByUserName
+     *
+     * @param username username
+     * @return User
+     */
+    User getUserByUserName(String username);
+
+    /**
+     * getUserByUserName
+     *
+     * @param username username
+     * @param pwd      pwd
+     * @return User
+     */
+    User getUserByUserNamePwd(String username, String pwd);
+
+    /**
+     * getUserByUuid
+     *
+     * @param uuid uuid
+     * @return User
+     */
+    User getUserByUuid(String uuid);
+
+    /**
+     * userPageList
+     *
+     * @param name      name
+     * @param pageIndex pageIndex
+     * @param pageSize  pageSize
+     * @return List<User>
+     */
+    List<User> userPageList(String name, Integer pageIndex, Integer pageSize);
+
+
+    /**
+     * userPageCount
+     *
+     * @param name name
+     * @return Integer
+     */
+    Integer userPageCount(String name);
+
+
+    /**
+     * @param requestVM requestVM
+     * @return PageInfo<User>
+     */
+    PageInfo<User> userPage(UserPageRequestVM requestVM);
+
+
+    /**
+     * insertUser
+     *
+     * @param user user
+     */
+    void insertUser(User user);
+
+    /**
+     * insertUsers
+     *
+     * @param users users
+     */
+    void insertUsers(List<User> users);
+
+    /**
+     * updateUser
+     *
+     * @param user user
+     */
+    void updateUser(User user);
+
+    /**
+     * updateUsersAge
+     *
+     * @param age
+     * @param ids
+     */
+    void updateUsersAge(Integer age, List<Integer> ids);
+
+    /**
+     * deleteUserByIds
+     *
+     * @param ids
+     */
+    void deleteUserByIds(List<Integer> ids);
+
+
+    Integer selectAllCount();
+
+
+    List<KeyValue> selectByUserName(String userName);
+
+
+    List<User> selectByIds(List<Integer> ids);
+
+    User selectByWxOpenId(String wxOpenId);
+
+    void changePicture(User user, String imagePath);
+}

source/java/src/main/java/com/mindskip/xzs/service/UserTokenService.java

+package com.mindskip.xzs.service;
+
+import com.mindskip.xzs.domain.User;
+import com.mindskip.xzs.domain.UserToken;
+
+public interface UserTokenService extends BaseService<UserToken> {
+
+    /**
+     * 微信token绑定
+     *
+     * @param user user
+     * @return UserToken
+     */
+    UserToken bind(User user);
+
+    /**
+     * 检查微信openId是否绑定过
+     *
+     * @param openId openId
+     * @return UserToken
+     */
+    UserToken checkBind(String openId);
+
+    /**
+     * 根据token获取UserToken，带缓存的
+     *
+     * @param token token
+     * @return UserToken
+     */
+    UserToken getToken(String token);
+
+    /**
+     * 插入用户Token
+     *
+     * @param user user
+     * @return UserToken
+     */
+    UserToken insertUserToken(User user);
+
+    /**
+     * 微信小程序退出，清除缓存
+     *
+     * @param userToken userToken
+     */
+    void unBind(UserToken userToken);
+}

source/java/src/main/java/com/mindskip/xzs/service/enums/ActionEnum.java

+package com.mindskip.xzs.service.enums;
+
+public enum ActionEnum {
+
+    ADD(1, "新增"),
+    UPDATE(2, "修改");
+
+    int code;
+    String Name;
+
+    ActionEnum(int code, String name) {
+        this.code = code;
+        Name = name;
+    }
+
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getName() {
+        return Name;
+    }
+
+    public void setName(String name) {
+        Name = name;
+    }
+
+
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/AuthenticationServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.configuration.property.SystemConfig;
+import com.mindskip.xzs.domain.User;
+import com.mindskip.xzs.service.AuthenticationService;
+import com.mindskip.xzs.service.UserService;
+import com.mindskip.xzs.utility.RsaUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+
+@Service
+public class AuthenticationServiceImpl implements AuthenticationService {
+
+
+    private final UserService userService;
+    private final SystemConfig systemConfig;
+
+    @Autowired
+    public AuthenticationServiceImpl(UserService userService, SystemConfig systemConfig) {
+        this.userService = userService;
+        this.systemConfig = systemConfig;
+    }
+
+
+    /**
+     * @param username username
+     * @param password password
+     * @return boolean
+     */
+    @Override
+    public boolean authUser(String username, String password) {
+        User user = userService.getUserByUserName(username);
+        return authUser(user, username, password);
+    }
+
+
+    @Override
+    public boolean authUser(User user, String username, String password) {
+        if (user == null) {
+            return false;
+        }
+        String encodePwd = user.getPassword();
+        if (null == encodePwd || encodePwd.length() == 0) {
+            return false;
+        }
+        String pwd = pwdDecode(encodePwd);
+        return pwd.equals(password);
+    }
+
+    @Override
+    public String pwdEncode(String password) {
+        return RsaUtil.rsaEncode(systemConfig.getPwdKey().getPublicKey(), password);
+    }
+
+    @Override
+    public String pwdDecode(String encodePwd) {
+        return RsaUtil.rsaDecode(systemConfig.getPwdKey().getPrivateKey(), encodePwd);
+    }
+
+
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/BaseServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.repository.BaseMapper;
+import com.mindskip.xzs.service.BaseService;
+
+public abstract class BaseServiceImpl<T> implements BaseService<T> {
+
+    private final BaseMapper<T> baseMapper;
+
+    public BaseServiceImpl(BaseMapper<T> baseMapper) {
+        this.baseMapper = baseMapper;
+    }
+
+    @Override
+    public int deleteById(Integer id) {
+        return baseMapper.deleteByPrimaryKey(id);
+    }
+
+    @Override
+    public int insert(T record) {
+        return baseMapper.insert(record);
+    }
+
+    @Override
+    public int insertByFilter(T record) {
+        return baseMapper.insertSelective(record);
+    }
+
+    @Override
+    public T selectById(Integer id) {
+        return baseMapper.selectByPrimaryKey(id);
+    }
+
+    @Override
+    public int updateByIdFilter(T record) {
+        return baseMapper.updateByPrimaryKeySelective(record);
+    }
+
+    @Override
+    public int updateById(T record) {
+        return baseMapper.updateByPrimaryKey(record);
+    }
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/ExamPaperAnswerServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.domain.*;
+import com.mindskip.xzs.domain.enums.ExamPaperAnswerStatusEnum;
+import com.mindskip.xzs.domain.enums.ExamPaperTypeEnum;
+import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
+import com.mindskip.xzs.domain.exam.ExamPaperTitleItemObject;
+import com.mindskip.xzs.domain.other.KeyValue;
+import com.mindskip.xzs.domain.other.ExamPaperAnswerUpdate;
+import com.mindskip.xzs.domain.task.TaskItemAnswerObject;
+import com.mindskip.xzs.repository.ExamPaperAnswerMapper;
+import com.mindskip.xzs.repository.ExamPaperMapper;
+import com.mindskip.xzs.repository.QuestionMapper;
+import com.mindskip.xzs.repository.TaskExamCustomerAnswerMapper;
+import com.mindskip.xzs.service.ExamPaperAnswerService;
+import com.mindskip.xzs.service.ExamPaperQuestionCustomerAnswerService;
+import com.mindskip.xzs.service.TextContentService;
+import com.mindskip.xzs.utility.DateTimeUtil;
+import com.mindskip.xzs.utility.ExamUtil;
+import com.mindskip.xzs.utility.JsonUtil;
+import com.mindskip.xzs.viewmodel.student.exam.ExamPaperSubmitItemVM;
+import com.mindskip.xzs.viewmodel.student.exam.ExamPaperSubmitVM;
+import com.mindskip.xzs.viewmodel.student.exampaper.ExamPaperAnswerPageVM;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class ExamPaperAnswerServiceImpl extends BaseServiceImpl<ExamPaperAnswer> implements ExamPaperAnswerService {
+
+    private final ExamPaperAnswerMapper examPaperAnswerMapper;
+    private final ExamPaperMapper examPaperMapper;
+    private final TextContentService textContentService;
+    private final QuestionMapper questionMapper;
+    private final ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService;
+    private final TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper;
+
+    @Autowired
+    public ExamPaperAnswerServiceImpl(ExamPaperAnswerMapper examPaperAnswerMapper, ExamPaperMapper examPaperMapper, TextContentService textContentService, QuestionMapper questionMapper, ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService, TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper) {
+        super(examPaperAnswerMapper);
+        this.examPaperAnswerMapper = examPaperAnswerMapper;
+        this.examPaperMapper = examPaperMapper;
+        this.textContentService = textContentService;
+        this.questionMapper = questionMapper;
+        this.examPaperQuestionCustomerAnswerService = examPaperQuestionCustomerAnswerService;
+        this.taskExamCustomerAnswerMapper = taskExamCustomerAnswerMapper;
+    }
+
+    @Override
+    public PageInfo<ExamPaperAnswer> studentPage(ExamPaperAnswerPageVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                examPaperAnswerMapper.studentPage(requestVM));
+    }
+
+
+    @Override
+    public ExamPaperAnswerInfo calculateExamPaperAnswer(ExamPaperSubmitVM examPaperSubmitVM, User user) {
+        ExamPaperAnswerInfo examPaperAnswerInfo = new ExamPaperAnswerInfo();
+        Date now = new Date();
+        ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(examPaperSubmitVM.getId());
+        ExamPaperTypeEnum paperTypeEnum = ExamPaperTypeEnum.fromCode(examPaper.getPaperType());
+        //任务试卷只能做一次
+        if (paperTypeEnum == ExamPaperTypeEnum.Task) {
+            ExamPaperAnswer examPaperAnswer = examPaperAnswerMapper.getByPidUid(examPaperSubmitVM.getId(), user.getId());
+            if (null != examPaperAnswer)
+                return null;
+        }
+        String frameTextContent = textContentService.selectById(examPaper.getFrameTextContentId()).getContent();
+        List<ExamPaperTitleItemObject> examPaperTitleItemObjects = JsonUtil.toJsonListObject(frameTextContent, ExamPaperTitleItemObject.class);
+        List<Integer> questionIds = examPaperTitleItemObjects.stream().flatMap(t -> t.getQuestionItems().stream().map(q -> q.getId())).collect(Collectors.toList());
+        List<Question> questions = questionMapper.selectByIds(questionIds);
+        //将题目结构的转化为题目答案
+        List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers = examPaperTitleItemObjects.stream()
+                .flatMap(t -> t.getQuestionItems().stream()
+                        .map(q -> {
+                            Question question = questions.stream().filter(tq -> tq.getId().equals(q.getId())).findFirst().get();
+                            ExamPaperSubmitItemVM customerQuestionAnswer = examPaperSubmitVM.getAnswerItems().stream()
+                                    .filter(tq -> tq.getQuestionId().equals(q.getId()))
+                                    .findFirst()
+                                    .orElse(null);
+                            return ExamPaperQuestionCustomerAnswerFromVM(question, customerQuestionAnswer, examPaper, q.getItemOrder(), user, now);
+                        })
+                ).collect(Collectors.toList());
+
+        ExamPaperAnswer examPaperAnswer = ExamPaperAnswerFromVM(examPaperSubmitVM, examPaper, examPaperQuestionCustomerAnswers, user, now);
+        examPaperAnswerInfo.setExamPaper(examPaper);
+        examPaperAnswerInfo.setExamPaperAnswer(examPaperAnswer);
+        examPaperAnswerInfo.setExamPaperQuestionCustomerAnswers(examPaperQuestionCustomerAnswers);
+        return examPaperAnswerInfo;
+    }
+
+    @Override
+    @Transactional
+    public String judge(ExamPaperSubmitVM examPaperSubmitVM) {
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerMapper.selectByPrimaryKey(examPaperSubmitVM.getId());
+        List<ExamPaperSubmitItemVM> judgeItems = examPaperSubmitVM.getAnswerItems().stream().filter(d -> d.getDoRight() == null).collect(Collectors.toList());
+        List<ExamPaperAnswerUpdate> examPaperAnswerUpdates = new ArrayList<>(judgeItems.size());
+        Integer customerScore = examPaperAnswer.getUserScore();
+        Integer questionCorrect = examPaperAnswer.getQuestionCorrect();
+        for (ExamPaperSubmitItemVM d : judgeItems) {
+            ExamPaperAnswerUpdate examPaperAnswerUpdate = new ExamPaperAnswerUpdate();
+            examPaperAnswerUpdate.setId(d.getId());
+            examPaperAnswerUpdate.setCustomerScore(ExamUtil.scoreFromVM(d.getScore()));
+            boolean doRight = examPaperAnswerUpdate.getCustomerScore().equals(ExamUtil.scoreFromVM(d.getQuestionScore()));
+            examPaperAnswerUpdate.setDoRight(doRight);
+            examPaperAnswerUpdates.add(examPaperAnswerUpdate);
+            customerScore += examPaperAnswerUpdate.getCustomerScore();
+            if (examPaperAnswerUpdate.getDoRight()) {
+                ++questionCorrect;
+            }
+        }
+        examPaperAnswer.setUserScore(customerScore);
+        examPaperAnswer.setQuestionCorrect(questionCorrect);
+        examPaperAnswer.setStatus(ExamPaperAnswerStatusEnum.Complete.getCode());
+        examPaperAnswerMapper.updateByPrimaryKeySelective(examPaperAnswer);
+        examPaperQuestionCustomerAnswerService.updateScore(examPaperAnswerUpdates);
+
+        ExamPaperTypeEnum examPaperTypeEnum = ExamPaperTypeEnum.fromCode(examPaperAnswer.getPaperType());
+        switch (examPaperTypeEnum) {
+            case Task:
+                //任务试卷批改完成后，需要更新任务的状态
+                ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(examPaperAnswer.getExamPaperId());
+                Integer taskId = examPaper.getTaskExamId();
+                Integer userId = examPaperAnswer.getCreateUser();
+                TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswerMapper.getByTUid(taskId, userId);
+                TextContent textContent = textContentService.selectById(taskExamCustomerAnswer.getTextContentId());
+                List<TaskItemAnswerObject> taskItemAnswerObjects = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemAnswerObject.class);
+                taskItemAnswerObjects.stream()
+                        .filter(d -> d.getExamPaperAnswerId().equals(examPaperAnswer.getId()))
+                        .findFirst().ifPresent(taskItemAnswerObject -> taskItemAnswerObject.setStatus(examPaperAnswer.getStatus()));
+                textContentService.jsonConvertUpdate(textContent, taskItemAnswerObjects, null);
+                textContentService.updateByIdFilter(textContent);
+                break;
+            default:
+                break;
+        }
+        return ExamUtil.scoreToVM(customerScore);
+    }
+
+    @Override
+    public ExamPaperSubmitVM examPaperAnswerToVM(Integer id) {
+        ExamPaperSubmitVM examPaperSubmitVM = new ExamPaperSubmitVM();
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerMapper.selectByPrimaryKey(id);
+        examPaperSubmitVM.setId(examPaperAnswer.getId());
+        examPaperSubmitVM.setDoTime(examPaperAnswer.getDoTime());
+        examPaperSubmitVM.setScore(ExamUtil.scoreToVM(examPaperAnswer.getUserScore()));
+        List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers = examPaperQuestionCustomerAnswerService.selectListByPaperAnswerId(examPaperAnswer.getId());
+        List<ExamPaperSubmitItemVM> examPaperSubmitItemVMS = examPaperQuestionCustomerAnswers.stream()
+                .map(a -> examPaperQuestionCustomerAnswerService.examPaperQuestionCustomerAnswerToVM(a))
+                .collect(Collectors.toList());
+        examPaperSubmitVM.setAnswerItems(examPaperSubmitItemVMS);
+        return examPaperSubmitVM;
+    }
+
+    @Override
+    public Integer selectAllCount() {
+        return examPaperAnswerMapper.selectAllCount();
+    }
+
+    @Override
+    public List<Integer> selectMothCount() {
+        Date startTime = DateTimeUtil.getMonthStartDay();
+        Date endTime = DateTimeUtil.getMonthEndDay();
+        List<KeyValue> mouthCount = examPaperAnswerMapper.selectCountByDate(startTime, endTime);
+        List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
+        return mothStartToNowFormat.stream().map(md -> {
+            KeyValue keyValue = mouthCount.stream().filter(kv -> kv.getName().equals(md)).findAny().orElse(null);
+            return null == keyValue ? 0 : keyValue.getValue();
+        }).collect(Collectors.toList());
+    }
+
+
+    /**
+     * 用户提交答案的转化存储对象
+     *
+     * @param question               question
+     * @param customerQuestionAnswer customerQuestionAnswer
+     * @param examPaper              examPaper
+     * @param itemOrder              itemOrder
+     * @param user                   user
+     * @param now                    now
+     * @return ExamPaperQuestionCustomerAnswer
+     */
+    private ExamPaperQuestionCustomerAnswer ExamPaperQuestionCustomerAnswerFromVM(Question question, ExamPaperSubmitItemVM customerQuestionAnswer, ExamPaper examPaper, Integer itemOrder, User user, Date now) {
+        ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer = new ExamPaperQuestionCustomerAnswer();
+        examPaperQuestionCustomerAnswer.setQuestionId(question.getId());
+        examPaperQuestionCustomerAnswer.setExamPaperId(examPaper.getId());
+        examPaperQuestionCustomerAnswer.setQuestionScore(question.getScore());
+        examPaperQuestionCustomerAnswer.setSubjectId(examPaper.getSubjectId());
+        examPaperQuestionCustomerAnswer.setItemOrder(itemOrder);
+        examPaperQuestionCustomerAnswer.setCreateTime(now);
+        examPaperQuestionCustomerAnswer.setCreateUser(user.getId());
+        examPaperQuestionCustomerAnswer.setQuestionType(question.getQuestionType());
+        examPaperQuestionCustomerAnswer.setQuestionTextContentId(question.getInfoTextContentId());
+        if (null == customerQuestionAnswer) {
+            examPaperQuestionCustomerAnswer.setCustomerScore(0);
+        } else {
+            setSpecialFromVM(examPaperQuestionCustomerAnswer, question, customerQuestionAnswer);
+        }
+        return examPaperQuestionCustomerAnswer;
+    }
+
+    /**
+     * 判断提交答案是否正确，保留用户提交的答案
+     *
+     * @param examPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer
+     * @param question                        question
+     * @param customerQuestionAnswer          customerQuestionAnswer
+     */
+    private void setSpecialFromVM(ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer, Question question, ExamPaperSubmitItemVM customerQuestionAnswer) {
+        QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(examPaperQuestionCustomerAnswer.getQuestionType());
+        switch (questionTypeEnum) {
+            case SingleChoice:
+            case TrueFalse:
+                examPaperQuestionCustomerAnswer.setAnswer(customerQuestionAnswer.getContent());
+                examPaperQuestionCustomerAnswer.setDoRight(question.getCorrect().equals(customerQuestionAnswer.getContent()));
+                examPaperQuestionCustomerAnswer.setCustomerScore(examPaperQuestionCustomerAnswer.getDoRight() ? question.getScore() : 0);
+                break;
+            case MultipleChoice:
+                String customerAnswer = ExamUtil.contentToString(customerQuestionAnswer.getContentArray());
+                examPaperQuestionCustomerAnswer.setAnswer(customerAnswer);
+                examPaperQuestionCustomerAnswer.setDoRight(customerAnswer.equals(question.getCorrect()));
+                examPaperQuestionCustomerAnswer.setCustomerScore(examPaperQuestionCustomerAnswer.getDoRight() ? question.getScore() : 0);
+                break;
+            case GapFilling:
+                String correctAnswer = JsonUtil.toJsonStr(customerQuestionAnswer.getContentArray());
+                examPaperQuestionCustomerAnswer.setAnswer(correctAnswer);
+                examPaperQuestionCustomerAnswer.setCustomerScore(0);
+                break;
+            default:
+                examPaperQuestionCustomerAnswer.setAnswer(customerQuestionAnswer.getContent());
+                examPaperQuestionCustomerAnswer.setCustomerScore(0);
+                break;
+        }
+    }
+
+    private ExamPaperAnswer ExamPaperAnswerFromVM(ExamPaperSubmitVM examPaperSubmitVM, ExamPaper examPaper, List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers, User user, Date now) {
+        Integer systemScore = examPaperQuestionCustomerAnswers.stream().mapToInt(a -> a.getCustomerScore()).sum();
+        long questionCorrect = examPaperQuestionCustomerAnswers.stream().filter(a -> a.getCustomerScore().equals(a.getQuestionScore())).count();
+        ExamPaperAnswer examPaperAnswer = new ExamPaperAnswer();
+        examPaperAnswer.setPaperName(examPaper.getName());
+        examPaperAnswer.setDoTime(examPaperSubmitVM.getDoTime());
+        examPaperAnswer.setExamPaperId(examPaper.getId());
+        examPaperAnswer.setCreateUser(user.getId());
+        examPaperAnswer.setCreateTime(now);
+        examPaperAnswer.setSubjectId(examPaper.getSubjectId());
+        examPaperAnswer.setQuestionCount(examPaper.getQuestionCount());
+        examPaperAnswer.setPaperScore(examPaper.getScore());
+        examPaperAnswer.setPaperType(examPaper.getPaperType());
+        examPaperAnswer.setSystemScore(systemScore);
+        examPaperAnswer.setUserScore(systemScore);
+        examPaperAnswer.setTaskExamId(examPaper.getTaskExamId());
+        examPaperAnswer.setQuestionCorrect((int) questionCorrect);
+        boolean needJudge = examPaperQuestionCustomerAnswers.stream().anyMatch(d -> QuestionTypeEnum.needSaveTextContent(d.getQuestionType()));
+        if (needJudge) {
+            examPaperAnswer.setStatus(ExamPaperAnswerStatusEnum.WaitJudge.getCode());
+        } else {
+            examPaperAnswer.setStatus(ExamPaperAnswerStatusEnum.Complete.getCode());
+        }
+        return examPaperAnswer;
+    }
+
+
+    @Override
+    public PageInfo<ExamPaperAnswer> adminPage(com.mindskip.xzs.viewmodel.paper.ExamPaperAnswerPageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                examPaperAnswerMapper.adminPage(requestVM));
+    }
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/ExamPaperQuestionCustomerAnswerServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.domain.ExamPaperQuestionCustomerAnswer;
+import com.mindskip.xzs.domain.other.ExamPaperAnswerUpdate;
+import com.mindskip.xzs.domain.other.KeyValue;
+import com.mindskip.xzs.domain.TextContent;
+import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
+import com.mindskip.xzs.repository.ExamPaperQuestionCustomerAnswerMapper;
+import com.mindskip.xzs.service.ExamPaperQuestionCustomerAnswerService;
+import com.mindskip.xzs.service.TextContentService;
+import com.mindskip.xzs.utility.DateTimeUtil;
+import com.mindskip.xzs.utility.ExamUtil;
+import com.mindskip.xzs.utility.JsonUtil;
+import com.mindskip.xzs.viewmodel.student.exam.ExamPaperSubmitItemVM;
+import com.mindskip.xzs.viewmodel.student.question.answer.QuestionPageStudentRequestVM;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class ExamPaperQuestionCustomerAnswerServiceImpl extends BaseServiceImpl<ExamPaperQuestionCustomerAnswer> implements ExamPaperQuestionCustomerAnswerService {
+
+    private final ExamPaperQuestionCustomerAnswerMapper examPaperQuestionCustomerAnswerMapper;
+    private final TextContentService textContentService;
+
+    @Autowired
+    public ExamPaperQuestionCustomerAnswerServiceImpl(ExamPaperQuestionCustomerAnswerMapper examPaperQuestionCustomerAnswerMapper, TextContentService textContentService) {
+        super(examPaperQuestionCustomerAnswerMapper);
+        this.examPaperQuestionCustomerAnswerMapper = examPaperQuestionCustomerAnswerMapper;
+        this.textContentService = textContentService;
+    }
+
+
+    @Override
+    public PageInfo<ExamPaperQuestionCustomerAnswer> studentPage(QuestionPageStudentRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                examPaperQuestionCustomerAnswerMapper.studentPage(requestVM)
+        );
+    }
+
+    @Override
+    public List<ExamPaperQuestionCustomerAnswer> selectListByPaperAnswerId(Integer id) {
+        return examPaperQuestionCustomerAnswerMapper.selectListByPaperAnswerId(id);
+    }
+
+
+    @Override
+    public void insertList(List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers) {
+        examPaperQuestionCustomerAnswerMapper.insertList(examPaperQuestionCustomerAnswers);
+    }
+
+    @Override
+    public ExamPaperSubmitItemVM examPaperQuestionCustomerAnswerToVM(ExamPaperQuestionCustomerAnswer qa) {
+        ExamPaperSubmitItemVM examPaperSubmitItemVM = new ExamPaperSubmitItemVM();
+        examPaperSubmitItemVM.setId(qa.getId());
+        examPaperSubmitItemVM.setQuestionId(qa.getQuestionId());
+        examPaperSubmitItemVM.setDoRight(qa.getDoRight());
+        examPaperSubmitItemVM.setItemOrder(qa.getItemOrder());
+        examPaperSubmitItemVM.setQuestionScore(ExamUtil.scoreToVM(qa.getQuestionScore()));
+        examPaperSubmitItemVM.setScore(ExamUtil.scoreToVM(qa.getCustomerScore()));
+        setSpecialToVM(examPaperSubmitItemVM, qa);
+        return examPaperSubmitItemVM;
+    }
+
+    @Override
+    public Integer selectAllCount() {
+        return examPaperQuestionCustomerAnswerMapper.selectAllCount();
+    }
+
+    @Override
+    public List<Integer> selectMothCount() {
+        Date startTime = DateTimeUtil.getMonthStartDay();
+        Date endTime = DateTimeUtil.getMonthEndDay();
+        List<KeyValue> mouthCount = examPaperQuestionCustomerAnswerMapper.selectCountByDate(startTime, endTime);
+        List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
+        return mothStartToNowFormat.stream().map(md -> {
+            KeyValue keyValue = mouthCount.stream().filter(kv -> kv.getName().equals(md)).findAny().orElse(null);
+            return null == keyValue ? 0 : keyValue.getValue();
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    public int updateScore(List<ExamPaperAnswerUpdate> examPaperAnswerUpdates) {
+        return examPaperQuestionCustomerAnswerMapper.updateScore(examPaperAnswerUpdates);
+    }
+
+    private void setSpecialToVM(ExamPaperSubmitItemVM examPaperSubmitItemVM, ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer) {
+        QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(examPaperQuestionCustomerAnswer.getQuestionType());
+        switch (questionTypeEnum) {
+            case MultipleChoice:
+                examPaperSubmitItemVM.setContent(examPaperQuestionCustomerAnswer.getAnswer());
+                examPaperSubmitItemVM.setContentArray(ExamUtil.contentToArray(examPaperQuestionCustomerAnswer.getAnswer()));
+                break;
+            case GapFilling:
+                TextContent textContent = textContentService.selectById(examPaperQuestionCustomerAnswer.getTextContentId());
+                List<String> correctAnswer = JsonUtil.toJsonListObject(textContent.getContent(), String.class);
+                examPaperSubmitItemVM.setContentArray(correctAnswer);
+                break;
+            default:
+                if (QuestionTypeEnum.needSaveTextContent(examPaperQuestionCustomerAnswer.getQuestionType())) {
+                    TextContent content = textContentService.selectById(examPaperQuestionCustomerAnswer.getTextContentId());
+                    examPaperSubmitItemVM.setContent(content.getContent());
+                } else {
+                    examPaperSubmitItemVM.setContent(examPaperQuestionCustomerAnswer.getAnswer());
+                }
+                break;
+        }
+    }
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/ExamPaperServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.domain.TextContent;
+import com.mindskip.xzs.domain.enums.ExamPaperTypeEnum;
+import com.mindskip.xzs.domain.exam.ExamPaperQuestionItemObject;
+import com.mindskip.xzs.domain.exam.ExamPaperTitleItemObject;
+import com.mindskip.xzs.domain.other.KeyValue;
+import com.mindskip.xzs.repository.ExamPaperMapper;
+import com.mindskip.xzs.repository.QuestionMapper;
+import com.mindskip.xzs.service.ExamPaperService;
+import com.mindskip.xzs.service.QuestionService;
+import com.mindskip.xzs.service.SubjectService;
+import com.mindskip.xzs.service.TextContentService;
+import com.mindskip.xzs.service.enums.ActionEnum;
+import com.mindskip.xzs.utility.DateTimeUtil;
+import com.mindskip.xzs.utility.JsonUtil;
+import com.mindskip.xzs.utility.ModelMapperSingle;
+import com.mindskip.xzs.utility.ExamUtil;
+import com.mindskip.xzs.viewmodel.exam.ExamPaperEditRequestVM;
+import com.mindskip.xzs.viewmodel.exam.ExamPaperPageRequestVM;
+import com.mindskip.xzs.viewmodel.exam.ExamPaperTitleItemVM;
+import com.mindskip.xzs.viewmodel.question.QuestionEditRequestVM;
+import com.mindskip.xzs.viewmodel.student.dashboard.PaperFilter;
+import com.mindskip.xzs.viewmodel.student.dashboard.PaperInfo;
+import com.mindskip.xzs.viewmodel.student.exam.ExamPaperPageVM;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.mindskip.xzs.domain.ExamPaper;
+import com.mindskip.xzs.domain.Question;
+import com.mindskip.xzs.domain.User;
+import org.modelmapper.ModelMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+@Service
+public class ExamPaperServiceImpl extends BaseServiceImpl<ExamPaper> implements ExamPaperService {
+
+    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
+    private final ExamPaperMapper examPaperMapper;
+    private final QuestionMapper questionMapper;
+    private final TextContentService textContentService;
+    private final QuestionService questionService;
+    private final SubjectService subjectService;
+
+    @Autowired
+    public ExamPaperServiceImpl(ExamPaperMapper examPaperMapper, QuestionMapper questionMapper, TextContentService textContentService, QuestionService questionService, SubjectService subjectService) {
+        super(examPaperMapper);
+        this.examPaperMapper = examPaperMapper;
+        this.questionMapper = questionMapper;
+        this.textContentService = textContentService;
+        this.questionService = questionService;
+        this.subjectService = subjectService;
+    }
+
+
+    @Override
+    public PageInfo<ExamPaper> page(ExamPaperPageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                examPaperMapper.page(requestVM));
+    }
+
+    @Override
+    public PageInfo<ExamPaper> taskExamPage(ExamPaperPageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                examPaperMapper.taskExamPage(requestVM));
+    }
+
+    @Override
+    public PageInfo<ExamPaper> studentPage(ExamPaperPageVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                examPaperMapper.studentPage(requestVM));
+    }
+
+
+    @Override
+    @Transactional
+    public ExamPaper savePaperFromVM(ExamPaperEditRequestVM examPaperEditRequestVM, User user) {
+        ActionEnum actionEnum = (examPaperEditRequestVM.getId() == null) ? ActionEnum.ADD : ActionEnum.UPDATE;
+        Date now = new Date();
+        List<ExamPaperTitleItemVM> titleItemsVM = examPaperEditRequestVM.getTitleItems();
+        List<ExamPaperTitleItemObject> frameTextContentList = frameTextContentFromVM(titleItemsVM);
+        String frameTextContentStr = JsonUtil.toJsonStr(frameTextContentList);
+
+        ExamPaper examPaper;
+        if (actionEnum == ActionEnum.ADD) {
+            examPaper = modelMapper.map(examPaperEditRequestVM, ExamPaper.class);
+            TextContent frameTextContent = new TextContent(frameTextContentStr, now);
+            textContentService.insertByFilter(frameTextContent);
+            examPaper.setFrameTextContentId(frameTextContent.getId());
+            examPaper.setCreateTime(now);
+            examPaper.setCreateUser(user.getId());
+            examPaper.setDeleted(false);
+            examPaperFromVM(examPaperEditRequestVM, examPaper, titleItemsVM);
+            examPaperMapper.insertSelective(examPaper);
+        } else {
+            examPaper = examPaperMapper.selectByPrimaryKey(examPaperEditRequestVM.getId());
+            TextContent frameTextContent = textContentService.selectById(examPaper.getFrameTextContentId());
+            frameTextContent.setContent(frameTextContentStr);
+            textContentService.updateByIdFilter(frameTextContent);
+            modelMapper.map(examPaperEditRequestVM, examPaper);
+            examPaperFromVM(examPaperEditRequestVM, examPaper, titleItemsVM);
+            examPaperMapper.updateByPrimaryKeySelective(examPaper);
+        }
+        return examPaper;
+    }
+
+    @Override
+    public ExamPaperEditRequestVM examPaperToVM(Integer id) {
+        ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(id);
+        ExamPaperEditRequestVM vm = modelMapper.map(examPaper, ExamPaperEditRequestVM.class);
+        vm.setLevel(examPaper.getGradeLevel());
+        TextContent frameTextContent = textContentService.selectById(examPaper.getFrameTextContentId());
+        List<ExamPaperTitleItemObject> examPaperTitleItemObjects = JsonUtil.toJsonListObject(frameTextContent.getContent(), ExamPaperTitleItemObject.class);
+        List<Integer> questionIds = examPaperTitleItemObjects.stream()
+                .flatMap(t -> t.getQuestionItems().stream()
+                        .map(q -> q.getId()))
+                .collect(Collectors.toList());
+        List<Question> questions = questionMapper.selectByIds(questionIds);
+        List<ExamPaperTitleItemVM> examPaperTitleItemVMS = examPaperTitleItemObjects.stream().map(t -> {
+            ExamPaperTitleItemVM tTitleVM = modelMapper.map(t, ExamPaperTitleItemVM.class);
+            List<QuestionEditRequestVM> questionItemsVM = t.getQuestionItems().stream().map(i -> {
+                Question question = questions.stream().filter(q -> q.getId().equals(i.getId())).findFirst().get();
+                QuestionEditRequestVM questionEditRequestVM = questionService.getQuestionEditRequestVM(question);
+                questionEditRequestVM.setItemOrder(i.getItemOrder());
+                return questionEditRequestVM;
+            }).collect(Collectors.toList());
+            tTitleVM.setQuestionItems(questionItemsVM);
+            return tTitleVM;
+        }).collect(Collectors.toList());
+        vm.setTitleItems(examPaperTitleItemVMS);
+        vm.setScore(ExamUtil.scoreToVM(examPaper.getScore()));
+        if (ExamPaperTypeEnum.TimeLimit == ExamPaperTypeEnum.fromCode(examPaper.getPaperType())) {
+            List<String> limitDateTime = Arrays.asList(DateTimeUtil.dateFormat(examPaper.getLimitStartTime()), DateTimeUtil.dateFormat(examPaper.getLimitEndTime()));
+            vm.setLimitDateTime(limitDateTime);
+        }
+        return vm;
+    }
+
+    @Override
+    public List<PaperInfo> indexPaper(PaperFilter paperFilter) {
+        return examPaperMapper.indexPaper(paperFilter);
+    }
+
+
+    @Override
+    public Integer selectAllCount() {
+        return examPaperMapper.selectAllCount();
+    }
+
+    @Override
+    public List<Integer> selectMothCount() {
+        Date startTime = DateTimeUtil.getMonthStartDay();
+        Date endTime = DateTimeUtil.getMonthEndDay();
+        List<KeyValue> mouthCount = examPaperMapper.selectCountByDate(startTime, endTime);
+        List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
+        return mothStartToNowFormat.stream().map(md -> {
+            KeyValue keyValue = mouthCount.stream().filter(kv -> kv.getName().equals(md)).findAny().orElse(null);
+            return null == keyValue ? 0 : keyValue.getValue();
+        }).collect(Collectors.toList());
+    }
+
+    private void examPaperFromVM(ExamPaperEditRequestVM examPaperEditRequestVM, ExamPaper examPaper, List<ExamPaperTitleItemVM> titleItemsVM) {
+        Integer gradeLevel = subjectService.levelBySubjectId(examPaperEditRequestVM.getSubjectId());
+        Integer questionCount = titleItemsVM.stream()
+                .mapToInt(t -> t.getQuestionItems().size()).sum();
+        Integer score = titleItemsVM.stream().
+                flatMapToInt(t -> t.getQuestionItems().stream()
+                        .mapToInt(q -> ExamUtil.scoreFromVM(q.getScore()))
+                ).sum();
+        examPaper.setQuestionCount(questionCount);
+        examPaper.setScore(score);
+        examPaper.setGradeLevel(gradeLevel);
+        List<String> dateTimes = examPaperEditRequestVM.getLimitDateTime();
+        if (ExamPaperTypeEnum.TimeLimit == ExamPaperTypeEnum.fromCode(examPaper.getPaperType())) {
+            examPaper.setLimitStartTime(DateTimeUtil.parse(dateTimes.get(0), DateTimeUtil.STANDER_FORMAT));
+            examPaper.setLimitEndTime(DateTimeUtil.parse(dateTimes.get(1), DateTimeUtil.STANDER_FORMAT));
+        }
+    }
+
+    private List<ExamPaperTitleItemObject> frameTextContentFromVM(List<ExamPaperTitleItemVM> titleItems) {
+        AtomicInteger index = new AtomicInteger(1);
+        return titleItems.stream().map(t -> {
+            ExamPaperTitleItemObject titleItem = modelMapper.map(t, ExamPaperTitleItemObject.class);
+            List<ExamPaperQuestionItemObject> questionItems = t.getQuestionItems().stream()
+                    .map(q -> {
+                        ExamPaperQuestionItemObject examPaperQuestionItemObject = modelMapper.map(q, ExamPaperQuestionItemObject.class);
+                        examPaperQuestionItemObject.setItemOrder(index.getAndIncrement());
+                        return examPaperQuestionItemObject;
+                    })
+                    .collect(Collectors.toList());
+            titleItem.setQuestionItems(questionItems);
+            return titleItem;
+        }).collect(Collectors.toList());
+    }
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/FileUploadImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.configuration.property.QnConfig;
+import com.mindskip.xzs.configuration.property.SystemConfig;
+import com.mindskip.xzs.service.FileUpload;
+import com.google.gson.Gson;
+import com.qiniu.common.QiniuException;
+import com.qiniu.http.Response;
+import com.qiniu.storage.Configuration;
+import com.qiniu.storage.Region;
+import com.qiniu.storage.UploadManager;
+import com.qiniu.storage.model.DefaultPutRet;
+import com.qiniu.util.Auth;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.InputStream;
+
+@Service
+public class FileUploadImpl implements FileUpload {
+    private final Logger logger = LoggerFactory.getLogger(FileUpload.class);
+    private final SystemConfig systemConfig;
+
+
+    @Autowired
+    public FileUploadImpl(SystemConfig systemConfig) {
+        this.systemConfig = systemConfig;
+    }
+
+    @Override
+    public String uploadFile(InputStream inputStream, long size, String extName) {
+        QnConfig qnConfig = systemConfig.getQn();
+        Configuration cfg = new Configuration(Region.region2());
+        UploadManager uploadManager = new UploadManager(cfg);
+        Auth auth = Auth.create(qnConfig.getAccessKey(), qnConfig.getSecretKey());
+        String upToken = auth.uploadToken(qnConfig.getBucket());
+        try {
+            Response response = uploadManager.put(inputStream, null, upToken, null, null);
+            DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
+            return qnConfig.getUrl() + "/" + putRet.key;
+        } catch (QiniuException ex) {
+            logger.error(ex.getMessage(), ex);
+        }
+        return null;
+    }
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/MessageServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.domain.Message;
+import com.mindskip.xzs.domain.MessageUser;
+import com.mindskip.xzs.repository.MessageMapper;
+import com.mindskip.xzs.repository.MessageUserMapper;
+import com.mindskip.xzs.service.MessageService;
+import com.mindskip.xzs.viewmodel.message.MessagePageRequestVM;
+import com.mindskip.xzs.viewmodel.student.user.MessageRequestVM;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Date;
+import java.util.List;
+
+@Service
+public class MessageServiceImpl implements MessageService {
+
+    private final MessageMapper messageMapper;
+    private final MessageUserMapper messageUserMapper;
+
+    @Autowired
+    public MessageServiceImpl(MessageMapper messageMapper, MessageUserMapper messageUserMapper) {
+        this.messageMapper = messageMapper;
+        this.messageUserMapper = messageUserMapper;
+    }
+
+    @Override
+    public List<Message> selectMessageByIds(List<Integer> ids) {
+        return messageMapper.selectByIds(ids);
+    }
+
+    @Override
+    public PageInfo<MessageUser> studentPage(MessageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                messageUserMapper.studentPage(requestVM)
+        );
+    }
+
+    @Override
+    public PageInfo<Message> page(MessagePageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                messageMapper.page(requestVM)
+        );
+    }
+
+    @Override
+    public List<MessageUser> selectByMessageIds(List<Integer> ids) {
+        return messageUserMapper.selectByMessageIds(ids);
+    }
+
+    @Override
+    @Transactional
+    public void sendMessage(Message message, List<MessageUser> messageUsers) {
+        messageMapper.insertSelective(message);
+        messageUsers.forEach(d -> d.setMessageId(message.getId()));
+        messageUserMapper.inserts(messageUsers);
+    }
+
+    @Override
+    @Transactional
+    public void read(Integer id) {
+        MessageUser messageUser = messageUserMapper.selectByPrimaryKey(id);
+        if (messageUser.getReaded())
+            return;
+        messageUser.setReaded(true);
+        messageUser.setReadTime(new Date());
+        messageUserMapper.updateByPrimaryKeySelective(messageUser);
+        messageMapper.readAdd(messageUser.getMessageId());
+    }
+
+    @Override
+    public Integer unReadCount(Integer userId) {
+        return messageUserMapper.unReadCount(userId);
+    }
+
+    @Override
+    public Message messageDetail(Integer id) {
+        MessageUser messageUser = messageUserMapper.selectByPrimaryKey(id);
+        return messageMapper.selectByPrimaryKey(messageUser.getMessageId());
+    }
+
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/QuestionServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.domain.other.KeyValue;
+import com.mindskip.xzs.domain.Question;
+import com.mindskip.xzs.domain.TextContent;
+import com.mindskip.xzs.domain.enums.QuestionStatusEnum;
+import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
+import com.mindskip.xzs.domain.question.QuestionItemObject;
+import com.mindskip.xzs.domain.question.QuestionObject;
+import com.mindskip.xzs.repository.QuestionMapper;
+import com.mindskip.xzs.service.QuestionService;
+import com.mindskip.xzs.service.SubjectService;
+import com.mindskip.xzs.service.TextContentService;
+import com.mindskip.xzs.utility.DateTimeUtil;
+import com.mindskip.xzs.utility.JsonUtil;
+import com.mindskip.xzs.utility.ModelMapperSingle;
+import com.mindskip.xzs.utility.ExamUtil;
+import com.mindskip.xzs.viewmodel.question.QuestionEditItemVM;
+import com.mindskip.xzs.viewmodel.question.QuestionEditRequestVM;
+import com.mindskip.xzs.viewmodel.question.QuestionPageRequestVM;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.modelmapper.ModelMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class QuestionServiceImpl extends BaseServiceImpl<Question> implements QuestionService {
+
+    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
+    private final QuestionMapper questionMapper;
+    private final TextContentService textContentService;
+    private final SubjectService subjectService;
+
+    @Autowired
+    public QuestionServiceImpl(QuestionMapper questionMapper, TextContentService textContentService, SubjectService subjectService) {
+        super(questionMapper);
+        this.textContentService = textContentService;
+        this.questionMapper = questionMapper;
+        this.subjectService = subjectService;
+    }
+
+    @Override
+    public PageInfo<Question> page(QuestionPageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                questionMapper.page(requestVM)
+        );
+    }
+
+
+    @Override
+    @Transactional
+    public Question insertFullQuestion(QuestionEditRequestVM model, Integer userId) {
+        Date now = new Date();
+        Integer gradeLevel = subjectService.levelBySubjectId(model.getSubjectId());
+
+        //题干、解析、选项等 插入
+        TextContent infoTextContent = new TextContent();
+        infoTextContent.setCreateTime(now);
+        setQuestionInfoFromVM(infoTextContent, model);
+        textContentService.insertByFilter(infoTextContent);
+
+        Question question = new Question();
+        question.setSubjectId(model.getSubjectId());
+        question.setGradeLevel(gradeLevel);
+        question.setCreateTime(now);
+        question.setQuestionType(model.getQuestionType());
+        question.setStatus(QuestionStatusEnum.OK.getCode());
+        question.setCorrectFromVM(model.getCorrect(), model.getCorrectArray());
+        question.setScore(ExamUtil.scoreFromVM(model.getScore()));
+        question.setDifficult(model.getDifficult());
+        question.setInfoTextContentId(infoTextContent.getId());
+        question.setCreateUser(userId);
+        question.setDeleted(false);
+        questionMapper.insertSelective(question);
+        return question;
+    }
+
+    @Override
+    @Transactional
+    public Question updateFullQuestion(QuestionEditRequestVM model) {
+        Integer gradeLevel = subjectService.levelBySubjectId(model.getSubjectId());
+        Question question = questionMapper.selectByPrimaryKey(model.getId());
+        question.setSubjectId(model.getSubjectId());
+        question.setGradeLevel(gradeLevel);
+        question.setScore(ExamUtil.scoreFromVM(model.getScore()));
+        question.setDifficult(model.getDifficult());
+        question.setCorrectFromVM(model.getCorrect(), model.getCorrectArray());
+        questionMapper.updateByPrimaryKeySelective(question);
+
+        //题干、解析、选项等 更新
+        TextContent infoTextContent = textContentService.selectById(question.getInfoTextContentId());
+        setQuestionInfoFromVM(infoTextContent, model);
+        textContentService.updateByIdFilter(infoTextContent);
+
+        return question;
+    }
+
+    @Override
+    public QuestionEditRequestVM getQuestionEditRequestVM(Integer questionId) {
+        //题目映射
+        Question question = questionMapper.selectByPrimaryKey(questionId);
+        return getQuestionEditRequestVM(question);
+    }
+
+    @Override
+    public QuestionEditRequestVM getQuestionEditRequestVM(Question question) {
+        //题目映射
+        TextContent questionInfoTextContent = textContentService.selectById(question.getInfoTextContentId());
+        QuestionObject questionObject = JsonUtil.toJsonObject(questionInfoTextContent.getContent(), QuestionObject.class);
+        QuestionEditRequestVM questionEditRequestVM = modelMapper.map(question, QuestionEditRequestVM.class);
+        questionEditRequestVM.setTitle(questionObject.getTitleContent());
+
+        //答案
+        QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(question.getQuestionType());
+        switch (questionTypeEnum) {
+            case SingleChoice:
+            case TrueFalse:
+                questionEditRequestVM.setCorrect(question.getCorrect());
+                break;
+            case MultipleChoice:
+                questionEditRequestVM.setCorrectArray(ExamUtil.contentToArray(question.getCorrect()));
+                break;
+            case GapFilling:
+                List<String> correctContent = questionObject.getQuestionItemObjects().stream().map(d -> d.getContent()).collect(Collectors.toList());
+                questionEditRequestVM.setCorrectArray(correctContent);
+                break;
+            case ShortAnswer:
+                questionEditRequestVM.setCorrect(questionObject.getCorrect());
+                break;
+            default:
+                break;
+        }
+        questionEditRequestVM.setScore(ExamUtil.scoreToVM(question.getScore()));
+        questionEditRequestVM.setAnalyze(questionObject.getAnalyze());
+
+
+        //题目项映射
+        List<QuestionEditItemVM> editItems = questionObject.getQuestionItemObjects().stream().map(o -> {
+            QuestionEditItemVM questionEditItemVM = modelMapper.map(o, QuestionEditItemVM.class);
+            if (o.getScore() != null) {
+                questionEditItemVM.setScore(ExamUtil.scoreToVM(o.getScore()));
+            }
+            return questionEditItemVM;
+        }).collect(Collectors.toList());
+        questionEditRequestVM.setItems(editItems);
+        return questionEditRequestVM;
+    }
+
+    public void setQuestionInfoFromVM(TextContent infoTextContent, QuestionEditRequestVM model) {
+        List<QuestionItemObject> itemObjects = model.getItems().stream().map(i ->
+                {
+                    QuestionItemObject item = new QuestionItemObject();
+                    item.setPrefix(i.getPrefix());
+                    item.setContent(i.getContent());
+                    item.setItemUuid(i.getItemUuid());
+                    item.setScore(ExamUtil.scoreFromVM(i.getScore()));
+                    return item;
+                }
+        ).collect(Collectors.toList());
+        QuestionObject questionObject = new QuestionObject();
+        questionObject.setQuestionItemObjects(itemObjects);
+        questionObject.setAnalyze(model.getAnalyze());
+        questionObject.setTitleContent(model.getTitle());
+        questionObject.setCorrect(model.getCorrect());
+        infoTextContent.setContent(JsonUtil.toJsonStr(questionObject));
+    }
+
+    @Override
+    public Integer selectAllCount() {
+        return questionMapper.selectAllCount();
+    }
+
+    @Override
+    public List<Integer> selectMothCount() {
+        Date startTime = DateTimeUtil.getMonthStartDay();
+        Date endTime = DateTimeUtil.getMonthEndDay();
+        List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
+        List<KeyValue> mouthCount = questionMapper.selectCountByDate(startTime, endTime);
+        return mothStartToNowFormat.stream().map(md -> {
+            KeyValue keyValue = mouthCount.stream().filter(kv -> kv.getName().equals(md)).findAny().orElse(null);
+            return null == keyValue ? 0 : keyValue.getValue();
+        }).collect(Collectors.toList());
+    }
+
+
+}

source/java/src/main/java/com/mindskip/xzs/service/impl/SubjectServiceImpl.java

+package com.mindskip.xzs.service.impl;
+
+import com.mindskip.xzs.domain.Subject;
+import com.mindskip.xzs.repository.SubjectMapper;
+import com.mindskip.xzs.service.SubjectService;
+import com.mindskip.xzs.viewmodel.education.SubjectPageRequestVM;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class SubjectServiceImpl extends BaseServiceImpl<Subject> implements SubjectService {
+
+    private final static String CACHE_NAME = "xzs:subject";
+    private final SubjectMapper subjectMapper;
+
+    @Autowired
+    public SubjectServiceImpl(SubjectMapper subjectMapper) {
+        super(subjectMapper);
+        this.subjectMapper = subjectMapper;
+    }
+
+    @Override
+    @Cacheable(value = CACHE_NAME, key = "#id", unless = "#result == null")
+    public Subject selectById(Integer id) {
+        return super.selectById(id);
+    }
+
+    @Override
+    @CacheEvict(value = CACHE_NAME, key = "#record.id")
+    public int updateByIdFilter(Subject record) {
+        return super.updateByIdFilter(record);
+    }
+
+    @Override
+    public List<Subject> getSubjectByLevel(Integer level) {
+        return subjectMapper.getSubjectByLevel(level);
+    }
+
+    @Override
+    public List<Subject> allSubject() {
+        return subjectMapper.allSubject();
+    }
+
+    @Override
+    public Integer levelBySubjectId(Integer id) {
+        return this.selectById(id).getLevel();
+    }
+
+    @Override
+    public PageInfo<Subject> page(SubjectPageRequestVM requestVM) {
+        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
+                subjectMapper.page(requestVM)
+        );
+    }
+
+}