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="类型">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();
}
}
/// <summary>
/// 因试卷大题中试题有无限循环，故无法用Mapper函数转化
/// </summary>
private static LoveKaoServiceReference.试卷外部信息 把试卷外部信息转化成试卷外部信息WCF(试卷外部信息 outside)
{
LoveKaoServiceReference.试卷外部信息 outsideWCF = new LoveKaoServiceReference.试卷外部信息();
outsideWCF.ID = outside.爱考网ID;
outsideWCF.创建人ID = outside.创建人ID;
outsideWCF.分类列表 = new List<LoveKaoServiceReference.所属分类>();
foreach (string belongSort in outside.分类列表)
{
outsideWCF.分类列表.Add(所属分类.把所属分类转化为所属分类WCF(belongSort,outside.ID));
}
outsideWCF.名称 = outside.名称;
outsideWCF.试卷内容ID = outside.试卷内容ID;
outsideWCF.说明 = outside.说明;
outsideWCF.总分 = outside.总分;
return outsideWCF;
}
/// <summary>
/// 因试卷大题中试题有无限循环，故无法用Mapper函数转化
/// </summary>
private static 试卷外部信息 把试卷外部信息WCF转化成试卷外部信息(LoveKaoServiceReference.试卷外部信息WCF outsideWCF)
{
试卷外部信息 outside = new 试卷外部信息();
outside.ID = outsideWCF.ID;
outside.创建人ID = outsideWCF.创建人ID;
outside.分类列表 = new List<string>();
foreach (LoveKaoServiceReference.所属分类 belongSort in outsideWCF.分类列表)
{
outside.分类列表.Add(所属分类.把所属分类WCF转化成所属分类(belongSort).分类名);
}
outside.名称 = outsideWCF.名称;
outside.试卷内容ID = outsideWCF.试卷内容ID;
outside.说明 = outsideWCF.说明;
outside.总分 = outsideWCF.总分;
return outside;
}
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;
}
