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 提交保存批改(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();
}
/// <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 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();
// }
}
/// <summary>
/// 返回0上传成功，1账号未绑定，2绑定账号被禁用，3禁止绑定任何账号
/// </summary>
public static int 上传试题(List<Guid> 试题外部信息ID集合,out List<试题外部信息> 已存在试题集合)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
//获取绑定账号信息
绑定账号表 bind = db.绑定账号表.Where(a => a.本地账号ID == 用户信息.CurrentUser.用户ID).FirstOrDefault();
if (bind == null)
{
已存在试题集合 = new List<试题外部信息>();
return 1;
}
List<试题外部信息> 试题外部信息集合 = 试题外部信息查询.Where(a => 试题外部信息ID集合.Contains(a.ID)).ToList();
//给试题外部信息集合赋值当前试题内容属性
List<Guid> listContentId = 试题外部信息集合.Select(a => a.试题内容ID).ToList();
List<试题内容> listContent = 试题内容.试题内容查询.Where(a => listContentId.Contains(a.ID)).ToList();
foreach (试题外部信息 outside in 试题外部信息集合)
{
outside.当前试题内容 = listContent.Where(a => a.ID == outside.试题内容ID).First();
}
Dictionary<string, byte[]> dicPicture = new Dictionary<string, byte[]>();
List<string> listJson = new List<string>();
foreach (试题外部信息 outside in 试题外部信息集合)
{
string Json = 试题内容.转化成完整Json字符串(outside.当前试题内容, outside);
listJson.Add(Json);
Dictionary<string, byte[]> oneDic = 获取试题图片(Json);
foreach (var subOneDic in oneDic)
{
dicPicture.Add(subOneDic.Key, subOneDic.Value);
}
}
List<Guid> listExistOutsideId = new List<Guid>();
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result = client.上传试题(out listExistOutsideId,listJson,dicPicture,bind.爱考网账号, bind.爱考网密码);
client.Close();
if (result == 1)
{
异常处理.抛出异常(-1);
}
else if (result == 2)
{
异常处理.抛出异常(1);
}
else if (result == 3)
{
异常处理.抛出异常(2);
}
if (result == 0)
{
//更新试题类型
List<试题外部信息表> listOutside = db.试题外部信息表.Where(a => 试题外部信息ID集合.Contains(a.ID)).ToList();
foreach (试题外部信息表 outside in listOutside)
{
outside.试题类型 = 1;
}
db.SaveChanges();
已存在试题集合 = 试题外部信息.试题外部信息查询.Where(a => listExistOutsideId.Contains(a.ID)).ToList();
}
else
{
已存在试题集合 = new List<试题外部信息>();
}
return result;
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
public static void 删除用户(Guid 用户ID)
{
异常处理.删除修改权限判断();
LoveKaoExamEntities db = new LoveKaoExamEntities();
List<系统分类表> listSystem = db.系统分类表.Where(a=>a.操作人ID==用户ID).ToList();
List<string> listSystemSort=listSystem.Select(a=>a.分类名称).ToList();
List<系统分类上下级关系表> listRelation = db.系统分类上下级关系表.Where(a => listSystemSort.Contains(a.系统分类名称)
|| listSystemSort.Contains(a.分类关系名称)).ToList();
foreach (var relation in listRelation)
{
db.系统分类上下级关系表.DeleteObject(relation);
}
foreach (var system in listSystem)
{
db.系统分类表.DeleteObject(system);
}
List<试卷外部信息表> listTest = db.试卷外部信息表.Where(a => a.创建人ID == 用户ID).ToList();
foreach (var test in listTest)
{
db.试卷外部信息表.DeleteObject(test);
}
List<试题外部信息表> listProblem = db.试题外部信息表.Where(a => a.创建人ID == 用户ID).ToList();
foreach (var problem in listProblem)
{
db.试题外部信息表.DeleteObject(problem);
}
用户表 user = db.用户表.First(a => a.ID == 用户ID);
db.SaveChanges();
}
/// <summary>
/// 返回0成功，1失败
/// </summary>
public static int 解除绑定账号()
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
绑定账号表 bind = db.绑定账号表.Where(a=>a.本地账号ID==用户信息.CurrentUser.用户ID).FirstOrDefault();
if (bind == null)
{
return 1;
}
else
{
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result = client.解除绑定账号(bind.爱考网账号, bind.爱考网密码,用户信息.CurrentUser.用户名);
client.Close();
if (result == 0)
{
//删除本地绑定账号
db.绑定账号表.DeleteObject(bind);
db.SaveChanges();
}
return result;
}
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
/// <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 void 修改公布考试结果(Guid 考试设置ID, bool 是否公布考试结果)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
考试设置表 examSet = db.考试设置表.FirstOrDefault(a=>a.ID==考试设置ID);
if (examSet.设置人ID != 用户信息.CurrentUser.用户ID)
{
throw new Exception("您无权修改！");
}
examSet.是否公布考试结果 = 是否公布考试结果;
db.SaveChanges();
}
public static void 添加试卷设置(试卷设置 试卷设置)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
if (试卷设置.设置类型 == 1)
{
//未设置成练习才能设置成考试
Guid outsideId = db.试卷内容表.FirstOrDefault(a=>a.ID==试卷设置.试卷内容ID).试卷外部信息ID;
List<Guid> listContentId = db.试卷内容表.Where(a=>a.试卷外部信息ID==outsideId).Select(a=>a.ID).ToList();
if (db.练习设置表.Any(a => listContentId.Contains(a.试卷内容ID) && a.是否删除 == false) == true)
{
throw new Exception("该试卷已设置成练习，若要设置成考试，请先删除练习设置！");
}
//只有出卷人才能设置
试卷内容 testContent = 试卷内容.试卷内容查询.Where(a => a.ID == 试卷设置.试卷内容ID).First();
if (testContent.提交人ID != 试卷设置.设置人ID)
{
throw new Exception("您无权设置该试卷！");
}
//开始时间不能大于结束时间
if (试卷设置.考试开始时间 >= 试卷设置.考试结束时间)
{
throw new Exception("考试开始时间不能大于考试结束时间！");
}
考试设置表 examSet = new 考试设置表();
examSet.ID = Guid.NewGuid();
examSet.及格条件 = 试卷设置.及格条件;
examSet.考试结束时间 = 试卷设置.考试结束时间;
examSet.考试开始时间 = 试卷设置.考试开始时间;
examSet.考试时长 = 试卷设置.考试时长;
examSet.试卷内容ID = 试卷设置.试卷内容ID;
examSet.是否公布考试结果 = 试卷设置.是否公布考试结果;
examSet.设置人ID = 试卷设置.设置人ID;
examSet.设置时间 = DateTime.Now;
examSet.是否删除 = false;
List<考生范围表> listArea = new List<考生范围表>();
foreach (Guid examineeId in 试卷设置.考生ID集合)
{
考生范围表 area = new 考生范围表();
area.ID = Guid.NewGuid();
area.考生ID = examineeId;
area.相关ID = examSet.ID;
listArea.Add(area);
}
db.考试设置表.AddObject(examSet);
foreach (var area in listArea)
{
db.考生范围表.AddObject(area);
}
db.SaveChanges();
}
else
{
//若试卷已设置成考试，则要在考试结束后或删除考试设置才能设置成练习
Guid outsideId = db.试卷内容表.FirstOrDefault(a=>a.ID==试卷设置.试卷内容ID).试卷外部信息ID;
List<Guid> listContentId = db.试卷内容表.Where(a=>a.试卷外部信息ID==outsideId).Select(a => a.ID).ToList();
考试设置表 examSet = db.考试设置表.Where(a=>listContentId.Contains(a.试卷内容ID)&& a.是否删除 == false)
.OrderByDescending(a => a.考试结束时间).FirstOrDefault();
if (examSet != null)
{
if (examSet.考试结束时间 > DateTime.Now)
{
throw new Exception("该试卷已设置成考试，若要设置成练习，需在考试结束时间以后或删除考试设置！");
}
}
//只有出卷人才能设置
试卷内容 testContent = 试卷内容.试卷内容查询.Where(a => a.ID == 试卷设置.试卷内容ID).First();
if (testContent.提交人ID != 试卷设置.设置人ID)
{
throw new Exception("您无权设置该试卷！");
}
//若该试卷以前有设置成练习的记录，且被删除了，则更新设置，并恢复删除,若没有，则添加新的设置
练习设置表 dbExerciseSet = db.练习设置表.FirstOrDefault(a=>a.试卷内容ID==试卷设置.试卷内容ID);
if (dbExerciseSet == null)
{
练习设置表 exerciseSet = new 练习设置表();
exerciseSet.及格条件 = 试卷设置.及格条件;
exerciseSet.考试时长 = 试卷设置.考试时长;
exerciseSet.设置人ID = 试卷设置.设置人ID;
exerciseSet.设置时间 = DateTime.Now;
exerciseSet.试卷内容ID = 试卷设置.试卷内容ID;
exerciseSet.是否删除 = false;
db.练习设置表.AddObject(exerciseSet);
List<考生范围表> listArea = new List<考生范围表>();
foreach (Guid examineeId in 试卷设置.考生ID集合)
{
考生范围表 area = new 考生范围表();
area.ID = Guid.NewGuid();
area.考生ID = examineeId;
area.相关ID = exerciseSet.试卷内容ID;
listArea.Add(area);
}
foreach (var area in listArea)
{
db.考生范围表.AddObject(area);
}
}
else
{
dbExerciseSet.及格条件 = 试卷设置.及格条件;
dbExerciseSet.考试时长 = 试卷设置.考试时长;
dbExerciseSet.设置时间 = DateTime.Now;
dbExerciseSet.是否删除 = false;
考生范围.更新考生范围(试卷设置.试卷内容ID, 试卷设置.考生ID集合, db);
}
db.SaveChanges();
}
}
/// <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;
}
public void 保存(LoveKaoExamEntities db, Guid 试卷内容ID)
{
试卷内容表 testContent = new 试卷内容表();
testContent.ID = 试卷内容ID;
testContent.名称 = this.名称;
testContent.试卷外部信息ID = this.试卷外部信息ID;
testContent.说明 = this.说明;
testContent.提交备注 = this.提交备注;
testContent.提交人ID = this.提交人ID;
testContent.提交时间 = DateTime.Now;
for (int i = 0; i < this.试卷中大题集合.Count; i++)
{
试卷中大题表 type = new 试卷中大题表();
type.ID = Guid.NewGuid();
type.多选题评分策略 = this.试卷中大题集合[i].多选题评分策略;
type.名称 = this.试卷中大题集合[i].名称;
type.顺序 = Convert.ToByte(i);
type.说明 = this.试卷中大题集合[i].说明;
for (int j = 0; j < this.试卷中大题集合[i].试卷大题中试题集合.Count; j++)
{
if (this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合 != null)
{
foreach (试卷大题中试题 testProblem in this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合)
{
试卷大题中试题表 dbTestProblem = new 试卷大题中试题表();
dbTestProblem.ID = Guid.NewGuid();
dbTestProblem.每小题分值 = testProblem.每小题分值;
dbTestProblem.试题内容ID = testProblem.试题内容ID;
type.试卷大题中试题表.Add(dbTestProblem);
}
}
试卷大题中试题表 problem = new 试卷大题中试题表();
problem.ID = Guid.NewGuid();
problem.每小题分值 = this.试卷中大题集合[i].试卷大题中试题集合[j].每小题分值;
problem.试题内容ID = this.试卷中大题集合[i].试卷大题中试题集合[j].试题内容ID;
problem.顺序 = Convert.ToByte(j);
type.试卷大题中试题表.Add(problem);
}
testContent.试卷中大题表.Add(type);
}
db.试卷内容表.AddObject(testContent);
db.SaveChanges();
}
public override void 保存(LoveKaoExamEntities db, string Json字符串)
{
试题内容表 content = new 试题内容表();
content.ID = this.ID;
content.操作人ID = this.操作人ID;
content.操作时间 = DateTime.Now;
content.解题思路 = this.解题思路;
content.试题外部信息ID = this.试题外部信息ID;
content.题干HTML = this.题干HTML;
content.题干文本 = this.题干文本;
content.小题型Enum = this.小题型Enum;
content.难易度 = this.难易度;
JObject bo = JObject.Parse(Json字符串);
for (int i = 0; i < this.子小题集合.Count; i++)
{
switch (this.子小题集合[i].小题型Enum)
{
//单选题
case 11:
{
string singleJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
单选题 single = jss.Deserialize<单选题>(singleJson);
单选题.给单选题选项赋值新ID(single);
single.操作人ID = this.操作人ID;
single.试题外部信息ID = this.试题外部信息ID;
single.父试题内容ID = content.ID;
single.爱考网ID = this.子小题集合[i].爱考网ID;
single.ID = this.子小题集合[i].ID;
试题内容表 singleContent = single.类映射表赋值();
singleContent.父试题内容ID = content.ID;
singleContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(singleContent);
break;
}
//多选题
case 12:
{
string multiJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
多选题 multi = jss.Deserialize<多选题>(multiJson);
多选题.给多选题选项赋值新ID(multi);
multi.操作人ID = this.操作人ID;
multi.试题外部信息ID = this.试题外部信息ID;
multi.父试题内容ID = content.ID;
multi.爱考网ID = this.子小题集合[i].爱考网ID;
multi.ID = this.子小题集合[i].ID;
试题内容表 multiContent = multi.类映射表赋值();
multiContent.父试题内容ID = content.ID;
multiContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(multiContent);
break;
}
//填空题
case 13:
{
string fillJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
填空题 fill = jss.Deserialize<填空题>(fillJson);
fill.操作人ID = this.操作人ID;
fill.试题外部信息ID = this.试题外部信息ID;
fill.父试题内容ID = content.ID;
fill.爱考网ID = this.子小题集合[i].爱考网ID;
fill.ID = this.子小题集合[i].ID;
试题内容表 fillContent = fill.类映射表赋值();
fillContent.父试题内容ID = content.ID;
fillContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(fillContent);
break;
}
case 14:
{
string dictionJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
选词填空 diction = jss.Deserialize<选词填空>(dictionJson);
选词填空.给选词填空选项赋值新ID(diction);
diction.操作人ID = this.操作人ID;
diction.试题外部信息ID = this.试题外部信息ID;
diction.父试题内容ID = content.ID;
diction.爱考网ID = this.子小题集合[i].爱考网ID;
diction.ID = this.子小题集合[i].ID;
试题内容表 dictionContent = diction.类映射表赋值();
dictionContent.父试题内容ID = content.ID;
dictionContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(dictionContent);
break;
}
case 15:
{
string clozeJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
完形填空 cloze = jss.Deserialize<完形填空>(clozeJson);
完形填空.给完形填空选项赋值新ID(cloze);
cloze.操作人ID = this.操作人ID;
cloze.试题外部信息ID = this.试题外部信息ID;
cloze.父试题内容ID = content.ID;
cloze.爱考网ID = this.子小题集合[i].爱考网ID;
cloze.ID = this.子小题集合[i].ID;
试题内容表 clozeContent = cloze.类映射表赋值();
clozeContent.父试题内容ID = content.ID;
clozeContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(clozeContent);
break;
}
//判断题
case 20:
{
string singleJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
判断题 judge = jss.Deserialize<判断题>(singleJson);
judge.操作人ID = this.操作人ID;
judge.试题外部信息ID = this.试题外部信息ID;
judge.父试题内容ID = content.ID;
judge.爱考网ID = this.子小题集合[i].爱考网ID;
judge.ID = this.子小题集合[i].ID;
试题内容表 judgeContent = judge.类映射表赋值();
judgeContent.父试题内容ID = content.ID;
judgeContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(judgeContent);
break;
}
case 30:
{
string linkJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
连线题 link = jss.Deserialize<连线题>(linkJson);
连线题.给连线题选项赋值新ID(link);
link.操作人ID = this.操作人ID;
link.试题外部信息ID = this.试题外部信息ID;
link.父试题内容ID = content.ID;
link.爱考网ID = this.子小题集合[i].爱考网ID;
link.ID = this.子小题集合[i].ID;
试题内容表 linkContent = link.类映射表赋值();
linkContent.父试题内容ID = content.ID;
linkContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(linkContent);
break;
}
//问答题
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
{
string questionAnswerJson = bo["子小题集合"][i].ToString();
JavaScriptSerializer jss = new JavaScriptSerializer();
问答题 questionAnswer = jss.Deserialize<问答题>(questionAnswerJson);
questionAnswer.操作人ID = this.操作人ID;
questionAnswer.试题外部信息ID = this.试题外部信息ID;
questionAnswer.父试题内容ID = content.ID;
questionAnswer.爱考网ID = this.子小题集合[i].爱考网ID;
questionAnswer.ID = this.子小题集合[i].ID;
试题内容表 questionAnswerContent = questionAnswer.类映射表赋值();
questionAnswerContent.父试题内容ID = content.ID;
questionAnswerContent.本题在复合题中顺序 = Convert.ToByte(i);
content.试题内容表1.Add(questionAnswerContent);
break;
}
}
}
content.Json字符串 = this.转化成Json带答案();
content.爱考网ID = this.爱考网ID;
db.试题内容表.AddObject(content);
db.SaveChanges();
}
public override void 保存(LoveKaoExamEntities db, string Json字符串)
{
试题内容表 content = new 试题内容表();
content.ID = this.ID;
content.操作人ID = this.操作人ID;
content.操作时间 = DateTime.Now;
content.解题思路 = this.解题思路;
content.试题外部信息ID = this.试题外部信息ID;
content.题干HTML = this.题干HTML;
content.题干文本 = this.题干文本;
content.小题型Enum = this.小题型Enum;
content.爱考网ID = this.爱考网ID;
content.难易度 = this.难易度;
for (int i = 0; i < this.子小题集合.Count; i++)
{
this.子小题集合[i].本题在复合题中顺序 = Convert.ToByte(i);
this.子小题集合[i].ID = Guid.NewGuid();
}
var subContentGroup = this.子小题集合.GroupBy(a => a.选项组ID).ToList();
for (int j = 0; j < subContentGroup.Count; j++)
{
自由题选项组表 dbGroup = new 自由题选项组表();
dbGroup.ID = subContentGroup[j].Key;
选项组 newGroup = new 选项组();
foreach (选项组 group in this.选项组集合)
{
if (subContentGroup[j].Key == group.ID)
{
newGroup = group;
}
}
for (int k = 0; k < newGroup.选项集合.Count; k++)
{
自由题选项表 choice = new 自由题选项表();
choice.ID = newGroup.选项集合[k].ID;
choice.顺序 = Convert.ToByte(k);
choice.选项内容HTML = newGroup.选项集合[k].选项内容HTML;
choice.选项内容文本 = newGroup.选项集合[k].选项内容文本;
dbGroup.自由题选项表.Add(choice);
}
subContentGroup[j].ElementAt(0).父试题内容ID = content.ID;
试题内容表 dbSubContent = new 试题内容表();
dbSubContent.ID = subContentGroup[j].ElementAt(0).ID;
dbSubContent.操作人ID = this.操作人ID;
dbSubContent.操作时间 = DateTime.Now;
dbSubContent.解题思路 = subContentGroup[j].ElementAt(0).解题思路;
dbSubContent.试题外部信息ID = this.试题外部信息ID;
dbSubContent.题干HTML = subContentGroup[j].ElementAt(0).题干HTML;
dbSubContent.题干文本 = subContentGroup[j].ElementAt(0).题干文本;
dbSubContent.小题型Enum = subContentGroup[j].ElementAt(0).小题型Enum;
dbSubContent.本题在复合题中顺序 = subContentGroup[j].ElementAt(0).本题在复合题中顺序;
dbSubContent.父试题内容ID = content.ID;
dbSubContent.Json字符串 = subContentGroup[j].ElementAt(0).转化成Json带答案();
dbSubContent.爱考网ID = subContentGroup[j].ElementAt(0).爱考网ID;
自由题选项空格答案表 answer = new 自由题选项空格答案表();
answer.ID = Guid.NewGuid();
answer.自由题选项ID = subContentGroup[j].ElementAt(0).答案ID;
自由题空格表 space = new 自由题空格表();
space.ID = Guid.NewGuid();
space.空格类型 = 0;
space.顺序 = 0;
space.自由题选项组表 = dbGroup;
space.自由题选项空格答案表.Add(answer);
dbSubContent.自由题空格表.Add(space);
content.试题内容表1.Add(dbSubContent);
for (int m = 1; m < subContentGroup[j].Count(); m++)
{
subContentGroup[j].ElementAt(m).父试题内容ID = content.ID;
试题内容表 dbSubContent1 = new 试题内容表();
dbSubContent1.ID = subContentGroup[j].ElementAt(m).ID;
dbSubContent1.操作人ID = this.操作人ID;
dbSubContent1.操作时间 = DateTime.Now;
dbSubContent1.解题思路 = subContentGroup[j].ElementAt(m).解题思路;
dbSubContent1.试题外部信息ID = this.试题外部信息ID;
dbSubContent1.题干HTML = subContentGroup[j].ElementAt(m).题干HTML;
dbSubContent1.题干文本 = subContentGroup[j].ElementAt(m).题干文本;
dbSubContent1.小题型Enum = subContentGroup[j].ElementAt(m).小题型Enum;
dbSubContent1.本题在复合题中顺序 = subContentGroup[j].ElementAt(m).本题在复合题中顺序;
dbSubContent1.父试题内容ID = content.ID;
dbSubContent1.Json字符串 = subContentGroup[j].ElementAt(m).转化成Json带答案();
dbSubContent1.爱考网ID = subContentGroup[j].ElementAt(m).爱考网ID;
自由题选项空格答案表 answer1 = new 自由题选项空格答案表();
answer1.ID = Guid.NewGuid();
answer1.自由题选项ID = subContentGroup[j].ElementAt(m).答案ID;
自由题空格表 space1 = new 自由题空格表();
space1.ID = Guid.NewGuid();
space1.空格类型 = 0;
space1.顺序 = 0;
space1.自由题选项组ID = newGroup.ID;
space1.自由题选项空格答案表.Add(answer1);
dbSubContent1.自由题空格表.Add(space1);
content.试题内容表1.Add(dbSubContent1);
}
}
content.Json字符串 = this.转化成Json带答案();
db.试题内容表.AddObject(content);
db.SaveChanges();
}
private static void 添加绑定账号(string 用户名, string 密码, string 邮箱)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
Guid hostUserId=用户信息.CurrentUser.用户ID;
if (db.绑定账号表.Any(a => a.本地账号ID == hostUserId && a.爱考网账号 == 用户名) == false)
{
绑定账号表 bind = new 绑定账号表();
bind.本地账号ID = hostUserId;
bind.爱考网账号 = 用户名;
bind.爱考网密码 = 加密字符串(密码);
bind.爱考网邮箱 = 邮箱;
bind.绑定时间 = DateTime.Now;
db.绑定账号表.AddObject(bind);
db.SaveChanges();
}
}
private static void 更新绑定账号(string 用户名, string 密码, string 邮箱)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
//删除原来的
绑定账号表 oldBind = db.绑定账号表.Where(a => a.本地账号ID == 用户信息.CurrentUser.用户ID).FirstOrDefault();
if (oldBind != null)
{
db.绑定账号表.DeleteObject(oldBind);
}
//添加新的
绑定账号表 bind = new 绑定账号表();
bind.本地账号ID = 用户信息.CurrentUser.用户ID;
bind.爱考网账号 = 用户名;
bind.爱考网密码 = 加密字符串(密码);
bind.爱考网邮箱 = 邮箱;
bind.绑定时间 = DateTime.Now;
db.绑定账号表.AddObject(bind);
db.SaveChanges();
}
public static void 删除试题(Guid 试题外部信息ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
试题外部信息表 problem = db.试题外部信息表.FirstOrDefault(a => a.ID == 试题外部信息ID);
异常处理.删除修改权限判断(problem.创建人ID);
problem.试题状态Enum = 1;
db.SaveChanges();
}
public static void 修改试卷设置(试卷设置 试卷设置)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
if (试卷设置.设置类型 == 1)
{
考试设置表 examSet = db.考试设置表.FirstOrDefault(a=>a.ID==试卷设置.ID);
//只有设置人自己才能修改
异常处理.删除修改权限判断(examSet.设置人ID);
//考试时间开始以后，就不能修改了
if (DateTime.Now >= examSet.考试开始时间 && DateTime.Now <= examSet.考试结束时间)
{
throw new Exception("考试时间内不能修改，只有考试开始时间前能修改！");
}
if (DateTime.Now > examSet.考试结束时间)
{
throw new Exception("考试时间已过，不能修改，只有考试开始时间前能修改！");
}
examSet.及格条件 = 试卷设置.及格条件;
examSet.考试结束时间 = 试卷设置.考试结束时间;
examSet.考试开始时间 = 试卷设置.考试开始时间;
examSet.考试时长 = 试卷设置.考试时长;
//更新考生范围
考生范围.更新考生范围(试卷设置.ID, 试卷设置.考生ID集合, db);
db.SaveChanges();
}
else
{
练习设置表 exerciseSet = db.练习设置表.FirstOrDefault(a=>a.试卷内容ID==试卷设置.试卷内容ID);
//只有设置人自己才能修改
异常处理.删除修改权限判断(exerciseSet.设置人ID);
exerciseSet.及格条件 = 试卷设置.及格条件;
exerciseSet.考试时长 = 试卷设置.考试时长;
exerciseSet.设置时间 = DateTime.Now;
考生范围.更新考生范围(试卷设置.试卷内容ID, 试卷设置.考生ID集合, db);
db.SaveChanges();
}
}
public static void 删除练习设置(Guid 试卷内容ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
练习设置表 exerciseSet = db.练习设置表.FirstOrDefault(a=>a.试卷内容ID==试卷内容ID);
//只有设置人才能删除
异常处理.删除修改权限判断(exerciseSet.设置人ID);
db.练习设置表.DeleteObject(exerciseSet);
//删除考生范围
List<考生范围表> listArea = db.考生范围表.Where(a => a.相关ID == 试卷内容ID).ToList();
foreach (var area in listArea)
{
db.考生范围表.DeleteObject(area);
}
//删除考生做过的练习记录
List<考生做过的试卷表> listMemberDoneTest = db.考生做过的试卷表.Where(a => a.类型 == 0 && a.相关ID == 试卷内容ID).ToList();
foreach (var memberDoneTest in listMemberDoneTest)
{
db.考生做过的试卷表.DeleteObject(memberDoneTest);
}
db.SaveChanges();
}
public static void 删除考生未完成的试卷记录(Guid 考生做过的试卷ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
考生做过的试卷表 memberDoneTest = db.考生做过的试卷表.First(a => a.ID == 考生做过的试卷ID);
db.考生做过的试卷表.DeleteObject(memberDoneTest);
db.SaveChanges();
}
/// <summary>
/// 返回0成功,1部门名已存在
/// </summary>
public static int 添加部门(部门 部门)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
if (db.部门表.Any(a => a.名称 == 部门.名称) == true)
{
return 1;
}
部门表 department = new 部门表();
department.ID = 部门.ID;
department.名称 = 部门.名称;
department.上级部门ID = 部门.上级部门ID;
department.添加人ID = 部门.创建人ID;
department.添加时间 = DateTime.Now;
db.部门表.AddObject(department);
db.SaveChanges();
return 0;
}
public static void 删除考试设置(Guid 考试设置ID)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
考试设置表 examSet = db.考试设置表.FirstOrDefault(a=>a.ID==考试设置ID);
//只有设置人才能删除
异常处理.删除修改权限判断(examSet.设置人ID);
//考试时间内不能删除
if (DateTime.Now >= examSet.考试开始时间 && DateTime.Now <= examSet.考试结束时间)
{
throw new Exception("考试时间内不能删除！");
}
db.考试设置表.DeleteObject(examSet);
//删除考生范围
List<考生范围表> listArea = db.考生范围表.Where(a => a.相关ID == 考试设置ID).ToList();
foreach (var area in listArea)
{
db.考生范围表.DeleteObject(area);
}
//删除考生做过的练习记录
List<考生做过的试卷表> listMemberDoneTest = db.考生做过的试卷表.Where(a => a.类型 == 1 && a.相关ID == 考试设置ID).ToList();
foreach (var memberDoneTest in listMemberDoneTest)
{
db.考生做过的试卷表.DeleteObject(memberDoneTest);
}
db.SaveChanges();
}
public override void 保存(LoveKaoExamEntities db, string Json字符串)
{
试题内容表 problemContent = this.类映射表赋值();
db.试题内容表.AddObject(problemContent);
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();
}
}
/// <summary>
/// 返回0成功，1编号重复，2邮箱重复
/// </summary>
public static int 添加用户(用户 用户)
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
//判断编号是否存在
if (db.用户表.Any(a => a.编号 == 用户.编号) == true)
{
return 1;
}
if (String.IsNullOrEmpty(用户.邮箱) == false)
{
//判断邮箱是否存在
if (db.用户表.Any(a => a.邮箱 == 用户.邮箱) == true)
{
return 2;
}
}
用户表 user = new 用户表();
user.ID = Guid.NewGuid();
user.编号 = 用户.编号;
if (用户.角色 == 0)
{
user.部门ID = 用户.部门ID;
}
user.角色 = 用户.角色;
user.密码 = "123456";
user.姓名 = 用户.姓名;
user.性别 = 用户.性别;
user.邮箱 = 用户.邮箱;
user.添加时间 = DateTime.Now;
db.用户表.AddObject(user);
db.SaveChanges();
return 0;
}
/// <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 void 删除部门(Guid 部门ID)
{
异常处理.删除修改权限判断();
LoveKaoExamEntities db = new LoveKaoExamEntities();
部门表 department = db.部门表.First(a => a.ID == 部门ID);
db.部门表.DeleteObject(department);
db.SaveChanges();
}
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();
}
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();
//}
}