public static 试题外部信息 把试题外部信息WCF转化成试题外部信息(LoveKaoServiceReference.试题外部信息 outsideWcf)
{
试题外部信息 outside = new 试题外部信息();
outside.ID = outsideWcf.ID;
outside.创建人ID = outsideWcf.创建人ID;
outside.创建时间 = outsideWcf.创建时间;
outside.难易度 = outsideWcf.初始难易度;
outside.试题查询内容 = outsideWcf.试题查询内容;
outside.试题类型 = 2;
outside.试题内容ID = outsideWcf.试题内容ID;
outside.试题显示内容 = outsideWcf.试题显示内容;
outside.试题状态Enum = 0;
outside.小题型Enum = outsideWcf.小题型Enum;
outside.最新更新时间 = outsideWcf.最新更新时间;
outside.分类列表 = new List<string>();
foreach (var sort in outsideWcf.分类列表)
{
outside.分类列表.Add(sort.分类名);
}
return outside;
}
/// <param name="类型">0保存本站试题，1保存下载试题，2保存下载试卷中试题</param>
private static Dictionary<Guid, Guid> 保存试题(int 题型, 试题外部信息 outside, string 试题Json, int 类型, List<string> 所属分类集合
, bool 是否只保存试题内容, LoveKaoExamEntities db)
{
Dictionary<Guid, Guid> dic = new Dictionary<Guid, Guid>();
switch (题型)
{
case 11:
{
单选题 single = 单选题.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, single, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
单选题.给单选题选项赋值新ID(single);
保存试题(outside, single, 所属分类集合, 试题Json, 1, db);
}
else
{
单选题.给单选题选项赋值新ID(single);
dic = 保存下载试卷中试题(outside, single, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 12:
{
多选题 multi = 多选题.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, multi, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
多选题.给多选题选项赋值新ID(multi);
保存试题(outside, multi, 所属分类集合, 试题Json, 1, db);
}
else
{
多选题.给多选题选项赋值新ID(multi);
dic = 保存下载试卷中试题(outside, multi, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 13:
{
填空题 fill = 填空题.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, fill, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
保存试题(outside, fill, 所属分类集合, 试题Json, 1, db);
}
else
{
dic = 保存下载试卷中试题(outside, fill, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 14:
{
选词填空 diction = 选词填空.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, diction, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
选词填空.给选词填空选项赋值新ID(diction);
保存试题(outside, diction, 所属分类集合, 试题Json, 1, db);
}
else
{
选词填空.给选词填空选项赋值新ID(diction);
dic = 保存下载试卷中试题(outside, diction, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 15:
{
完形填空 cloze = 完形填空.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, cloze, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
完形填空.给完形填空选项赋值新ID(cloze);
保存试题(outside, cloze, 所属分类集合, 试题Json, 1, db);
}
else
{
完形填空.给完形填空选项赋值新ID(cloze);
dic = 保存下载试卷中试题(outside, cloze, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 20:
{
判断题 judge = 判断题.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, judge, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
保存试题(outside, judge, 所属分类集合, 试题Json, 1, db);
}
else
{
dic = 保存下载试卷中试题(outside, judge, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 30:
{
连线题 link = 连线题.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, link, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
连线题.给连线题选项赋值新ID(link);
保存试题(outside, link, 所属分类集合, 试题Json, 1, db);
}
else
{
连线题.给连线题选项赋值新ID(link);
dic = 保存下载试卷中试题(outside, link, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
{
复合题 combination = 复合题.把Json转化成试题内容(试题Json);
foreach (试题内容 subCombination in combination.子小题集合)
{
subCombination.爱考网ID = subCombination.ID;
subCombination.ID = Guid.NewGuid();
dic.Add(subCombination.爱考网ID, subCombination.ID);
}
if (类型 == 0)
{
保存试题相关信息(0, outside, combination, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
保存试题(outside, combination, 所属分类集合, 试题Json, 1, db);
}
else
{
Dictionary<Guid,Guid> reDic = 保存下载试卷中试题(outside, combination, 所属分类集合, 试题Json, 是否只保存试题内容, db);
dic.Add(reDic.ElementAt(0).Key, reDic.ElementAt(0).Value);
}
break;
}
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
{
问答题 questionAnswer = 问答题.把Json转化成试题内容(试题Json);
if (类型 == 0)
{
保存试题相关信息(0, outside, questionAnswer, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
保存试题(outside, questionAnswer, 所属分类集合, 试题Json, 1, db);
}
else
{
dic = 保存下载试卷中试题(outside, questionAnswer, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
case 80:
{
多题干共选项题 common = 多题干共选项题.把Json转化成试题内容(试题Json);
foreach (试题内容 subcommon in common.子小题集合)
{
subcommon.爱考网ID = subcommon.ID;
subcommon.ID = Guid.NewGuid();
dic.Add(subcommon.爱考网ID, subcommon.ID);
}
if (类型 == 0)
{
foreach (题干 content in common.子小题集合)
{
content.爱考网ID = content.ID;
}
保存试题相关信息(0, outside, common, 所属分类集合, 试题Json, db);
}
else if (类型 == 1)
{
多题干共选项题.给多题干共选项题子小题内容和选项赋值新ID(common);
保存试题(outside, common, 所属分类集合, 试题Json, 1, db);
}
else
{
多题干共选项题.给多题干共选项题子小题内容和选项赋值新ID(common);
return 保存下载试卷中试题(outside, common, 所属分类集合, 试题Json, 是否只保存试题内容, db);
}
break;
}
}
return dic;
}
public static void 保存试题相关信息(int 类型,试题外部信息 problemOutside, 试题内容 problemContent, List<string> 分类列表, string 试题json字符串,LoveKaoExamEntities db)
{
List<string> listBelongSort = 所属分类.所属分类处理(分类列表, problemOutside.创建人ID, db);
problemOutside.最新更新时间 = DateTime.Now;
problemOutside.创建时间 = DateTime.Now;
problemContent.爱考网ID = problemContent.ID;
problemOutside.ID = problemContent.试题外部信息ID;
problemOutside.爱考网ID = problemOutside.ID;
保存试题(problemOutside, problemContent, 分类列表, 试题json字符串, 类型, db);
}
public static void 修改正常试题(试题外部信息 problemOutside, 试题内容 problemContent, List<string> 分类列表, string 试题json字符串)
{
//using (TransactionScope scope = new TransactionScope())
//{
JObject bo = JObject.Parse(试题json字符串);
var typeEnum = bo["outside"]["试题状态Enum"].ToString();
if (typeEnum == "4")
{
throw new Exception("正常试题不能改为草稿！");
}
LoveKaoExamEntities db = new LoveKaoExamEntities();
试题外部信息表 outsideTable = db.试题外部信息表.FirstOrDefault(a => a.ID == problemOutside.ID);
异常处理.删除修改权限判断(outsideTable.创建人ID);
if (outsideTable.试题状态Enum == 1)
{
throw new Exception("该试题已被删除！");
}
outsideTable.最新更新时间 = DateTime.Now;
outsideTable.难易度 = problemOutside.难易度;
if (problemContent != null)
{
outsideTable.试题查询内容 = problemContent.生成查询内容();
outsideTable.试题显示列 = problemContent.生成试题显示列();
outsideTable.试题内容ID = problemContent.ID;
}
List<string> listBelongSort = 所属分类.所属分类处理(分类列表, outsideTable.创建人ID, db);
所属分类.修改相关信息更新所属分类(listBelongSort, 0, outsideTable.创建人ID, outsideTable.ID, db);
if (problemContent != null)
{
string json字符串 = bo["content"].ToString();
problemContent.保存(db, json字符串);
}
if (problemContent == null)
{
db.SaveChanges();
}
// scope.Complete();
// }
}
public static Dictionary<Guid, Guid> 保存下载试卷中试题(试题外部信息 problemOutside,试题内容 试题内容, List<string> 所属分类集合, string 分站试题Json
,bool 是否只保存试题内容, LoveKaoExamEntities db)
{
Guid outsideLoveKaoId = 试题内容.试题外部信息ID;
Guid contentLoveKaoId = 试题内容.ID;
试题内容.ID = Guid.NewGuid();
试题内容.爱考网ID = contentLoveKaoId;
if (是否只保存试题内容 == false)
{
试题外部信息表 outside = new 试题外部信息表();
outside.ID = Guid.NewGuid();
outside.爱考网ID = outsideLoveKaoId;
outside.试题类型 = 2;
outside.创建人ID = 用户信息.CurrentUser.用户ID;
outside.创建时间 = problemOutside.创建时间;
outside.试题查询内容 = 试题内容.生成查询内容();
outside.试题内容ID = 试题内容.ID;
outside.试题显示列 = 试题内容.生成试题显示列();
outside.试题状态Enum = 0;
outside.小题型Enum = 试题内容.小题型Enum;
outside.最新更新时间 = problemOutside.最新更新时间;
outside.难易度 = 0.5m;
试题内容.试题外部信息ID = outside.ID;
db.试题外部信息表.AddObject(outside);
所属分类.添加相关信息所属分类(所属分类集合, outside.创建人ID, outside.ID, 0, db);
}
else
{
Guid outsideId = db.试题外部信息表.Where(a => a.创建人ID == 用户信息.CurrentUser.用户ID
&& a.爱考网ID == problemOutside.爱考网ID).First().ID;
试题内容.试题外部信息ID = outsideId;
}
JObject bo = JObject.Parse(分站试题Json);
string json字符串 = bo["content"].ToString();
试题内容.操作人ID = 用户信息.CurrentUser.用户ID;
试题内容.难易度 = 0.5m;
试题内容.保存(db, json字符串);
Dictionary<Guid, Guid> dic = new Dictionary<Guid, Guid>();
dic.Add(contentLoveKaoId, 试题内容.ID);
return dic;
}
public static Dictionary<Guid, Guid> 保存下载试卷中试题(试题外部信息 outside,string 试题Json, List<string> 所属分类集合,bool 是否只保存试题内容, LoveKaoExamEntities db)
{
int smallType = 试题内容.得到试题的小题型(试题Json);
return 保存试题(smallType, outside, 试题Json, 2, 所属分类集合, 是否只保存试题内容, db);
}
private static void 修改草稿试题(试题外部信息 problemOutside,试题内容 problemContent, List<string> 分类列表, string 试题json字符串)
{
//using (TransactionScope scope = new TransactionScope())
//{
LoveKaoExamEntities db = new LoveKaoExamEntities();
试题外部信息表 outsideTable = db.试题外部信息表.FirstOrDefault(a => a.ID == problemOutside.ID);
List<string> listBelongSort = 所属分类.所属分类处理(分类列表, outsideTable.创建人ID, db);
if (outsideTable.试题状态Enum == 1)
{
throw new Exception("该试题已被删除！");
}
//原试题内容ID
Guid oldContentId = outsideTable.试题内容ID;
outsideTable.试题状态Enum = problemOutside.试题状态Enum;
outsideTable.最新更新时间 = DateTime.Now;
if (problemContent != null)
{
outsideTable.试题查询内容 = problemContent.生成查询内容();
outsideTable.试题显示列 = problemContent.生成试题显示列();
outsideTable.试题内容ID = problemContent.ID;
}
所属分类.修改相关信息更新所属分类(listBelongSort, 0, outsideTable.创建人ID, outsideTable.ID, db);
if (problemContent != null)
{
outsideTable.试题内容ID = problemContent.ID;
试题内容表 dbContent = db.试题内容表.FirstOrDefault(a => a.ID == oldContentId);
List<自由题空格表> listSpace = db.自由题空格表.Where(a=>a.试题内容ID==oldContentId).ToList();
if (listSpace.Count != 0)
{
List<Guid> listGroupId = listSpace.Where(a => a.自由题选项组ID != null).GroupBy(a => a.自由题选项组ID).Select(a => a.Key.Value).ToList();
if (listGroupId.Count != 0)
{
List<自由题选项组表> listGroup = db.自由题选项组表.Where(a => listGroupId.Contains(a.ID)).ToList();
foreach (var group in listGroup)
{
db.自由题选项组表.DeleteObject(group);
}
}
}
db.试题内容表.DeleteObject(dbContent);
JObject bo = JObject.Parse(试题json字符串);
string json字符串 = bo["content"].ToString();
problemContent.保存(db, json字符串);
}
if (problemContent == null)
{
db.SaveChanges();
}
//scope.Complete();
//}
}
private static void 保存试题(试题外部信息 problemOutside, 试题内容 problemContent, List<string> 分类列表, string 试题json字符串,int 类型, LoveKaoExamEntities db)
{
if (类型 == 1)
{
problemOutside.创建人ID = 用户信息.CurrentUser.用户ID;
problemContent.操作人ID = 用户信息.CurrentUser.用户ID;
}
试题外部信息表 outside = new 试题外部信息表();
outside.ID = problemOutside.ID;
outside.爱考网ID = problemOutside.爱考网ID;
outside.试题类型 = problemOutside.试题类型;
outside.创建人ID = problemOutside.创建人ID;
outside.创建时间 = problemOutside.创建时间;
outside.最新更新时间 = problemOutside.最新更新时间;
outside.试题状态Enum = problemOutside.试题状态Enum;
outside.小题型Enum = problemOutside.小题型Enum;
if (类型 == 1)
{
Guid contentLoveKaoId = problemContent.ID;
problemContent.ID = Guid.NewGuid();
problemContent.爱考网ID = contentLoveKaoId;
problemContent.试题外部信息ID = problemOutside.ID;
}
outside.试题内容ID = problemContent.ID;
outside.试题查询内容 = problemContent.生成查询内容();
outside.试题显示列 = problemContent.生成试题显示列();
outside.难易度 = problemOutside.难易度;
using (TransactionScope scope = new TransactionScope())
{
db.试题外部信息表.AddObject(outside);
所属分类.添加相关信息所属分类(分类列表, outside.创建人ID, outside.ID, 0, db);
//db.SaveChanges();
JObject bo = JObject.Parse(试题json字符串);
string json字符串 = bo["content"].ToString();
problemContent.难易度 = outside.难易度;
problemContent.保存(db, json字符串);
scope.Complete();
}
}
/// <summary>
/// 返回试卷中所有试题外部信息ID，插入试卷引用的试题表有用，全部保存成功才插入
/// </summary>
public List<Guid> 保存下载试卷(LoveKaoExamEntities db, List<string> listBelongSort)
{
//全部试题的外部信息ID
List<Guid> listProblemOutsideId = new List<Guid>();
//新题的外部信息ID集合
List<Guid> listNewProblemOutsideId = new List<Guid>();
//把试卷中所有的试题内容ID,试题外部信息ID取出来
List<Guid> listProblemContentId = new List<Guid>();
foreach (试卷中大题 testType in this.试卷中大题集合)
{
foreach (试卷大题中试题 testProblem in testType.试卷大题中试题集合)
{
listProblemContentId.Add(testProblem.试题内容ID);
JObject bo = JObject.Parse(testProblem.试题内容Json);
string problemOutsideIdStr = bo["content"]["试题外部信息ID"].ToString();
problemOutsideIdStr = problemOutsideIdStr.Replace("\"", "");
Guid problemOutsideId = new Guid(problemOutsideIdStr);
listProblemOutsideId.Add(problemOutsideId);
string subJsonStr = string.Empty;
//若是复合题，则把子小题的Json加入到复合题的Json
if (testProblem.子小题集合 != null)
{
foreach (试卷大题中试题 subTestProblem in testProblem.子小题集合)
{
JObject subBo = JObject.Parse(subTestProblem.试题内容Json);
string subJson = subBo["content"].ToString();
subJsonStr += subJson+",";
}
if (subJsonStr.Length > 0)
{
subJsonStr = subJsonStr.Remove(subJsonStr.Length - 1);
}
}
subJsonStr = "\"子小题集合\":[" + subJsonStr + "]";
testProblem.试题内容Json = testProblem.试题内容Json
.Replace("" + testProblem.试题内容ID + "\",", "" + testProblem.试题内容ID + "\","+subJsonStr+",");
}
}
//查询已存在的试题，已存在的则不必插入了
List<试题内容表> listExistProblemContent = db.试题内容表.Where(a => listProblemContentId.Contains(a.爱考网ID)
&& a.操作人ID == 用户信息.CurrentUser.用户ID).ToList();
List<Guid> listExistProblemContentLoveKaoId = listExistProblemContent.Select(a => a.爱考网ID).ToList();
List<Guid> listNotExistProblemContentId = listProblemContentId.Except(listExistProblemContentLoveKaoId).ToList();
//查询已存在的试题外部信息ID，若试题外部信息存在，而试题内容不存在，则只需添加试题内容即可
List<Guid> listExistProblemOutsideId = db.试题外部信息表.Where(a => listProblemOutsideId.Contains(a.爱考网ID)
&&a.创建人ID==用户信息.CurrentUser.用户ID).Select(a => a.爱考网ID).ToList();
试卷内容表 testContent = new 试卷内容表();
testContent.ID = this.ID;
testContent.名称 = this.名称;
testContent.试卷外部信息ID = this.试卷外部信息ID;
testContent.说明 = "";
testContent.提交备注 = "";
testContent.提交人ID = 用户信息.CurrentUser.用户ID;
testContent.提交时间 = DateTime.Now;
//随机一个秒数，使创建时间不在同一秒
Random random = new Random();
DateTime time = DateTime.Now;
//记录随机的秒数，以避免重复
List<int> listSeconds = new List<int>();
for (int i = 0; i < this.试卷中大题集合.Count; i++)
{
试卷中大题表 type = new 试卷中大题表();
type.ID = Guid.NewGuid();
type.多选题评分策略 = 0;
type.名称 = this.试卷中大题集合[i].名称;
type.顺序 = Convert.ToByte(i);
type.说明 = "";
for (int j = 0; j < this.试卷中大题集合[i].试卷大题中试题集合.Count; j++)
{
int seconds = random.Next(0, 300);
if (listSeconds.Contains(seconds))
{
seconds = random.Next(0, 300);
}
listSeconds.Add(seconds);
试题外部信息 outside = new 试题外部信息();
outside.创建时间=time.AddSeconds(seconds);
outside.最新更新时间=time.AddSeconds(seconds);
试卷大题中试题表 problem = new 试卷大题中试题表();
problem.ID = Guid.NewGuid();
problem.每小题分值 = this.试卷中大题集合[i].试卷大题中试题集合[j].每小题分值;
string 试题Json = this.试卷中大题集合[i].试卷大题中试题集合[j].试题内容Json;
Guid contentId = this.试卷中大题集合[i].试卷大题中试题集合[j].试题内容ID;
JObject bo = JObject.Parse(试题Json);
string problemOutsideIdStr = bo["content"]["试题外部信息ID"].ToString();
problemOutsideIdStr = problemOutsideIdStr.Replace("\"", "");
Guid problemOutsideId = new Guid(problemOutsideIdStr);
//若是不存在的新题，插入新题
if (listNotExistProblemContentId.Contains(contentId))
{
Dictionary<Guid,Guid> dic=new Dictionary<Guid,Guid>();
listNewProblemOutsideId.Add(problemOutsideId);
试题Json = 试题外部信息.替换试题图片路径(试题Json,用户信息.CurrentUser.用户名);
if (listExistProblemOutsideId.Contains(problemOutsideId))
{
outside.爱考网ID = problemOutsideId;
dic=试题外部信息.保存下载试卷中试题(outside, 试题Json, listBelongSort, true, db);
contentId = dic.Where(a => a.Key == contentId).First().Value;
}
else
{
dic =试题外部信息.保存下载试卷中试题(outside, 试题Json, listBelongSort, false, db);
contentId = dic.Where(a => a.Key == contentId).First().Value;
}
if (this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合 != null)
{
for (int m = 0; m < this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合.Count; m++)
{
Guid subContentId = dic.Where(a => a.Key == this.试卷中大题集合[i].试卷大题中试题集合[j]
.子小题集合[m].试题内容ID).First().Value;
试卷大题中试题表 subProblem = new 试卷大题中试题表();
subProblem.ID = Guid.NewGuid();
subProblem.每小题分值 = this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合[m].每小题分值;
subProblem.试题内容ID = subContentId;
subProblem.顺序 = Convert.ToByte(m);
type.试卷大题中试题表.Add(subProblem);
}
}
listNotExistProblemContentId.Remove(contentId);
}
else
{
contentId = listExistProblemContent.First(a => a.爱考网ID == contentId).ID;
}
problem.试题内容ID = contentId;
problem.顺序 = Convert.ToByte(j);
type.试卷大题中试题表.Add(problem);
}
testContent.试卷中大题表.Add(type);
}
db.试卷内容表.AddObject(testContent);
db.SaveChanges();
return listProblemOutsideId;
}
