package com.qxueyou.scc.exercise.util;
|
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import com.qxueyou.scc.base.model.ITrace;
|
import com.qxueyou.scc.base.util.CollectionUtils;
|
import com.qxueyou.scc.base.util.CommonUtils;
|
import com.qxueyou.scc.exercise.model.ExerciseItem;
|
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerU;
|
import com.qxueyou.scc.exercise.model.ExerciseItemOption;
|
import com.qxueyou.scc.exercise.model.ExerciseItemScore;
|
import com.qxueyou.scc.exercise.model.ExerciseObjectImg;
|
import com.qxueyou.scc.exercise.model.ExerciseOptionStatistics;
|
import com.qxueyou.scc.school.model.SchEvaluate;
|
|
/**
|
* Á·Ï°¹¤¾ßÀà
|
*
|
* @author zhiyong
|
*
|
*/
|
public class ExerciseUtils {
|
|
/**
|
* ÖØÐÂ×é×°Á·Ï°item
|
*
|
* @param lstItems
|
* @return
|
*/
|
public static void packageExerciseItem(List<ExerciseItem> lstItems, List<ExerciseItemAnswerU> lstUserAnswer,
|
List<ExerciseObjectImg> lstOptionImgs) {
|
for (ExerciseItem objExerciseItem : lstItems) {
|
// Ñ¡Ïî
|
List<ExerciseItemOption> options = objExerciseItem.getOptions();
|
// Ñ¡Ïî·ÖÊý
|
List<ExerciseItemScore> scores = objExerciseItem.getScores();
|
ExerciseUtils.packOption(options, scores, lstOptionImgs);
|
if (lstUserAnswer == null || lstUserAnswer.isEmpty()) {
|
continue;
|
}
|
for (ExerciseItemAnswerU answerU : lstUserAnswer) {
|
// »ñÓû§´ð°¸
|
if (answerU.getExerciseItemId().equals(objExerciseItem.getExerciseId())) {
|
objExerciseItem.setAnswer(answerU.getAnswer());
|
break;
|
}
|
}
|
}
|
}
|
|
/**
|
* ΪѡÏî×é×°·ÖÊýºÍͼƬ
|
*
|
* @return
|
*/
|
private static List<ExerciseItemOption> packOption(List<ExerciseItemOption> options, List<ExerciseItemScore> scores,
|
List<ExerciseObjectImg> lstOptionImgs) {
|
if (options == null || options.isEmpty()) {
|
return options;
|
}
|
if (scores == null || scores.isEmpty()) {
|
return options;
|
}
|
for (ExerciseItemOption objExerciseItemOption : options) {
|
for (ExerciseItemScore objExerciseItemScore : scores) {
|
if (objExerciseItemScore.getAttribute1().equals(objExerciseItemOption.getOptionId())) {
|
objExerciseItemOption.setScore((int) (Double.parseDouble(objExerciseItemScore.getScore())));
|
break;
|
}
|
}
|
// ͼƬ
|
if (lstOptionImgs == null || lstOptionImgs.isEmpty()) {
|
continue;
|
}
|
for (ExerciseObjectImg objExerciseObjectImg : lstOptionImgs) {
|
if (objExerciseObjectImg.getExerciseObjectId().equals(objExerciseItemOption.getOptionId())) {
|
List<ExerciseObjectImg> lstImgs = new ArrayList<>();
|
lstImgs.add(objExerciseObjectImg);
|
objExerciseItemOption.setImgPath(objExerciseObjectImg.getImgPath());
|
objExerciseItemOption.setImgs(lstImgs);
|
break;
|
}
|
}
|
}
|
return options;
|
}
|
|
/**
|
* ×é×°ÎʾíÏêϸͳ¼ÆÇé¿ö
|
*
|
* @param lstItems
|
* @param objSchEvaluate
|
* @return
|
*/
|
public static Map<String, Object> packageExerciseDetail(List<ExerciseItem> lstItems, SchEvaluate objSchEvaluate) {
|
Map<String, Object> mResult = new HashMap<String, Object>();
|
double iTotalAverageScore = 0;
|
double iTotalScore = 0;
|
for (ExerciseItem objExerciseItem : lstItems) {
|
// Ñ¡Ïî
|
List<ExerciseItemOption> options = objExerciseItem.getOptions();
|
// Ñ¡Ïî·ÖÊý
|
List<ExerciseItemScore> scores = objExerciseItem.getScores();
|
|
ExerciseUtils.packOption(options, scores, null);
|
List<ExerciseItemAnswerU> exerciseItemAnswerU = objExerciseItem.getExerciseItemAnswerU();
|
// ƽ¾ù·ÖÊý
|
double dAverageScore = 0;
|
double dUserScore = 0;
|
// ÊÇ·ñ´æÔÚ´ðÌâѧԱ
|
boolean hasAnswerU = exerciseItemAnswerU != null && !exerciseItemAnswerU.isEmpty();
|
if (options == null || options.isEmpty()) {
|
continue;
|
}
|
// ͳ¼Æÿ¸öÑ¡ÏîµÄÇé¿ö
|
LinkedHashMap<String, Integer> mOptionsDetail = new LinkedHashMap<String, Integer>();
|
LinkedHashMap<String, Integer> mOptionOrderDetail = new LinkedHashMap<String, Integer>();
|
if (!hasAnswerU) {
|
continue;
|
}
|
for (ExerciseItemAnswerU objExerciseItemAnswerU : exerciseItemAnswerU) {
|
String strAnswer = objExerciseItemAnswerU.getAnswer();
|
if (StringUtils.isEmpty(strAnswer)) {// Ϊ¿Õ×Ô¶¯Ìø³öÑ»·
|
break;
|
}
|
Map<String, Object> mResult2 = packageItemOption(objExerciseItem, strAnswer, mOptionsDetail, mOptionOrderDetail);
|
objExerciseItemAnswerU.setAnswerValue((String) mResult2.get("userAnswerContent"));
|
objExerciseItem.setMaxScore((Double) mResult2.get("dMaxScore"));
|
dUserScore += (Double) mResult2.get("dUserScore");
|
}
|
// ¼ÆËãƽ¾ùÖµ
|
if (hasAnswerU) {
|
dAverageScore = dUserScore / exerciseItemAnswerU.size();
|
}
|
// ×î´óÖµ
|
iTotalScore += objExerciseItem.getMaxScore();
|
objExerciseItem.setOptionsDetail(mOptionsDetail);
|
if(!mOptionOrderDetail.isEmpty()) {
|
List<Map<String, Object>> optionsOrderDetail = new ArrayList<>();
|
for (String key : mOptionOrderDetail.keySet()) {
|
optionsOrderDetail.add(CollectionUtils.newObjectMap("optionsOrder", key, "count", mOptionOrderDetail.get(key)));
|
}
|
objExerciseItem.setOptionsOrderDetail(optionsOrderDetail);
|
}
|
objExerciseItem.setAverageScore(dAverageScore);
|
iTotalAverageScore += dAverageScore;
|
objExerciseItem.setScores(null);
|
}
|
mResult.put("iTotalAverageScore", iTotalAverageScore);
|
mResult.put("iTotalScore", iTotalScore);
|
mResult.put("lstExerciseItem", lstItems);
|
mResult.put("objSchEvaluate", objSchEvaluate);
|
return mResult;
|
}
|
|
/**
|
* ×é×°ÎʾíÏêϸͳ¼ÆÇé¿ö
|
*
|
* @param lstItems
|
* @param objSchEvaluate
|
* @return
|
*/
|
public static Map<String, Object> packageUserExerciseDetail(List<ExerciseItem> result, SchEvaluate objSchEvaluate,
|
List<ExerciseObjectImg> lstExerciseObjectImg) {
|
Map<String, Object> mResult = new HashMap<String, Object>();
|
double iTotalScore = 0;
|
List<ExerciseItem> lstItems = new ArrayList<>();
|
double dTotalScoreU = 0;
|
String strCreator = "";
|
for (ExerciseItem objExerciseItem : result) {
|
lstItems.add(objExerciseItem);
|
List<ExerciseItemAnswerU> lstExerciseItemAnswerU = objExerciseItem.getExerciseItemAnswerU();
|
// Ñ¡Ïî
|
List<ExerciseItemOption> options = objExerciseItem.getOptions();
|
// Ñ¡Ïî·ÖÊý
|
List<ExerciseItemScore> scores = objExerciseItem.getScores();
|
// ×é×°Ñ¡ÏîºÍ·ÖÊý
|
ExerciseUtils.packOption(options, scores, lstExerciseObjectImg);
|
if (lstExerciseItemAnswerU == null || lstExerciseItemAnswerU.isEmpty()) {
|
continue;
|
}
|
// Óû§´ð°¸
|
String strAnswer = lstExerciseItemAnswerU.get(0).getAnswer();
|
if (StringUtils.isEmpty(strAnswer)) {// Ϊ¿Õ×Ô¶¯Ìø³öÑ»·
|
break;
|
}
|
strCreator = lstExerciseItemAnswerU.get(0).getCreator();
|
if (objExerciseItem.getType() == ExerciseItem.TYPE_ESSAY_QUESTION) {// ÎÊ´ðÌâ
|
objExerciseItem.setAnswer(strAnswer);
|
} else {
|
if (options == null || options.isEmpty()) {
|
continue;
|
}
|
Map<String, Object> mResult2 = packageItemOption(objExerciseItem, strAnswer,
|
new LinkedHashMap<String, Integer>(), new LinkedHashMap<String, Integer>());
|
objExerciseItem.setMaxScore((Double) mResult2.get("dUserScore"));
|
iTotalScore += (Double) mResult2.get("dMaxScore");
|
dTotalScoreU += (Double) mResult2.get("dUserScore");
|
objExerciseItem.setScores(null);
|
objExerciseItem.setAnswer((String) mResult2.get("userAnswerContent"));
|
}
|
}
|
mResult.put("iTotalScore", iTotalScore);
|
mResult.put("dTotalScoreU", dTotalScoreU);
|
mResult.put("lstExerciseItem", lstItems);
|
mResult.put("objSchEvaluate", objSchEvaluate);
|
mResult.put("strUserName", strCreator);
|
return mResult;
|
}
|
|
/**
|
* ÅжÏÌâÄ¿ÀàÐÍ
|
*
|
* @param objExerciseItem
|
* 퉀|
* @param strAnswer
|
* Óû§Ñ¡Ôñ´ð°¸
|
* @param mOptionsDetail
|
* ͳ¼ÆÖµ
|
* @return
|
*/
|
public static Map<String, Object> packageItemOption(ExerciseItem objExerciseItem, String strAnswer,
|
LinkedHashMap<String, Integer> mOptionsDetail, LinkedHashMap<String, Integer> mOptionOrderDetail) {
|
Map<String, Object> mResult = new HashMap<String, Object>();
|
// Ñ¡Ïî
|
List<ExerciseItemOption> options = objExerciseItem.getOptions();
|
double dMaxScore = 0;
|
double dUserScore = 0;
|
String[] c = "A B C D E F G H I J K L M N".split(" ");
|
// ÌâÄ¿ÀàÐÍ
|
int iType = objExerciseItem.getType();
|
int index = 0;
|
StringBuffer userAnswerContent = new StringBuffer(256);
|
for (ExerciseItemOption objExerciseItemOption : options) {
|
double dScore = Double.valueOf(objExerciseItemOption.getScore());
|
// »ñÈ¡×î´óÖµ
|
dMaxScore = iType == 2 ? dMaxScore + dScore : dScore > dMaxScore ? dScore : dMaxScore;
|
if (iType == ExerciseItem.TYPE_SINGLE_SELECT
|
&& strAnswer.substring(0, 1).equals(objExerciseItemOption.getOptionOrder())) {// µ¥Ñ¡A»òB»òC»òD_²¹³äxxxxxx
|
dUserScore += dScore;
|
userAnswerContent.append(strAnswer.length() > 2
|
? objExerciseItemOption.getContent() + strAnswer.substring(1, strAnswer.length()) : // Æ´½Ó²¹³äÄÚÈÝ
|
objExerciseItemOption.getContent());
|
mOptionsDetail.put(ExerciseUtils.getOptionsContent(objExerciseItemOption),
|
ExerciseUtils.getValue(ExerciseUtils.getOptionsContent(objExerciseItemOption), mOptionsDetail));
|
mOptionOrderDetail.put(objExerciseItemOption.getOptionOrder(),mOptionsDetail.get(ExerciseUtils.getOptionsContent(objExerciseItemOption)));
|
} else if (iType == ExerciseItem.TYPE_MULTI_SELECT) {// ¶àÑ¡A,B,C,D_²¹³äxxxxxx
|
String[] arrAnswer = strAnswer.split("_");
|
String[] strAnswerOrder = arrAnswer[0].split(",");
|
for (int i = 0; i < strAnswerOrder.length; i++) {
|
if (strAnswerOrder[i].equals(objExerciseItemOption.getOptionOrder())) {
|
dUserScore += dScore;
|
// Æ´½Ó²¹³äµÄÄÚÈÝ
|
if (index == options.size() - 1) {
|
userAnswerContent.append(objExerciseItemOption.getContent());
|
userAnswerContent.append(arrAnswer.length > 1 && arrAnswer[1].length() > 2
|
? "_" + strAnswer.substring(arrAnswer[0].length() + 1, strAnswer.length()) : "");
|
} else {
|
userAnswerContent.append(objExerciseItemOption.getContent()).append(';');
|
}
|
mOptionsDetail.put(ExerciseUtils.getOptionsContent(objExerciseItemOption), ExerciseUtils
|
.getValue(ExerciseUtils.getOptionsContent(objExerciseItemOption), mOptionsDetail));
|
mOptionOrderDetail.put(objExerciseItemOption.getOptionOrder(),mOptionsDetail.get(ExerciseUtils.getOptionsContent(objExerciseItemOption)));
|
}
|
}
|
} else if (iType == ExerciseItem.TYPE_SCORE
|
&& c[Integer.valueOf(strAnswer) - 1].equals(objExerciseItemOption.getOptionOrder())) {// ·ÖÖµ£¬1£¬2£¬3£¬4£¬5¿ÅÐÇ
|
dUserScore += dScore;
|
userAnswerContent.append(ExerciseUtils.getOptionsContent(objExerciseItemOption));// ¸ø´ð°¸ÎÄ×Ö¸³Öµ
|
mOptionsDetail.put(ExerciseUtils.getOptionsContent(objExerciseItemOption),
|
ExerciseUtils.getValue(ExerciseUtils.getOptionsContent(objExerciseItemOption), mOptionsDetail));
|
mOptionOrderDetail.put(objExerciseItemOption.getOptionOrder(),mOptionsDetail.get(ExerciseUtils.getOptionsContent(objExerciseItemOption)));
|
} else if (iType == ExerciseItem.TYPE_MEASUREMENT && index == 0) {// Á¿Öµ£¬Ö±½Ó´æ·ÖÊý
|
dUserScore += Integer.valueOf(strAnswer);
|
userAnswerContent.append(strAnswer).append("·Ö");
|
mOptionsDetail.put(strAnswer + "·Ö",
|
mOptionsDetail.get(strAnswer + "·Ö") == null ? 1 : mOptionsDetail.get(strAnswer + "·Ö") + 1);
|
mOptionOrderDetail.put(strAnswer,mOptionsDetail.get(strAnswer + "·Ö"));
|
}
|
index++;
|
}
|
mResult.put("dMaxScore", dMaxScore);
|
mResult.put("userAnswerContent", userAnswerContent.toString());
|
mResult.put("dUserScore", dUserScore);
|
return mResult;
|
}
|
|
/**
|
* »ñÈ¡Öµ
|
*
|
* @param content
|
* @param mOptionsDetail
|
* @param Content
|
* @return
|
*/
|
public static Integer getValue(String content, Map<String, Integer> mOptionsDetail) {
|
return mOptionsDetail.get(content) == null ? 1 : mOptionsDetail.get(content) + 1;
|
}
|
|
/**
|
* »ñÈ¡Ñ¡ÏîµÄÖµºÍ·ÖÊý
|
*
|
* @param objExerciseItemOption
|
* @return
|
*/
|
public static String getOptionsContent(ExerciseItemOption objExerciseItemOption) {
|
return objExerciseItemOption.getContent().concat("(").concat(String.valueOf(objExerciseItemOption.getScore()))
|
.concat("·Ö)");
|
}
|
|
/**
|
* ÖØÐÂ×é×°Á·Ï°item
|
*
|
* @param lstAllOptions
|
* @return
|
*/
|
public static void packageExerciseItem(Map<String, List<ExerciseItemOption>> optionsMap,
|
Map<String, String> answerMap, List<ExerciseItemOption> lstAllOptions,
|
Map<String, List<ExerciseObjectImg>> imgOptionMap) {
|
// ÉÏÒ»´ÎÁ·Ï°id
|
String lastExerciseId = "";
|
ExerciseItemOption option = null;
|
List<ExerciseItemOption> lstOptions = null;
|
StringBuffer correctAnswers = new StringBuffer(128); // ÕýÈ·´ð°¸
|
// 4.3 ÌâÄ¿Ñ¡Ïî
|
for (int i = 0; i < lstAllOptions.size(); i++) {
|
option = lstAllOptions.get(i);
|
|
if (imgOptionMap != null && imgOptionMap.get(option.getOptionId()) != null) {
|
option.setImgs(imgOptionMap.get(option.getOptionId()));
|
}
|
|
if (i == 0) {// µÚÒ»´Î
|
lstOptions = new ArrayList<ExerciseItemOption>();
|
lstOptions.add(option);
|
|
if (option.getChecked()) {// ÕýÈ·´ð°¸
|
correctAnswers.append(option.getOptionOrder()).append(',');
|
}
|
} else {// µÚ¶þ´Î¿ªÊ¼
|
if (lastExerciseId.equals(option.getExerciseItemId())) {// Ïàͬ
|
lstOptions.add(option);
|
|
if (option.getChecked()) {// ÕýÈ·´ð°¸
|
correctAnswers.append(option.getOptionOrder()).append(',');
|
}
|
} else {// ²»Ïàͬ
|
// Ìí¼Óµ½map
|
optionsMap.put(lastExerciseId, lstOptions);
|
answerMap.put(lastExerciseId, correctAnswers.toString());
|
|
correctAnswers = new StringBuffer(128);
|
if (option.getChecked()) {// ÕýÈ·´ð°¸
|
correctAnswers.append(option.getOptionOrder()).append(',');
|
}
|
lstOptions = new ArrayList<ExerciseItemOption>();
|
lstOptions.add(option);
|
}
|
}
|
|
if (i == lstAllOptions.size() - 1) {// ×îºóÒ»´Î
|
answerMap.put(option.getExerciseItemId(), correctAnswers.toString());
|
optionsMap.put(option.getExerciseItemId(), lstOptions);
|
}
|
|
// ÉÏÒ»´ÎÁ·Ï°id
|
lastExerciseId = option.getExerciseItemId();
|
}
|
}
|
|
/**
|
* ÖØÐÂ×é×°Á·Ï°item ÌâĿͼƬ
|
*
|
* @param lstAllOptions
|
* @return
|
*/
|
public static Map<String, List<ExerciseObjectImg>> packageExerciseItemImg(List<ExerciseObjectImg> lstImgs) {
|
Map<String, List<ExerciseObjectImg>> imgMap = new HashMap<String, List<ExerciseObjectImg>>();
|
// ÉÏÒ»´ÎÁ·Ï°id
|
String lastExerciseId = "";
|
ExerciseObjectImg objImg = null;
|
List<ExerciseObjectImg> lstImg = null;
|
// 4.3 ÌâÄ¿Ñ¡Ïî
|
for (int i = 0; i < lstImgs.size(); i++) {
|
objImg = lstImgs.get(i);
|
|
if (i == 0) {// µÚÒ»´Î
|
lstImg = new ArrayList<ExerciseObjectImg>();
|
lstImg.add(objImg);
|
} else {// µÚ¶þ´Î¿ªÊ¼
|
if (lastExerciseId.equals(objImg.getExerciseObjectId())) {// Ïàͬ
|
lstImg.add(objImg);
|
} else {// ²»Ïàͬ
|
// Ìí¼Óµ½map
|
imgMap.put(lastExerciseId, lstImg);
|
|
lstImg = new ArrayList<ExerciseObjectImg>();
|
lstImg.add(objImg);
|
}
|
}
|
|
if (i == lstImgs.size() - 1) {// ×îºóÒ»´Î
|
imgMap.put(objImg.getExerciseObjectId(), lstImg);
|
}
|
|
// ÉÏÒ»´ÎÁ·Ï°id
|
lastExerciseId = objImg.getExerciseObjectId();
|
}
|
|
return imgMap;
|
}
|
|
/**
|
* ÖØÐÂ×é×°Á·Ï°item
|
*
|
* @param lstAllOptions
|
* @return
|
*/
|
public static void packageExerciseItemScore(Map<String, List<ExerciseItemScore>> scoreMap,
|
List<ExerciseItemScore> lstAllscores) {
|
// ÉÏÒ»´ÎÁ·Ï°id
|
String lastExerciseId = "";
|
ExerciseItemScore score = null;
|
List<ExerciseItemScore> lstscore = null;
|
// 4.3 ÌâÄ¿Ñ¡Ïî
|
for (int i = 0; i < lstAllscores.size(); i++) {
|
score = lstAllscores.get(i);
|
|
if (i == 0) {// µÚÒ»´Î
|
lstscore = new ArrayList<ExerciseItemScore>();
|
lstscore.add(score);
|
} else {// µÚ¶þ´Î¿ªÊ¼
|
if (lastExerciseId.equals(score.getExerciseItemId())) {// Ïàͬ
|
lstscore.add(score);
|
} else {// ²»Ïàͬ
|
// Ìí¼Óµ½map
|
scoreMap.put(lastExerciseId, lstscore);
|
|
lstscore = new ArrayList<ExerciseItemScore>();
|
lstscore.add(score);
|
}
|
}
|
|
if (i == lstAllscores.size() - 1) {// ×îºóÒ»´Î
|
scoreMap.put(score.getExerciseItemId(), lstscore);
|
}
|
|
// ÉÏÒ»´ÎÁ·Ï°id
|
lastExerciseId = score.getExerciseItemId();
|
}
|
}
|
|
/**
|
* ÖØÐÂ×é×°×öÌâ¼Ç¼ ExerciseItemAnswer ¡ª¡ª ³É¼¨Í³¼Æ
|
*
|
* @param lstAllOptions
|
* @return
|
*/
|
public static void packageExerciseItemAnswerStatis(List<ExerciseItemAnswerU> answers,
|
Map<String, Object> answerUMap) {
|
// ÉÏÒ»´ÎÁ·Ï°id
|
String lastExerciseId = "";
|
ExerciseItemAnswerU answer = null;
|
List<ExerciseItemAnswerU> lstAnswers = null;
|
// ×öÌâ¼Ç¼
|
for (int i = 0; i < answers.size(); i++) {
|
answer = answers.get(i);
|
|
if (i == 0) {// µÚÒ»´Î
|
lstAnswers = new ArrayList<ExerciseItemAnswerU>();
|
lstAnswers.add(answer);
|
} else {// µÚ¶þ´Î¿ªÊ¼
|
if (lastExerciseId.equals(answer.getExerciseItemId())) {// Ïàͬ
|
lstAnswers.add(answer);
|
|
} else {// ²»Ïàͬ
|
// Ìí¼Óµ½map
|
answerUMap.put(lastExerciseId, lstAnswers);
|
|
lstAnswers = new ArrayList<ExerciseItemAnswerU>();
|
lstAnswers.add(answer);
|
}
|
}
|
|
if (i == answers.size() - 1) {// ×îºóÒ»´Î
|
answerUMap.put(answer.getExerciseItemId(), lstAnswers);
|
}
|
|
// ÉÏÒ»´ÎÁ·Ï°id
|
lastExerciseId = answer.getExerciseItemId();
|
}
|
}
|
|
/**
|
* ÖØÐÂ×é×°ÌâÄ¿Ñ¡ÏîExerciseItemOption ¡ª¡ª ³É¼¨Í³¼Æ
|
*
|
* @param lstAllOptions
|
* @return
|
*/
|
public static void packageExerciseItemOption(List<ExerciseItemOption> itemOptionLst,
|
Map<String, Object> itemOptionMap) {
|
// ÉÏÒ»´ÎÁ·Ï°id
|
String lastExerciseId = "";
|
ExerciseItemOption option = null;
|
List<ExerciseItemOption> lstOptions = null;
|
// ÌâÄ¿Ñ¡Ïî
|
for (int i = 0; i < itemOptionLst.size(); i++) {
|
option = itemOptionLst.get(i);
|
|
if (i == 0) {// µÚÒ»´Î
|
lstOptions = new ArrayList<ExerciseItemOption>();
|
lstOptions.add(option);
|
} else {// µÚ¶þ´Î¿ªÊ¼
|
if (lastExerciseId.equals(option.getExerciseItemId())) {// Ïàͬ
|
lstOptions.add(option);
|
|
} else {// ²»Ïàͬ
|
// Ìí¼Óµ½map
|
itemOptionMap.put(lastExerciseId, lstOptions);
|
|
lstOptions = new ArrayList<ExerciseItemOption>();
|
lstOptions.add(option);
|
}
|
}
|
|
if (i == itemOptionLst.size() - 1) {// ×îºóÒ»´Î
|
itemOptionMap.put(option.getExerciseItemId(), lstOptions);
|
}
|
|
// ÉÏÒ»´ÎÁ·Ï°id
|
lastExerciseId = option.getExerciseItemId();
|
}
|
}
|
|
/**
|
* ÖØÐÂ×é×°ÌâÄ¿Ñ¡Ïîͳ¼ÆExerciseOptionStatistics ¡ª¡ª ³É¼¨Í³¼Æ
|
*
|
* @param lstAllOptions
|
* @return
|
*/
|
public static void packageExerciseOptionStatis(List<ExerciseOptionStatistics> claOptionStatisLst,
|
Map<String, Object> optionStatisMap) {
|
// ÉÏÒ»´ÎÁ·Ï°id
|
String lastExerciseId = "";
|
ExerciseOptionStatistics optionSta = null;
|
List<ExerciseOptionStatistics> lstOptionStas = null;
|
// ÌâÄ¿Ñ¡Ïî
|
for (int i = 0; i < claOptionStatisLst.size(); i++) {
|
optionSta = claOptionStatisLst.get(i);
|
|
if (i == 0) {// µÚÒ»´Î
|
lstOptionStas = new ArrayList<ExerciseOptionStatistics>();
|
lstOptionStas.add(optionSta);
|
} else {// µÚ¶þ´Î¿ªÊ¼
|
if (lastExerciseId.equals(optionSta.getExerciseItemId())) {// Ïàͬ
|
lstOptionStas.add(optionSta);
|
|
} else {// ²»Ïàͬ
|
// Ìí¼Óµ½map
|
optionStatisMap.put(lastExerciseId, lstOptionStas);
|
|
lstOptionStas = new ArrayList<ExerciseOptionStatistics>();
|
lstOptionStas.add(optionSta);
|
}
|
}
|
|
if (i == claOptionStatisLst.size() - 1) {// ×îºóÒ»´Î
|
optionStatisMap.put(optionSta.getExerciseItemId(), lstOptionStas);
|
}
|
|
// ÉÏÒ»´ÎÁ·Ï°id
|
lastExerciseId = optionSta.getExerciseItemId();
|
}
|
}
|
|
/**
|
* »ñȡת»»½á¹û
|
*
|
* @param count
|
* @param allCount
|
* @return
|
*/
|
public static String getFormatValue(long count, long allCount) {
|
double value = Double.valueOf(count) / Double.valueOf(allCount) * 100;
|
|
return CommonUtils.formatDecimalFormat(value, CommonUtils.PARTEN_ONE);
|
}
|
|
/**
|
* »ñȡת»»½á¹û
|
*
|
* @param count
|
* @param allCount
|
* @return
|
*/
|
public static String getFormatValue(int count, int allCount) {
|
double value = Double.valueOf(count) / Double.valueOf(allCount) * 100;
|
|
return CommonUtils.formatDecimalFormat(value, CommonUtils.PARTEN_ONE);
|
}
|
|
/**
|
* ÉèÖÃÐÂÔö¹ì¼£ÐÅÏ¢
|
*
|
* @param trace
|
*/
|
public static void setCreateTrace(ITrace trace, Map<String, String> userMap) {
|
trace.setCreateId(userMap.get("userId"));
|
trace.setCreateTime(new Date(System.currentTimeMillis()));
|
trace.setCreator(userMap.get("userName"));
|
trace.setUpdateId(userMap.get("userId"));
|
trace.setUpdateTime(new Date(System.currentTimeMillis()));
|
trace.setUpdator(userMap.get("userName"));
|
|
}
|
|
/**
|
* ÉèÖøüй켣ÐÅÏ¢
|
*
|
* @param trace
|
*/
|
public static void setUpdateTrace(ITrace trace, Map<String, String> userMap) {
|
|
trace.setUpdateId(userMap.get("userId"));
|
trace.setUpdateTime(new Date(System.currentTimeMillis()));
|
trace.setUpdator(userMap.get("userName"));
|
|
}
|
|
/**
|
* ת»»ÎªBigDecimal
|
*
|
* @param str1
|
* @param str2
|
* @return
|
*/
|
public static BigDecimal parseStrToBigDecimal(String str1, String str2) {
|
|
return new BigDecimal(
|
CommonUtils.formatDecimalFormat(Double.parseDouble(str1) / Double.parseDouble(str2) * 100, "#.##"));
|
}
|
}
|
