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); } }