public static void 更新考生范围(Guid 相关ID, List<Guid> 考生ID集合, LoveKaoExamEntities db)
{
List<考生范围表> listOldArea = db.考生范围表.Where(a=>a.相关ID==相关ID).ToList();
List<Guid> listOldAreaId = listOldArea.Select(a => a.考生ID).ToList();
//没变，则不作任何操作，若有变，则先删除原来的，再插入新的
List<Guid> listNewId = listOldAreaId.Except(考生ID集合).ToList();
if (listOldAreaId.Count != 考生ID集合.Count || listOldAreaId.Count == 考生ID集合.Count && listNewId.Count != 0)
{
foreach (var oldArea in listOldArea)
{
db.考生范围表.DeleteObject(oldArea);
}
List<考生范围表> listNewArea = new List<考生范围表>();
foreach (Guid examineeId in 考生ID集合)
{
考生范围表 area = new 考生范围表();
area.ID = Guid.NewGuid();
area.相关ID = 相关ID;
area.考生ID = examineeId;
listNewArea.Add(area);
}
foreach (var newArea in listNewArea)
{
db.考生范围表.AddObject(newArea);
}
}
}
public static void 修改相关信息更新所属分类(List<string> 分类列表, byte 相关类型, Guid memberId, Guid 相关ID, LoveKaoExamEntities db)
{
if (分类列表.Count > 0)
{
//把原来的删除，再插入新的
List<所属分类表> listSort = db.所属分类表.Where(a=>a.相关信息ID==相关ID).ToList();
foreach (var sort in listSort)
{
db.所属分类表.DeleteObject(sort);
}
db.SaveChanges();
List<所属分类表> listNewSort = new List<所属分类表>();
foreach (string sort in 分类列表)
{
所属分类表 sortTable = new 所属分类表();
sortTable.ID = Guid.NewGuid();
sortTable.操作人ID = memberId;
sortTable.操作时间 = DateTime.Now;
sortTable.分类名 = sort;
sortTable.相关类型 = 相关类型;
sortTable.相关信息ID = 相关ID;
listNewSort.Add(sortTable);
}
foreach (var newSort in listNewSort)
{
db.所属分类表.DeleteObject(newSort);
}
db.SaveChanges();
}
}
public static void 删除考官(Guid 考官ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
用户表 user = db.用户表.First(a => a.ID == 考官ID);
db.用户表.DeleteObject(user);
db.SaveChanges();
}
public static void 删除部门(Guid 部门ID)
{
异常处理.删除修改权限判断();
LoveKaoExamEntities db = new LoveKaoExamEntities();
部门表 department = db.部门表.First(a => a.ID == 部门ID);
db.部门表.DeleteObject(department);
db.SaveChanges();
}
public static void 提交保存批改(string 批改Json)
{
考生做过的试卷 doneTest = 考生做过的试卷.把Json转化成考生做过的试卷(批改Json);
List<试卷大题中试题> listTestProblem=new List<试卷大题中试题>();
foreach(试卷中大题 testType in doneTest.考试设置.试卷内容.试卷中大题集合)
{
listTestProblem.AddRange(testType.试卷大题中试题集合);
}
LoveKaoExamEntities db = new LoveKaoExamEntities();
考生做过的试卷表 memberDoneTest = db.考生做过的试卷表.FirstOrDefault(a=>a.ID==doneTest.ID);
//更新考生得分
List<考生考试回答表> listMemberAnswer = db.考生考试回答表.Where(a => a.考生做过的试卷ID == doneTest.ID)
.ToList();
foreach (考生考试回答表 memberAnswer in listMemberAnswer)
{
memberAnswer.该题的得分 = listTestProblem.Where(a => a.ID == memberAnswer.试卷大题中试题ID).First()
.该题考试回答.该题的得分;
}
//更新批改状态
memberDoneTest.批改状态 = doneTest.批改状态类型;
if (doneTest.批改状态类型>0)
{
memberDoneTest.批改时间 = DateTime.Now;
}
//计算客观题总得分
//List<Guid> listContentId = listTestProblem.Select(a => a.试题内容ID).ToList();
//List<Guid> listObjectiveContentId = db.试题内容表.Where(a => listContentId.Contains(a.ID)
// && (a.小题型Enum < 31 || a.小题型Enum == 8011)).Select(a => a.ID).ToList();
//memberDoneTest.客观题得分 = listTestProblem.Where(a => listObjectiveContentId.Contains(a.试题内容ID))
// .Sum(a => a.该题考试回答.该题的得分.Value);
List<Guid> listTestProblemID = listMemberAnswer.Select(a => a.试卷大题中试题ID).ToList();
List<试卷大题中试题表> listTestProblemTable = db.试卷大题中试题表.Where(a => listTestProblemID.Contains(a.ID))
.ToList();
List<Guid> listProblemContentID = listTestProblemTable.Select(a => a.试题内容ID).ToList();
//是客观题的试题内容ID
List<Guid> listContentID = db.试题内容表.Where(a => listProblemContentID.Contains(a.ID)
&& (a.小题型Enum < 31 || a.小题型Enum == 8011)).Select(a => a.ID).ToList();
//是客观题的试卷大题中试题ID
List<Guid> listTestTypeProblemID = listTestProblemTable.Where(a => listContentID.Contains(a.试题内容ID))
.Select(a=>a.ID).ToList();
memberDoneTest.客观题得分 = listMemberAnswer.Where(a => listTestTypeProblemID.Contains(a.试卷大题中试题ID))
.Sum(a => a.该题的得分.Value);
//主观题得分
//memberDoneTest.主观题得分 = listTestProblem.Sum(a => a.该题考试回答.该题的得分.Value) - memberDoneTest.客观题得分;
memberDoneTest.主观题得分 = listMemberAnswer.Sum(a => a.该题的得分.Value) - memberDoneTest.客观题得分;
db.SaveChanges();
}
public override void 保存考生考试回答(LoveKaoExamEntities db)
{
考生单选题回答表 singleAnswer = new 考生单选题回答表();
singleAnswer.回答的选项ID = this.回答的选项ID;
考生考试回答表 memberTestAnswer = new 考生考试回答表();
memberTestAnswer.ID = Guid.NewGuid();
memberTestAnswer.该题的得分 = this.该题的得分;
memberTestAnswer.该题的用时 = this.该题的用时;
memberTestAnswer.考生做过的试卷ID = this.考生做过的试卷ID;
memberTestAnswer.评语 = "";
memberTestAnswer.试卷大题中试题ID = this.试卷大题中试题ID;
memberTestAnswer.考生单选题回答表 = singleAnswer;
db.考生考试回答表.AddObject(memberTestAnswer);
}
/// <summary>
/// 返回0修改成功,1部门名已存在，不能修改
/// </summary>
public static int 修改部门(部门 部门)
{
异常处理.删除修改权限判断();
LoveKaoExamEntities db = new LoveKaoExamEntities();
if (db.部门表.Any(a => a.名称 == 部门.名称) == true)
{
return 1;
}
部门表 department = db.部门表.FirstOrDefault(a=>a.ID==部门.ID);
department.名称 = 部门.名称;
department.上级部门ID = 部门.上级部门ID;
department.添加时间 = DateTime.Now;
db.SaveChanges();
return 0;
}
public override void 保存考生考试回答(LoveKaoExamEntities db)
{
考生问答题回答表 questionAnswer = new 考生问答题回答表();
questionAnswer.回答的内容 = this.回答答案;
考生考试回答表 memberTestAnswer = new 考生考试回答表();
memberTestAnswer.ID = Guid.NewGuid();
memberTestAnswer.该题的得分 = this.该题的得分;
memberTestAnswer.该题的用时 = this.该题的用时;
memberTestAnswer.考生做过的试卷ID = this.考生做过的试卷ID;
memberTestAnswer.评语 = "";
memberTestAnswer.试卷大题中试题ID = this.试卷大题中试题ID;
memberTestAnswer.考生问答题回答表 = questionAnswer;
db.考生考试回答表.AddObject(memberTestAnswer);
}
public static 上传下载信息 得到上传下载信息(Guid 用户ID)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
上传下载信息 information = new 上传下载信息();
绑定账号表 bind = db.绑定账号表.Where(a=>a.本地账号ID==用户ID).FirstOrDefault();
if (bind == null)
{
information.可下载试题数量 = 100;
information.是否绑定账号 = false;
}
else
{
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result;
string Json = client.得到上传下载信息(out result, bind.爱考网账号, bind.爱考网密码);
client.Close();
if (result == 1)
{
异常处理.抛出异常(1);
}
else if (result == 2)
{
异常处理.抛出异常(2);
}
if (String.IsNullOrEmpty(Json))
{
information.可下载试题数量 = 100;
information.是否绑定账号 = false;
}
else
{
information = 把Json转化成上传下载信息(Json);
information.是否绑定账号 = true;
}
}
return information;
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
public override void 保存考生考试回答(LoveKaoExamEntities db)
{
考生考试回答表 memberTestAnswer = new 考生考试回答表();
memberTestAnswer.ID = Guid.NewGuid();
memberTestAnswer.该题的得分 = this.该题的得分;
memberTestAnswer.该题的用时 = this.该题的用时;
memberTestAnswer.考生做过的试卷ID = this.考生做过的试卷ID;
memberTestAnswer.评语 = "";
memberTestAnswer.试卷大题中试题ID = this.试卷大题中试题ID;
for (int i = 0; i < this.回答的选项ID集合.Count; i++)
{
考生多选题回答表 multiAnswer = new 考生多选题回答表();
multiAnswer.ID = Guid.NewGuid();
multiAnswer.回答的选项ID = this.回答的选项ID集合[i];
memberTestAnswer.考生多选题回答表.Add(multiAnswer);
}
db.考生考试回答表.AddObject(memberTestAnswer);
}
public override void 保存考生考试回答(LoveKaoExamEntities db)
{
考生考试回答表 memberTestAnswer = new 考生考试回答表();
memberTestAnswer.ID = Guid.NewGuid();
memberTestAnswer.该题的得分 = this.该题的得分;
memberTestAnswer.该题的用时 = this.该题的用时;
memberTestAnswer.考生做过的试卷ID = this.考生做过的试卷ID;
memberTestAnswer.评语 = "";
memberTestAnswer.试卷大题中试题ID = this.试卷大题中试题ID;
for (int i = 0; i < this.连线题回答集合.Count; i++)
{
考生连线题回答表 linkAnswer = new 考生连线题回答表();
linkAnswer.ID = Guid.NewGuid();
linkAnswer.回答的选项ID = this.连线题回答集合[i].回答的右选项ID;
linkAnswer.连线题左边小题ID = this.连线题回答集合[i].回答的左选项ID;
memberTestAnswer.考生连线题回答表.Add(linkAnswer);
}
db.考生考试回答表.AddObject(memberTestAnswer);
}
public override void 保存考生考试回答(LoveKaoExamEntities db)
{
考生考试回答表 memberTestAnswer = new 考生考试回答表();
memberTestAnswer.ID = Guid.NewGuid();
memberTestAnswer.该题的得分 = this.该题的得分;
memberTestAnswer.该题的用时 = this.该题的用时;
memberTestAnswer.考生做过的试卷ID = this.考生做过的试卷ID;
memberTestAnswer.评语 = "";
memberTestAnswer.试卷大题中试题ID = this.试卷大题中试题ID;
for (int i = 0; i < this.选词空格回答集合.Count; i++)
{
考生选词填空回答表 spaceAnswer = new 考生选词填空回答表();
spaceAnswer.ID = Guid.NewGuid();
spaceAnswer.该空ID = this.选词空格回答集合[i].空格ID;
spaceAnswer.该空的回答ID = this.选词空格回答集合[i].回答的选项ID;
memberTestAnswer.考生选词填空回答表.Add(spaceAnswer);
}
db.考生考试回答表.AddObject(memberTestAnswer);
}
public static List<试卷外部信息> 得到上传试卷列表(string 关键字, int 第几页, int 页的大小, out int 返回总条数)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
IQueryable<试卷外部信息表> query = db.试卷外部信息表.Where(a => a.创建人ID == 用户信息.CurrentUser.用户ID
&& a.试卷状态Enum == 0&&a.试卷类型<2);
if (String.IsNullOrEmpty(关键字) == false)
{
关键字 = 关键字.TrimStart();
关键字 = 关键字.TrimEnd();
//按试卷名查询
query = query.Where(a => a.名称.Contains(关键字));
//如果是分类，再按分类查询，并合并结果
if (db.系统分类表.Any(a => a.分类名称 == 关键字) == true)
{
IQueryable<试卷外部信息表> queryBySort = from outside in db.试卷外部信息表
join belongSort in db.所属分类表
on outside.ID equals belongSort.相关信息ID
where belongSort.分类名 == 关键字
&& outside.创建人ID == 用户信息.CurrentUser.用户ID
&& outside.试卷状态Enum == 0 && outside.试卷类型 < 2
select outside;
query = query.Union(queryBySort);
}
}
返回总条数 = query.Distinct().Count();
List<试卷外部信息表> list = query.Distinct().OrderByDescending(a => a.创建时间)
.Skip(第几页 * 页的大小).Take(页的大小).ToList();
List<试卷外部信息> listOutside = 把试卷外部信息表集合转化为试卷外部信息集合(list);
List<Guid> listProblemOutsideId = new List<Guid>();
//计算试题总数
List<Guid> listContentId = listOutside.Select(a => a.试卷内容ID).ToList();
List<试卷中大题表> listTestType = db.试卷中大题表.Where(a => listContentId.Contains(a.试卷内容ID)).ToList();
List<Guid> listTestTypeId = listTestType.Select(a => a.ID).ToList();
List<试卷大题中试题表> listTestProblem = db.试卷大题中试题表.Where(a => listTestTypeId.Contains(a.试卷中大题ID))
.ToList();
List<Guid> listProblemContentId = listTestProblem.Select(a => a.试题内容ID).ToList();
List<试题内容表> listProblemContent = db.试题内容表.Where(a => listProblemContentId.Contains(a.ID)).ToList();
foreach (试卷外部信息 outside in listOutside)
{
List<试卷中大题表> listThisTestType = listTestType.Where(a => a.试卷内容ID == outside.试卷内容ID).ToList();
List<Guid> listThisTestTypeId = listThisTestType.Select(a => a.ID).ToList();
List<试卷大题中试题表> listThisTestProblem = listTestProblem.Where(a => listThisTestTypeId
.Contains(a.试卷中大题ID)).ToList();
List<Guid> listThisProblemContentId = listThisTestProblem.Select(a => a.试题内容ID).ToList();
outside.试题外部信息ID集合 = listProblemContent.Where(a => listThisProblemContentId.Contains(a.ID))
.Select(a => a.试题外部信息ID).Distinct().ToList();
outside.试题总数 = outside.试题外部信息ID集合.Count;
listProblemOutsideId.AddRange(outside.试题外部信息ID集合);
}
//计算已上传试题个数
List<试题外部信息表> listOutsideTable = db.试题外部信息表.Where(a =>a.试题类型>0
&& a.创建人ID == 用户信息.CurrentUser.用户ID).ToList();
foreach (var outside in listOutside)
{
int count = listOutsideTable.Where(a => outside.试题外部信息ID集合.Contains(a.爱考网ID)).Count();
outside.已上传试题个数 = count;
}
return listOutside;
}
public static void 删除试卷(Guid 试卷外部信息ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
试卷外部信息表 outside = db.试卷外部信息表.FirstOrDefault(a => a.ID == 试卷外部信息ID);
异常处理.删除修改权限判断(outside.创建人ID);
outside.试卷状态Enum = 1;
//若设置了考试或练习，则删除
List<Guid> listContentId = db.试卷内容表.Where(a=>a.试卷外部信息ID==试卷外部信息ID).Select(a => a.ID).ToList();
List<Guid> listExamSetId = db.考试设置表.Where(a => listContentId.Contains(a.试卷内容ID)).Select(a => a.ID).ToList();
foreach (Guid examSetId in listExamSetId)
{
考试设置.删除考试设置(examSetId);
}
List<Guid> listExerciseSetId = db.练习设置表.Where(a => listContentId.Contains(a.试卷内容ID)).Select(a => a.试卷内容ID).ToList();
foreach (Guid exerciseSetId in listExerciseSetId)
{
练习设置.删除练习设置(exerciseSetId);
}
db.SaveChanges();
}
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();
}
}
public static void 给考试设置列表赋值试卷外部信息属性(List<考试设置> listExamSet)
{
LoveKaoExamEntities db=new LoveKaoExamEntities();
List<Guid> listContentId = listExamSet.Select(a => a.试卷内容ID).ToList();
List<Guid> listOutsideId = db.试卷内容表.Where(a => listContentId.Contains(a.ID))
.Select(a => a.试卷外部信息ID).ToList();
List<试卷外部信息> listOutside = 试卷外部信息.试卷外部信息查询.Where(a => listOutsideId.Contains(a.ID)).ToList();
//给分类列表属性赋值
List<所属分类> listBelongSort = 所属分类.所属分类查询.Where(a => listOutsideId.Contains(a.相关ID)).ToList();
foreach (试卷外部信息 outside in listOutside)
{
outside.分类列表 = listBelongSort.Where(a => a.相关ID == outside.ID).Select(a=>a.分类名).ToList();
}
//给试卷外部信息属性赋值
foreach (考试设置 examSet in listExamSet)
{
试卷外部信息 outside=listOutside.FirstOrDefault(a => a.试卷内容ID == examSet.试卷内容ID);
if (outside != null)
{
examSet.试卷外部信息 = outside;
}
}
}
/// <param name="类型">0全部，1自己出的，2草稿,3已上传的，4下载的</param>
public static List<试卷外部信息> 得到某考官试卷(string 试卷名, Guid 考官ID,int 类型, int 第几页, int 页的大小, out int 返回总条数)
{
IQueryable<试卷外部信息> query =试卷外部信息查询.Where(a => a.创建人ID == 考官ID);
switch (类型)
{
case 0:
{
query = query.Where(a => a.试卷状态Enum != 1);
break;
}
case 1:
{
query = query.Where(a => a.试卷状态Enum == 0 && a.试卷类型 < 2);
break;
}
case 2:
{
query = query.Where(a => a.试卷状态Enum == 4);
break;
}
case 3:
{
query = query.Where(a => a.试卷状态Enum == 0 && a.试卷类型 == 1);
break;
}
case 4:
{
query = query.Where(a => a.试卷状态Enum == 0 && a.试卷类型 == 2);
break;
}
}
if (String.IsNullOrEmpty(试卷名) == false)
{
query = query.Where(a => a.名称.Contains(试卷名));
}
返回总条数 = query.Count();
List<试卷外部信息> list = query.OrderByDescending(a => a.创建时间).Skip(第几页 * 页的大小).Take(页的大小).ToList();
//给已组织考试次数，已组织练习次数属性赋值
LoveKaoExamEntities db=new LoveKaoExamEntities();
List<Guid> listOutsideId=list.Select(a=>a.ID).ToList();
List<试卷内容表> listContent = db.试卷内容表.Where(a => listOutsideId.Contains(a.试卷外部信息ID)).ToList();
List<Guid> listContentId = listContent.Select(a => a.ID).ToList();
List<Guid> listExamId = db.考试设置表.Where(a => listContentId.Contains(a.试卷内容ID)
&& a.是否删除 == false).Select(a => a.试卷内容ID).ToList();
List<Guid> listExerciseId = db.练习设置表.Where(a => listContentId.Contains(a.试卷内容ID)
&& a.是否删除 == false).Select(a => a.试卷内容ID).ToList();
foreach (试卷外部信息 outside in list)
{
List<Guid> listThisContentId = listContent.Where(a => a.试卷外部信息ID == outside.ID).Select(a => a.ID).ToList();
outside.已组织考试次数 = listExamId.Where(a =>listThisContentId.Contains(a)).Count();
outside.已组织练习次数 = listExerciseId.Where(a => listThisContentId.Contains(a)).Count();
}
return list;
}
public override void 保存(LoveKaoExamEntities db, string Json字符串)
{
试题内容表 problemContent = this.类映射表赋值();
db.试题内容表.AddObject(problemContent);
db.SaveChanges();
}
public static List<考试排名> 得到考试排名(string 关键字,Guid 考试设置ID, Guid 考生ID, int 第几页, int 页的大小, out int 返回总条数,out LKPageException 异常信息)
{
考试设置 examSet = 考试设置.考试设置查询.Where(a => a.ID == 考试设置ID).First();
if (examSet.是否公布考试结果 == false)
{
异常信息 = new LKPageException(异常处理.得到异常信息(10));
返回总条数 = 0;
return new List<考试排名>();
}
if (DateTime.Now < examSet.考试结束时间)
{
异常信息 = new LKPageException(异常处理.得到异常信息(9));
返回总条数 = 0;
return new List<考试排名>();
}
//先查询出与该考生同班级的所有考生
LoveKaoExamEntities db = new LoveKaoExamEntities();
用户表 user = db.用户表.FirstOrDefault(a=>a.ID==考生ID);
List<Guid> listUserId = db.用户表.Where(a => a.部门ID == user.部门ID).Select(a => a.ID).ToList();
//查询这些考生的排名
List<考试排名> listAllRank=考试排名查询.Where(a => listUserId.Contains(a.考生ID) && a.考试设置ID == 考试设置ID).ToList();
if (listAllRank.Any(a => a.考生ID == 考生ID) == false)
{
异常信息 = new LKPageException(异常处理.得到异常信息(11));
返回总条数 = 0;
return new List<考试排名>();
}
listAllRank = listAllRank.OrderByDescending(a => a.总得分).ToList();
if (listAllRank.Count > 0)
{
//赋值名次，考生，考试设置，及格情况，参考书人数，我的排名属性
for (int i = 0; i < listAllRank.Count; i++)
{
listAllRank[i].名次 = i + 1;
}
List<Guid> listStudentId = listAllRank.Select(a => a.考生ID).ToList();
List<用户> listStudent = 用户.用户查询.Where(a => listStudentId.Contains(a.ID)).ToList();
Guid 试卷内容ID=listAllRank[0].考试设置表.试卷内容ID;
试卷内容 test = 试卷内容.试卷内容查询.Where(a => a.ID == 试卷内容ID).First();
//查询我的排名
int myRank = listAllRank.Where(a => a.考生ID == 考生ID).First().名次;
foreach (考试排名 rank in listAllRank)
{
rank.考试设置 = 考试设置.把考试设置表转化成考试设置(rank.考试设置表);
rank.考试设置.试卷内容 = test;
rank.考生 = listStudent.First(a => a.ID == rank.考生ID);
if (rank.总得分 / test.总分 * 100 < rank.考试设置表.及格条件)
{
rank.及格情况 = "不及格";
}
else
{
rank.及格情况 = "及格";
}
rank.参考人数 = listAllRank.Count;
rank.我的排名 = myRank;
}
}
if (!String.IsNullOrEmpty(关键字))
{
listAllRank = listAllRank.Where(a => a.考生.编号.Contains(关键字) || a.考生.姓名.Contains(关键字)).ToList();
}
返回总条数 = listAllRank.Count;
List<考试排名> listRank = listAllRank.Skip(第几页 * 页的大小).Take(页的大小).ToList();
异常信息 = new LKPageException();
return listAllRank;
}
public static DateTime 得到某试卷最后一次组织考试结束时间(Guid 试卷内容ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
return db.考试设置表.Where(a => a.试卷内容ID == 试卷内容ID).OrderByDescending(a => a.考试结束时间)
.Select(a => a.考试结束时间).FirstOrDefault();
}
/// <summary>
/// 返回已存在的编号集合
/// </summary>
/// <param name="fs">Excel文件流</param>
/// <param name="type">0学生，1员工</param>
/// <returns></returns>
public static List<string> 导入excel(Stream stream, int type)
{
try
{
HSSFWorkbook workBook = new HSSFWorkbook(stream);
HSSFSheet sheet = (HSSFSheet)workBook.GetSheetAt(0);
//判断是否符合格式
Cell cell0 = sheet.GetRow(0).GetCell(0);
if (cell0 == null)
{
抛出格式不符异常();
}
string cell0Value = 得到流中列值(cell0.CellType, sheet, 0, 0);
if (cell0Value != "学号" && cell0Value != "编号")
{
抛出格式不符异常();
}
Cell cell1 = sheet.GetRow(0).GetCell(1);
if (cell1 == null)
{
抛出格式不符异常();
}
string cell1Value = 得到流中列值(cell1.CellType, sheet, 0, 1);
if (cell1Value != "姓名")
{
抛出格式不符异常();
}
Cell cell2 = sheet.GetRow(0).GetCell(2);
if (cell2 == null)
{
抛出格式不符异常();
}
string cell2Value = 得到流中列值(cell2.CellType, sheet, 0, 2);
if (cell2Value != "性别")
{
抛出格式不符异常();
}
Cell cell3 = sheet.GetRow(0).GetCell(3);
if (cell3 == null)
{
抛出格式不符异常();
}
string cell3Value = 得到流中列值(cell1.CellType, sheet, 0, 3);
if (cell3Value != "班级"&&cell3Value!="部门")
{
抛出格式不符异常();
}
LoveKaoExamEntities db = new LoveKaoExamEntities();
//取出班级,学号
List<string> listClassName = new List<string>();
List<string> listNum = new List<string>();
for (int k = sheet.FirstRowNum + 1; k < sheet.LastRowNum + 1; k++)
{
string className = string.Empty;
string classType = string.Empty;
if (type == 0)
{
classType = "班级";
}
else
{
classType = "部门";
}
Cell cellClass = sheet.GetRow(k).GetCell(3);
if (cellClass == null)
{
throw new Exception("第" + k + "行" + classType + "未填写，请先填写，然后再导入！");
}
CellType classCellType = cellClass.CellType;
className = 得到流中列值(classCellType, sheet, k, 3);
if (className.Length > 16)
{
throw new Exception("第" + k + "行" + classType + "名称长度大于16，请填写16以内的名称！");
}
string num = string.Empty;
string numType = string.Empty;
if (type == 0)
{
numType = "学号";
}
else
{
numType = "编号";
}
Cell cellNum=sheet.GetRow(k).GetCell(0);
if (cellNum == null)
{
throw new Exception("第" + k + "行" + numType + "未填写，请先填写，然后再导入！");
}
CellType numCellType = cellNum.CellType;
num = 得到流中列值(numCellType, sheet, k, 0);
if (num.Length < 4 || num.Length > 16)
{
throw new Exception("第" + k + "行" + numType + "长度不符，必须是4到16位！");
}
else if (Regex.IsMatch(num, @"[^a-zA-Z0-9]"))
{
throw new Exception("第" + k + "行" + numType + "格式不符，" + numType + "必须只含数字或字母！");
}
listClassName.Add(className);
listNum.Add(num);
}
//有不存在的班级，则先添加
listClassName = listClassName.Distinct().ToList();
List<string> listExistClassName = db.部门表.Where(a => listClassName.Contains(a.名称))
.Select(a => a.名称).ToList();
List<string> listNotExistClassName = listClassName.Except(listExistClassName).ToList();
foreach (string className in listNotExistClassName)
{
部门表 department = new 部门表();
department.ID = Guid.NewGuid();
department.名称 = className;
department.添加人ID = 用户信息.CurrentUser.用户ID;
department.添加时间 = DateTime.Now;
db.部门表.AddObject(department);
}
db.SaveChanges();
//已存在的学生则不再导入
List<string> listExistNum = db.用户表.Where(a => listNum.Contains(a.编号)).Select(a => a.编号).ToList();
List<string> listNotExistNum = listNum.Except(listExistNum).ToList();
List<部门表> listClass = db.部门表.Where(a => listClassName.Contains(a.名称)).ToList();
for (int i = sheet.FirstRowNum+1; i < sheet.LastRowNum+1; i++)
{
CellType numCellType = sheet.GetRow(i).GetCell(0).CellType;
string stuNum = 得到流中列值(numCellType, sheet, i, 0);
if (listNotExistNum.Contains(stuNum))
{
Cell cellName=sheet.GetRow(i).GetCell(1);
if (cellName == null)
{
throw new Exception("第" + i + "行姓名未填写，请先填写，然后再导入！");
}
CellType nameCellType = cellName.CellType;
string name = 得到流中列值(nameCellType, sheet, i, 1);
if (name.Length < 2 || name.Length > 8)
{
throw new Exception("第" + i + "行姓名长度不符，必须是2到8位！");
}
else if (Regex.IsMatch(name, @"[^a-zA-Z\u4e00-\u9fa5]"))
{
throw new Exception("第" + i + "行姓名格式不符，姓名必须只含中文或字母！");
}
用户表 user = new 用户表();
user.ID = Guid.NewGuid();
user.编号 = stuNum;
user.姓名 = name;
user.密码 = stuNum;
Cell cellSex=sheet.GetRow(i).GetCell(2);
if (cellSex == null)
{
throw new Exception("第" + i + "行性别未填写，请先填写，然后再导入！");
}
CellType sexCellType = cellSex.CellType;
string sex = 得到流中列值(sexCellType, sheet, i, 2);
if (sex == "男")
{
user.性别 = 1;
}
else
{
user.性别 = 2;
}
CellType classCellType = sheet.GetRow(i).GetCell(3).CellType;
string className = 得到流中列值(classCellType, sheet, i, 3);
user.部门ID = listClass.Where(a => a.名称 == className).First().ID;
user.角色 = 0;
user.邮箱 = "";
user.添加时间 = DateTime.Now;
db.用户表.AddObject(user);
}
}
db.SaveChanges();
return listExistNum;
}
catch (Exception ex)
{
if (ex.Message.Contains("Table"))
{
throw new Exception("格式错误，请按模板格式来导入！");
}
else
{
throw ex;
}
}
}
public static 考试设置 预览考试设置试卷(Guid 考试设置ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
考试设置 examSet = 考试设置查询.Where(a => a.ID == 考试设置ID).First();
examSet.试卷内容 = 试卷内容.给试卷内容中试题内容Json赋值(examSet.试卷内容, false);
return examSet;
}
public static List<LoveKaoServiceReference.试卷外部信息WCF> 得到下载试卷列表(string 关键字, int 第几页, int 页的大小, out int 返回总条数)
{
try
{
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
List<LoveKaoServiceReference.试卷外部信息WCF> listOutside = client.得到主站下载试卷列表(out 返回总条数, 关键字, 第几页, 页的大小);
client.Close();
//查询已下载过的试题
List<Guid> listProblemOutsideId = new List<Guid>();
foreach (var outside in listOutside)
{
listProblemOutsideId.AddRange(outside.试题外部信息ID集合);
}
LoveKaoExamEntities db=new LoveKaoExamEntities();
List<试题外部信息表> listOutsideTable = db.试题外部信息表.Where(a => listProblemOutsideId
.Contains(a.爱考网ID)&&a.创建人ID==用户信息.CurrentUser.用户ID) .ToList();
foreach (var outside in listOutside)
{
int count = listOutsideTable.Where(a => outside.试题外部信息ID集合.Contains(a.爱考网ID)).Count();
outside.已下载试题个数 = count;
}
return listOutside;
}
catch (Exception)
{
throw new Exception("连接爱考网服务器出错，请稍后再试！");
}
}
/// <summary>
/// 返回0上传成功，1账号未绑定，2绑定账号被禁用，3该试卷已经上传过
/// </summary>
public static int 上传试卷(Guid 试卷外部信息ID, out List<试题外部信息> 已存在试题集合)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
//获取绑定账号信息
绑定账号表 bind = db.绑定账号表.Where(a => a.本地账号ID == 用户信息.CurrentUser.用户ID).FirstOrDefault();
if (bind == null)
{
异常处理.抛出异常(-1);
已存在试题集合 = new List<试题外部信息>();
return 1;
}
试卷外部信息 试卷外部信息 = 试卷外部信息查询.Where(a => a.ID == 试卷外部信息ID).First();
试卷内容.给试卷内容中试题内容Json赋值(试卷外部信息.当前试卷内容, false);
LoveKaoServiceReference.试卷外部信息 outsideWCF = 把试卷外部信息转化成试卷外部信息WCF(试卷外部信息);
LoveKaoServiceReference.试卷内容 contentWCF = 把试卷内容转化成试卷内容WCF(试卷外部信息.当前试卷内容);
outsideWCF.当前试卷内容 = contentWCF;
List<Guid> listNewUploadProblemOutsideId = new List<Guid>();
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result = client.上传试卷(out listNewUploadProblemOutsideId, outsideWCF, bind.爱考网账号, bind.爱考网密码);
client.Close();
if (result == 1)
{
异常处理.抛出异常(-1);
}
else if (result == 2)
{
异常处理.抛出异常(1);
}
else if (result == 3)
{
throw new Exception("你已上传过该试卷！");
}
else if (result == 4)
{
异常处理.抛出异常(2);
}
//上传成功，更新试卷类型和试卷中新上传试题类型
if (result == 0)
{
List<Guid> listAllContentId = new List<Guid>();
foreach (试卷中大题 type in 试卷外部信息.当前试卷内容.试卷中大题集合)
{
listAllContentId.AddRange(type.试卷大题中试题集合.Select(a => a.试题内容ID).ToList());
}
List<Guid> listAllOutsideId = db.试题内容表.Where(a => listAllContentId.Contains(a.ID))
.Select(a => a.试题外部信息ID).Distinct().ToList();
List<Guid> listExistOutsideId = listAllOutsideId.Except(listNewUploadProblemOutsideId).ToList();
已存在试题集合 = 试题外部信息.试题外部信息查询.Where(a => listExistOutsideId.Contains(a.ID)).ToList();
试卷外部信息表 outside = db.试卷外部信息表.FirstOrDefault(a=>a.ID==试卷外部信息ID);
outside.试卷类型 = 1;
List<试题外部信息表> listOutside = db.试题外部信息表.Where(a => a.创建人ID == 用户信息.CurrentUser.用户ID
&& listNewUploadProblemOutsideId.Contains(a.ID)).ToList();
foreach (试题外部信息表 outsideTable in listOutside)
{
outsideTable.试题类型 = 1;
}
db.SaveChanges();
return result;
}
else
{
已存在试题集合 = new List<试题外部信息>();
return result;
}
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
public static List<Guid> 得到已下载试卷爱考网ID集合()
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
List<Guid> listOutsideId = db.试卷外部信息表.Where(a => a.试卷类型 == 2
&& a.创建人ID == 用户信息.CurrentUser.用户ID).Select(a => a.爱考网ID).ToList();
return listOutsideId;
}
/// <summary>
/// 返回0下载成功，1账号未绑定，2绑定账号被禁用
/// </summary>
public static int 下载试卷(Guid 试卷外部信息WCFID, int 试题总数, int 已下载试题个数)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
//获取绑定账号信息
绑定账号表 bind = db.绑定账号表.Where(a => a.本地账号ID == 用户信息.CurrentUser.用户ID).FirstOrDefault();
if (bind == null)
{
异常处理.抛出异常(-1);
return 1;
}
LoveKaoServiceReference.试卷外部信息WCF outsideWCF = new LoveKaoServiceReference.试卷外部信息WCF();
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result = client.下载试卷(out outsideWCF, 试卷外部信息WCFID, 试题总数, 已下载试题个数, bind.爱考网账号, bind.爱考网密码);
client.Close();
if (result == 1)
{
异常处理.抛出异常(-1);
}
else if (result == 2)
{
异常处理.抛出异常(1);
}
else if (result == 3)
{
异常处理.抛出异常(2);
}
if (result == 0)
{
保存下载试卷(outsideWCF);
试题外部信息.保存图片(outsideWCF.当前试卷内容WCF.试题图片, 用户信息.CurrentUser.用户名);
}
return result;
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
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;
}
public static void 给考试设置列表赋值试卷内容属性(List<考试设置> listExamSet)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
List<Guid> listContentId = listExamSet.Select(a => a.试卷内容ID).ToList();
List<试卷内容> listContent = 试卷内容.试卷内容查询.Where(a => listContentId.Contains(a.ID)).ToList();
foreach (考试设置 examSet in listExamSet)
{
examSet.试卷内容 = listContent.First(a => a.ID == examSet.试卷内容ID);
}
}
