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;
}
/// <summary>
/// 因有无限循环，故无法用Mapper函数转化类
/// </summary>
private static 试卷大题中试题 把试卷大题中试题WCF转化成试卷大题中试题(LoveKaoServiceReference.试卷大题中试题WCF testProblemWCF)
{
试卷大题中试题 testProblem = new 试卷大题中试题();
testProblem.ID = testProblemWCF.ID;
testProblem.每小题分值 = testProblemWCF.每小题分值;
testProblem.试卷中大题ID = testProblemWCF.试卷中大题ID;
testProblem.试题内容ID = testProblemWCF.试题内容ID;
testProblem.试题内容Json = testProblemWCF.试题内容Json;
testProblem.顺序 = testProblemWCF.顺序;
return testProblem;
}
/// <summary>
/// 因有无限循环，故无法用Mapper函数转化类
/// </summary>
private static LoveKaoServiceReference.试卷大题中试题 把试卷大题中试题转化成试卷大题中试题WCF(试卷大题中试题 testProblem)
{
LoveKaoServiceReference.试卷大题中试题 testProblemWCF = new LoveKaoServiceReference.试卷大题中试题();
testProblemWCF.ID = testProblem.ID;
testProblemWCF.每小题分值 = testProblem.每小题分值;
testProblemWCF.试卷中大题ID = testProblem.试卷中大题ID;
testProblemWCF.试题内容ID = testProblem.试题内容ID;
testProblemWCF.试题内容Json = testProblem.试题内容Json;
testProblemWCF.顺序 = testProblem.顺序;
return testProblemWCF;
}
public static string getMarkItem(试卷大题中试题 试题, 序号对象类 序号对象, int 子小题序号, bool 是否为小题, bool 是否显示答案)
{
string htmlHead = "", htmlCont = "", htmlFoot = "";
bool 是否为父级 = false;
int 小题型Enum = 试题内容.得到试题的小题型(试题.试题内容Json);
switch (小题型Enum)
{
case 11:
{
试题.试题内容 = 单选题.把Json转化成试题内容(试题.试题内容Json);
单选题 T11 = (单选题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T11.题干HTML, T11.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlCont += ViewLibContent.getT11(T11.选项列表);
htmlFoot += ViewLibKeyResolu.getT11(T11, 是否显示答案);
}
break;
case 12:
{
试题.试题内容 = 多选题.把Json转化成试题内容(试题.试题内容Json);
多选题 T12 = (多选题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T12.题干HTML, T12.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlCont += ViewLibContent.getT12(T12.选项列表);
htmlFoot += ViewLibKeyResolu.getT12(T12, 是否显示答案);
}
break;
case 13:
{
试题.试题内容 = 填空题.把Json转化成试题内容(试题.试题内容Json);
填空题 T13 = (填空题)试题.试题内容;
htmlHead += ViewLibHeader.getT13(T13.题干HTML, T13.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlFoot += ViewLibKeyResolu.getT13(T13, 是否显示答案);
}
break;
case 14:
{
试题.试题内容 = 选词填空.把Json转化成试题内容(试题.试题内容Json);
选词填空 T14 = (选词填空)试题.试题内容;
htmlHead += ViewLibHeader.getT14(T14.题干HTML, T14.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlCont += ViewLibContent.getT14(T14.选项组.选项集合);
htmlFoot += ViewLibKeyResolu.getT14(T14, 是否显示答案);
}
break;
case 15:
{
试题.试题内容 = 完形填空.把Json转化成试题内容(试题.试题内容Json);
完形填空 T15 = (完形填空)试题.试题内容;
htmlHead += ViewLibHeader.getT15(T15.题干HTML, T15.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlCont += ViewLibContent.getT15(T15.单选空格集合);
htmlFoot += ViewLibKeyResolu.getT15(T15, 是否显示答案);
}
break;
case 20:
{
试题.试题内容 = 判断题.把Json转化成试题内容(试题.试题内容Json);
判断题 T20 = (判断题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T20.题干HTML, T20.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlCont += ViewLibContent.getT20();
htmlFoot += ViewLibKeyResolu.getT20(T20, 是否显示答案);
}
break;
case 30:
{
试题.试题内容 = 连线题.把Json转化成试题内容(试题.试题内容Json);
连线题 T30 = (连线题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T30.题干HTML, T30.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlCont += ViewLibContent.getT30(T30);
htmlFoot += ViewLibKeyResolu.getT30(T30, 是否显示答案);
}
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
{
是否为父级 = true;
试题.试题内容 = 复合题.把Json转化成试题内容(试题.试题内容Json);
复合题 T40 = (复合题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T40.题干HTML, T40.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, true, 是否为小题);
htmlCont += ViewLibContent.getT40(试题.子小题集合, 序号对象, 是否显示答案);
htmlFoot += ViewLibKeyResolu.getT40(T40, 是否显示答案);
}
break;
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
{
试题.试题内容 = 问答题.把Json转化成试题内容(试题.试题内容Json);
问答题 T60 = (问答题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T60.题干HTML, T60.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
htmlFoot += ViewLibKeyResolu.getT60(T60, 是否显示答案);
}
break;
case 80:
{
是否为父级 = true;
试题.试题内容 = 多题干共选项题.把Json转化成试题内容(试题.试题内容Json);
多题干共选项题 T80 = (多题干共选项题)试题.试题内容;
htmlHead += ViewLibHeader.getNormal(T80.题干HTML, T80.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, true, 是否为小题);
htmlCont += ViewLibContent.getT80(T80, 试题.子小题集合, 序号对象, 是否显示答案);
htmlFoot += ViewLibKeyResolu.getT40(T80, 是否显示答案);
}
break;
}
return getItemHtml(htmlHead, htmlCont, htmlFoot, 是否为父级);
}
