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, "#.##"));
|
}
|
}
|
