public static string GetTestViewHTML(试卷内容 c试卷内容, string sKey, bool isShowTitle)
{
string sHtml = "",
sHtml试题 = "";
序号对象类 序号对象 = new 序号对象类();
if (isShowTitle)
{
sHtml += "<div style=\"font-family:Verdana, Arial,宋体, Sans-Serif, Helvetica;font-size:14px;\">";
sHtml += "<div style=\"text-align:center;\">" +
"<div class=\"ViewTest_I_H_Title\" style=\"font-size:30px;font-weight:bold;\">" + c试卷内容.名称 + "</div>" +
"<div class=\"ViewTest_I_H_Count\">总分：" + c试卷内容.总分 + "</div>" +
"</div>";
}
foreach (试卷中大题 题型 in c试卷内容.试卷中大题集合)
{
sHtml试题 = "";
foreach (试卷大题中试题 试题 in 题型.试卷大题中试题集合)
{
if (sKey != "1")
{
sHtml试题 += ViewSubject.getMarkItem(试题, 序号对象, 0, false, false);
}
else
{
sHtml试题 += ViewSubject.getMarkItem(试题, 序号对象, 0, false, true);
}
}
sHtml += "<div class=\"ViewTestContent\">";
sHtml += "<div class=\"C_E_L_I_C_R_C_Title\">" +
"<div class=\"C_E_L_I_C_R_C_T_SubType\"><b>" + 题型.名称 + "</b></div>" +
"<div class=\"C_E_L_I_C_R_C_T_Explain\">说明:" + 题型.说明 + "</div>" +
"</div>";
sHtml += "<div class=\"C_E_L_I_C_R_C_Content\" >" +
"<div class=\"C_E_L_I_C_R_C_Font\">" + sHtml试题 + "</div>" +
"</div>";
sHtml += "</div>";
}
if (isShowTitle)
{
sHtml += "</div>";
}
return sHtml;
}
private static LoveKaoServiceReference.试卷内容 把试卷内容转化成试卷内容WCF(试卷内容 content)
{
LoveKaoServiceReference.试卷内容 contentWCF = new LoveKaoServiceReference.试卷内容();
contentWCF.ID = content.ID;
contentWCF.名称 = content.名称;
contentWCF.试卷外部信息ID = content.试卷外部信息ID;
contentWCF.说明 = content.说明;
contentWCF.提交备注 = content.提交备注;
contentWCF.提交人ID = content.提交人ID;
contentWCF.提交时间 = content.提交时间;
contentWCF.试题图片 = content.试题图片;
contentWCF.试卷中大题集合 = new List<LoveKaoServiceReference.试卷中大题>();
foreach (var testType in content.试卷中大题集合)
{
LoveKaoServiceReference.试卷中大题 testTypeWCF = 把试卷中大题转化成试卷中大题WCF(testType);
testTypeWCF.试卷大题中试题集合 = new List<LoveKaoServiceReference.试卷大题中试题>();
foreach (var testProblem in testType.试卷大题中试题集合)
{
LoveKaoServiceReference.试卷大题中试题 testProblemWCF = 把试卷大题中试题转化成试卷大题中试题WCF(testProblem);
if (testProblem.子小题集合 != null && testProblem.子小题集合.Count > 0)
{
testProblemWCF.子小题集合 = new List<LoveKaoServiceReference.试卷大题中试题>();
foreach (var subTestProblem in testProblem.子小题集合)
{
LoveKaoServiceReference.试卷大题中试题 subTestProblemWCF = 把试卷大题中试题转化成试卷大题中试题WCF(subTestProblem);
testProblemWCF.子小题集合.Add(subTestProblemWCF);
}
}
testTypeWCF.试卷大题中试题集合.Add(testProblemWCF);
}
contentWCF.试卷中大题集合.Add(testTypeWCF);
}
return contentWCF;
}
public static Guid 随机生成试卷(取题条件 getProblemCondition, out int 试题充足情况)
{
试题充足情况 = 0;
LoveKaoExamEntities db = new LoveKaoExamEntities();
if (getProblemCondition.取题题型及数量集合.Count > 15)
{
throw new Exception("试卷题型不能超过15个！");
}
foreach (取题题型及数量 typeNum in getProblemCondition.取题题型及数量集合)
{
if (typeNum.数量 > 200)
{
throw new Exception("每个题型下的题目不能超过200道！");
}
}
试卷外部信息 outside = new 试卷外部信息();
outside.ID = Guid.NewGuid();
outside.爱考网ID = outside.ID;
outside.创建人ID = 用户信息.CurrentUser.用户ID;
outside.名称 = getProblemCondition.试卷名称;
outside.说明 = "";
outside.分类列表 = new List<string>();
//给试卷内容赋值
试卷内容 test = new 试卷内容();
test.ID = Guid.NewGuid();
test.名称 = getProblemCondition.试卷名称;
test.说明 = "";
test.提交人ID = outside.创建人ID;
test.提交备注 = "";
test.试卷外部信息ID = outside.ID;
if (getProblemCondition.网站分类集合 == null || getProblemCondition.网站分类集合 == "")
{
throw new Exception("您还没选择分类，请先选择！");
}
if (getProblemCondition.网站分类集合 != null && getProblemCondition.网站分类集合 != "")
{
string[] sortList = getProblemCondition.网站分类集合.Split(",".ToCharArray());
if (sortList.Length > 10)
{
throw new Exception("分类选择不能超过10个！");
}
foreach (string sortName in sortList)
{
outside.分类列表.Add(sortName);
}
}
test.试卷中大题集合 = new List<试卷中大题>();
decimal totalScore = 0;
//遍历题型数量，并赋值
for (int i = 0; i < getProblemCondition.取题题型及数量集合.Count; i++)
{
getProblemCondition.取题题型及数量集合[0] = getProblemCondition.取题题型及数量集合[i];
List<试题外部信息表> listOutside = 试题外部信息.判断取题条件(getProblemCondition).ToList();
totalScore += getProblemCondition.取题题型及数量集合[i].每小题分值 * getProblemCondition.取题题型及数量集合[i].数量;
试卷中大题 type = new 试卷中大题();
type.ID = Guid.NewGuid();
type.名称 = getProblemCondition.取题题型及数量集合[i].题型名称;
type.说明 = "";
//随机取到的试题内容ID集合
if (getProblemCondition.取题题型及数量集合[i].数量 != 0)
{
List<Guid> listProblemId = 试题外部信息.随机取题(getProblemCondition.取题题型及数量集合[i].题型Enum,
getProblemCondition.取题题型及数量集合[i].数量, listOutside, 用户信息.CurrentUser.用户ID);
if (listProblemId.Count < getProblemCondition.取题题型及数量集合[i].数量)
{
试题充足情况 = 2;
}
type.试卷大题中试题集合 = new List<试卷大题中试题>();
//遍历题目数量，并赋值
for (int j = 0; j < listProblemId.Count; j++)
{
试卷大题中试题 testProblem = new 试卷大题中试题();
testProblem.ID = Guid.NewGuid();
testProblem.试题内容ID = listProblemId[j];
testProblem.每小题分值 = getProblemCondition.取题题型及数量集合[i].每小题分值;
testProblem.顺序 = Convert.ToByte(j);
type.试卷大题中试题集合.Add(testProblem);
}
//是复合题和多题干共选项题时给子集赋值
if (getProblemCondition.取题题型及数量集合[i].题型Enum > 39 && getProblemCondition.取题题型及数量集合[i].题型Enum < 50 ||
getProblemCondition.取题题型及数量集合[i].题型Enum == 80)
{
List<试题内容表> listSubContent = db.试题内容表.Where(a => listProblemId.Contains(a.父试题内容ID.Value)).ToList();
var groupSubContent = listSubContent.GroupBy(a => a.父试题内容ID).ToList();
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
testProblem.子小题集合 = new List<试卷大题中试题>();
var subContent = groupSubContent.Where(a => a.Key == testProblem.试题内容ID).First();
foreach (var sub in subContent)
{
试卷大题中试题 subTestProblem = new 试卷大题中试题();
subTestProblem.ID = Guid.NewGuid();
subTestProblem.每小题分值 = getProblemCondition.取题题型及数量集合[i].每小题分值 / subContent.Count();
subTestProblem.试题内容ID = sub.ID;
testProblem.子小题集合.Add(subTestProblem);
}
}
}
}
test.试卷中大题集合.Add(type);
}
test.总分 = Convert.ToInt32(totalScore);
outside.当前试卷内容 = test;
outside.试卷内容ID = test.ID;
outside.总分 = Convert.ToInt32(totalScore);
//加入缓存
MemoryCache.Default.Add("" + outside.ID + "", outside, cacheRandomTest);
if (试题充足情况 != 2)
{
试题充足情况 = 1;
}
return outside.ID;
}
/// <param name="相关ID">考试设置或试卷内容ID</param>
/// <param name="类型">0练习，1考试</param>
public static string 得到在线考试Json(Guid 相关ID,byte 类型, Guid 用户ID)
{
int TestDuration = 0;
试卷内容 content = new 试卷内容();
if (类型 == 0)
{
练习设置 exerciseSet=练习设置.练习设置查询.Where(a => a.试卷内容ID == 相关ID).First();
if (!exerciseSet.考生ID集合.Contains(用户ID))
{
throw new Exception("你不在该练习的考生范围内，无权参加练习！");
}
TestDuration = exerciseSet.考试时长;
content=exerciseSet.试卷内容;
}
else
{
考试设置 examSet = 考试设置.考试设置查询.Where(a => a.ID == 相关ID).First();
//判断是否是在考试时间内，是才能进入考试
if (DateTime.Now < examSet.考试开始时间)
{
throw new Exception("考试时间未到，不能进入考试！");
}
if (DateTime.Now > examSet.考试结束时间)
{
throw new Exception("考试时间已过，不能进入考试！");
}
if (!examSet.考生ID集合.Contains(用户ID))
{
throw new Exception("你不在该考试的考生范围内，无权参加考试！");
}
if (考生做过的试卷.考生做过的试卷查询.Any(a => a.相关ID == 相关ID && a.类型 == 1 && a.考生ID == 用户ID
&& a.是否是已提交的试卷 == true) == true)
{
throw new Exception("你已参加过本场考试，不能再次考试！");
}
TestDuration = examSet.考试时长;
content=examSet.试卷内容;
}
试卷外部信息 outside = content.试卷外部信息;
if (outside.试卷状态Enum == 1 || outside.试卷状态Enum == 3)
{
throw new Exception("该试卷已被删除！");
}
if (outside.试卷状态Enum == 4)
{
throw new Exception("该试卷是草稿试卷，您无法参加考试！");
}
考生做过的试卷 memberDoneTest = new 考生做过的试卷();
memberDoneTest.类型 = 类型;
memberDoneTest.相关ID = 相关ID;
if (类型 == 0)
{
memberDoneTest.练习设置 = new 练习设置();
memberDoneTest.练习设置.试卷内容 = content;
memberDoneTest.练习设置.试卷内容ID = content.ID;
}
else
{
memberDoneTest.考试设置 = new 考试设置();
memberDoneTest.考试设置.试卷内容 = content;
memberDoneTest.考试设置.试卷内容ID = content.ID;
}
content = 试卷内容.去掉试卷中的试题的答案(content);
string json = memberDoneTest.转化成Json();
json = json.Replace("\"考生ID\": null", "\"公共信息\":{\"考生ID\": null");
if (类型 == 0)
{
json = json.Replace(",\r\n \"练习设置\"", "},\r\n \"练习设置\"");
}
else
{
json = json.Replace(",\r\n \"考试设置\"", "},\r\n \"考试设置\"");
}
//格式化Json
JObject bo = JObject.Parse(json);
json = json.Replace("试卷内容\": {", "试卷内容\": {\"考试时长\":" + TestDuration + ",");
JObject bo1 = JObject.Parse(json);
string newJson = "{\"公共信息\":";
string common = bo1["公共信息"].ToString();
newJson = newJson + common+",\"试卷内容\":";
string test = string.Empty;
if (类型 == 0)
{
test = bo1["练习设置"]["试卷内容"].ToString();
}
else
{
test = bo1["考试设置"]["试卷内容"].ToString();
}
newJson = newJson + test+"}";
return newJson;
}
public static void 修改草稿试卷(List<string> 分类列表, 试卷内容 试卷内容, Guid 试卷外部信息ID, byte 试卷状态Enum)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
试卷外部信息表 outsideTable = db.试卷外部信息表.FirstOrDefault(a => a.ID == 试卷外部信息ID);
List<string> listBelongSort = 所属分类.所属分类处理(分类列表, outsideTable.创建人ID, db);
if (outsideTable.试卷状态Enum == 1)
{
throw new Exception("该试卷已被删除！");
}
outsideTable.试卷状态Enum = 试卷状态Enum;
outsideTable.最新更新时间 = DateTime.Now;
所属分类.修改相关信息更新所属分类(listBelongSort, 1, outsideTable.创建人ID, outsideTable.ID, db);
if (试卷内容 != null)
{
试卷内容表 dbContent = db.试卷内容表.FirstOrDefault(a => a.ID == 试卷内容.ID);
db.试卷内容表.DeleteObject(dbContent);
//db.SaveChanges();
试卷内容.保存(db, 试卷内容.ID);
db.SaveChanges();
}
}
public static void 修改正常试卷(List<string> 分类列表, 试卷内容 试卷内容, Guid 试卷外部信息ID, int 试卷状态Enum)
{
if (试卷状态Enum == 4)
{
throw new Exception("正常试卷不能改为草稿！");
}
LoveKaoExamEntities db = new LoveKaoExamEntities();
试卷外部信息表 outside = db.试卷外部信息表.FirstOrDefault(a => a.ID == 试卷外部信息ID);
异常处理.删除修改权限判断(outside.创建人ID);
List<string> listBelongSort = 所属分类.所属分类处理(分类列表, outside.创建人ID, db);
if (outside.试卷状态Enum == 1)
{
throw new Exception("该试卷已被删除！");
}
outside.最新更新时间 = DateTime.Now;
if (试卷内容 != null)
{
outside.名称 = 试卷内容.名称;
outside.试卷状态Enum = 0;
outside.试卷内容ID = 试卷内容.ID;
//计算试卷总分
decimal totalScore= 试卷外部信息.计算试卷总分(试卷内容);
outside.总分 = Convert.ToInt32(totalScore);
}
using (TransactionScope scope = new TransactionScope())
{
所属分类.修改相关信息更新所属分类(listBelongSort, 1, outside.创建人ID, outside.ID, db);
if (试卷内容 != null)
{
试卷内容.保存(db, 试卷内容.ID);
}
scope.Complete();
}
}
/// <param name="类型">0保存本站试卷，1保存下载试卷</param>
public static void 保存试卷相关信息(试卷内容 试卷内容, 试卷外部信息 试卷外部信息,int 类型)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
List<string> listSort = 试卷外部信息.分类列表.ToList();
if (类型 == 0)
{
listSort=所属分类.所属分类处理(listSort, 试卷外部信息.创建人ID, db);
}
else
{
所属分类.所属分类处理(listSort, 用户信息.CurrentUser.用户ID, db);
}
试卷外部信息表 testOutside = new 试卷外部信息表();
testOutside.ID = 试卷内容.试卷外部信息ID;
if (类型 == 0)
{
testOutside.创建人ID = 试卷内容.提交人ID;
}
else
{
testOutside.创建人ID = 用户信息.CurrentUser.用户ID;
}
testOutside.创建时间 = DateTime.Now;
testOutside.最新更新时间 = DateTime.Now;
testOutside.说明 = 试卷内容.说明;
testOutside.试卷内容ID = 试卷内容.ID;
testOutside.爱考网ID = 试卷外部信息.爱考网ID;
testOutside.试卷类型 = 试卷外部信息.试卷类型;
testOutside.名称 = 试卷内容.名称;
testOutside.试卷状态Enum = 试卷外部信息.试卷状态Enum;
//保存的是正常试卷，则计算总分，是草稿则不需计算
if (试卷外部信息.试卷状态Enum == 0)
{
//计算试卷总分
decimal totalScore = 试卷外部信息.计算试卷总分(试卷内容);
testOutside.总分 = Convert.ToInt32(totalScore);
}
using (TransactionScope scope = new TransactionScope())
{
if (类型 == 0)
{
所属分类.添加相关信息所属分类(listSort, testOutside.创建人ID, testOutside.ID, 1, db);
}
else
{
所属分类.添加相关信息所属分类(listSort, 用户信息.CurrentUser.用户ID, testOutside.ID, 1, db);
}
db.试卷外部信息表.AddObject(testOutside);
if (类型 == 0)
{
试卷内容.保存(db, 试卷内容.ID);
}
else
{
试卷内容.保存下载试卷(db, listSort);
}
scope.Complete();
}
}
private static decimal 计算试卷总分(试卷内容 试卷内容)
{
//计算试卷总分
decimal totalScore = 0;
for (int i = 0; i < 试卷内容.试卷中大题集合.Count; i++)
{
for (int j = 0; j < 试卷内容.试卷中大题集合[i].试卷大题中试题集合.Count; j++)
{
totalScore += 试卷内容.试卷中大题集合[i].试卷大题中试题集合[j].每小题分值;
}
}
return totalScore;
}
public static string 转化成完整Json字符串试题内容带答案(试卷内容 试卷内容, 试卷外部信息 试卷外部信息)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
试卷内容 content = 给试卷内容中试题内容Json赋值(试卷内容, true);
替换Json的扛(content);
string 试卷内容Json字符串 = content.转化成Json字符串();
string 试卷外部信息Json字符串 = 试卷外部信息.转化成Json字符串();
string json = "{\"content\":" + 试卷内容Json字符串 + ",\"outside\":" + 试卷外部信息Json字符串 + "}";
json = 还原Json的扛(json);
json = json.Replace("\"试题内容Json\": \"", "\"试题内容Json\":");
json = json.Replace("\\r\\n", "");
json = json.Replace("\"outside\":null}\"", "\"outside\":null}");
json = json.Replace("\"00000000-0000-0000-0000-000000000000\"", "null");
return json;
}
public static string 转化成完整Json字符串试题内容不带答案(试卷内容 试卷内容, 试卷外部信息 试卷外部信息)
{
试卷内容 = 去掉试卷中的试题的答案(试卷内容);
替换Json的扛(试卷内容);
string 试卷内容Json字符串 = 试卷内容.转化成Json字符串();
string 试卷外部信息Json字符串 = 试卷外部信息.转化成Json字符串();
string json = "{\"content\":" + 试卷内容Json字符串 + ",\"outside\":" + 试卷外部信息Json字符串 + "}";
json = 还原Json的扛(json);
json = json.Replace("\"试题内容Json\": \"", "\"试题内容Json\":");
json = json.Replace("\\r\\n", "");
json = json.Replace("\\n", "");
json = json.Replace("\\", "");
json = json.Replace("\"outside\":null}\"", "\"outside\":null}");
json = json.Replace("\"00000000-0000-0000-0000-000000000000\"", "null");
return json;
}
public static 试卷内容 给试卷内容中试题内容Json赋值(试卷内容 试卷内容, bool 是否加null的连线题回答)
{
List<Guid> listProblemId = new List<Guid>();
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
listProblemId.Add(testProblem.试题内容ID);
if (testProblem.子小题集合 != null)
{
foreach (试卷大题中试题 subTestProblem in testProblem.子小题集合)
{
listProblemId.Add(subTestProblem.试题内容ID);
}
}
}
}
List<试题内容> listProblem = 试题内容.试题内容查询.Where(a => listProblemId.Contains<Guid>(a.ID)).ToList();
试卷内容.试题图片 = new Dictionary<string, byte[]>();
foreach (试题内容 content in listProblem)
{
Dictionary<string, byte[]> oneDic = 试题外部信息.获取试题图片(content.Json字符串);
foreach (var subOneDic in oneDic)
{
试卷内容.试题图片.Add(subOneDic.Key, subOneDic.Value);
}
content.Json字符串 = "{\"content\":" + content.Json字符串 + ",\"outside\":null}";
}
//给试卷大题中试题的试题内容属性赋值
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
foreach (试题内容 content in listProblem)
{
if (testProblem.试题内容ID == content.ID)
{
//加一个null的回答，界面有需求
if (content.小题型Enum == 30 && 是否加null的连线题回答 == true)
{
考生连线题回答 memberLinkAnswer = new 考生连线题回答();
memberLinkAnswer.连线题回答集合 = new List<连线题回答>();
连线题回答 linkAnswer = new 连线题回答();
memberLinkAnswer.连线题回答集合.Add(linkAnswer);
testProblem.该题考试回答 = memberLinkAnswer;
}
testProblem.试题内容Json = content.Json字符串;
break;
}
if (testProblem .子小题集合!= null)
{
试卷大题中试题 subTestProblem = testProblem.子小题集合.FirstOrDefault(a => a.试题内容ID == content.ID);
if (subTestProblem != null)
{
subTestProblem.试题内容Json = content.Json字符串;
}
}
}
}
}
//回答的题中是复合题和多题干共选项题的小题集合
int hh = 0;
var listSubContent = listProblem.Where(a => a.父试题内容ID != null).OrderBy(a => a.本题在复合题中顺序)
.GroupBy(a => a.父试题内容ID).ToList();
for (int n = 0; n < listSubContent.Count; n++)
{
var aa = listSubContent[n].OrderBy(a => a.本题在复合题中顺序).ToList();
List<试卷大题中试题> listSubTestProblem = new List<试卷大题中试题>();
foreach (试题内容 content in aa)
{
//找到对应的试卷大题中试题
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
试卷大题中试题 testProblem = type.试卷大题中试题集合.Where(a => a.试题内容ID == content.ID).FirstOrDefault();
if (testProblem != null)
{
listSubTestProblem.Add(testProblem);
//去掉子小题
type.试卷大题中试题集合.Remove(testProblem);
break;
}
foreach (试卷大题中试题 TestProblem in type.试卷大题中试题集合)
{
if (TestProblem.子小题集合 != null)
{
试卷大题中试题 subTestProblem = TestProblem.子小题集合.Where(a => a.试题内容ID == content.ID).FirstOrDefault();
if (subTestProblem != null)
{
listSubTestProblem.Add(subTestProblem);
break;
}
}
}
}
}
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
if (testProblem.试题内容ID == listSubContent[n].Key)
{
testProblem.子小题集合 = listSubTestProblem;
hh = 1;
break;
}
}
if (hh == 1)
{
hh = 0;
break;
}
}
}
return 试卷内容;
}
public static void 替换Json的扛(试卷内容 testContent)
{
foreach (试卷中大题 type in testContent.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
if (testProblem.子小题集合 != null)
{
foreach (试卷大题中试题 subTestProblem in testProblem.子小题集合)
{
subTestProblem.试题内容Json = subTestProblem.试题内容Json.Replace("\"", "@2#3$4%5");
subTestProblem.试题内容Json = subTestProblem.试题内容Json.Replace("\\", "*8&7%5##");
}
}
testProblem.试题内容Json = testProblem.试题内容Json.Replace("\"", "@2#3$4%5");
testProblem.试题内容Json = testProblem.试题内容Json.Replace("\\", "*8&7%5##");
}
}
}
public static 试卷内容 去掉试卷中的试题的答案(试卷内容 试卷内容)
{
List<Guid> listProblemId = new List<Guid>();
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
listProblemId.Add(testProblem.试题内容ID);
}
}
List<试题内容> listProblem = 试题内容.试题内容查询.Where(a => listProblemId.Contains<Guid>(a.ID)).ToList();
foreach (试题内容 content in listProblem)
{
content.Json字符串 = 试题内容.去掉答案(content.Json字符串);
content.Json字符串 = "{\"content\":" + content.Json字符串 + ",\"outside\":null}";
}
//给试卷大题中试题的试题内容属性赋值
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
foreach (试题内容 content in listProblem)
{
if (testProblem.试题内容ID == content.ID)
{
//加一个null的回答，界面有需求
if (content.小题型Enum == 30)
{
考生连线题回答 memberLinkAnswer = new 考生连线题回答();
memberLinkAnswer.连线题回答集合 = new List<连线题回答>();
连线题回答 linkAnswer = new 连线题回答();
memberLinkAnswer.连线题回答集合.Add(linkAnswer);
testProblem.该题考试回答 = memberLinkAnswer;
}
testProblem.试题内容Json = content.Json字符串;
break;
}
}
}
}
//回答的题中是复合题和多题干共选项题的小题集合
int hh = 0;
var listSubContent = listProblem.Where(a => a.父试题内容ID != null).GroupBy(a => a.父试题内容ID).ToList();
for (int n = 0; n < listSubContent.Count; n++)
{
var aa = listSubContent[n].OrderBy(a => a.本题在复合题中顺序).ToList();
List<试卷大题中试题> listSubTestProblem = new List<试卷大题中试题>();
foreach (试题内容 content in aa)
{
//找到对应的试卷大题中试题
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
试卷大题中试题 testProblem = type.试卷大题中试题集合.Where(a => a.试题内容ID == content.ID).FirstOrDefault();
if (testProblem != null)
{
listSubTestProblem.Add(testProblem);
//去掉子小题
type.试卷大题中试题集合.Remove(testProblem);
break;
}
}
}
foreach (试卷中大题 type in 试卷内容.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
{
if (testProblem.试题内容ID == listSubContent[n].Key)
{
testProblem.子小题集合 = listSubTestProblem;
hh = 1;
break;
}
}
if (hh == 1)
{
hh = 0;
break;
}
}
}
return 试卷内容;
}
