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 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绑定账号被禁用
/// </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;
}
}
/// <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;
}
}
/// <summary>
/// 返回0下载成功，1账号未绑定，2绑定账号被禁用，3没有足够的下载积分，4禁止绑定任何账号
/// </summary>
public static int 下载试题(List<Guid> 试题外部信息WCFID集合)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
//获取绑定账号信息
绑定账号表 bind = db.绑定账号表.Where(a => a.本地账号ID == 用户信息.CurrentUser.用户ID).FirstOrDefault();
if (bind == null)
{
异常处理.抛出异常(-1);
return 1;
}
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
//判断是否有足够的积分下载
int type;
string informationJson = client.得到上传下载信息(out type, bind.爱考网账号, bind.爱考网密码);
if (type == 1)
{
异常处理.抛出异常(1);
}
else if (type == 2)
{
异常处理.抛出异常(2);
}
上传下载信息 information = 上传下载信息.把Json转化成上传下载信息(informationJson);
if (information.可下载试题数量 < 试题外部信息WCFID集合.Count)
{
异常处理.抛出异常(3);
}
Dictionary<string, byte[]> dicPicture = new Dictionary<string, byte[]>();
List<string> ListJson = new List<string>();
int result = client.下载试题(out ListJson, out dicPicture, 试题外部信息WCFID集合, bind.爱考网账号, bind.爱考网密码);
client.Close();
if (result == 0)
{
string userName = 用户信息.CurrentUser.用户名;
List<string> listSaveJson = 替换试题图片路径(ListJson, userName);
保存主站下载试题(listSaveJson, db);
保存图片(dicPicture, userName);
}
return result;
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
public static List<LoveKaoServiceReference.试题外部信息WCF> 得到下载试题列表(string 关键字, int 第几页, int 页的大小, out int 返回总条数)
{
try
{
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
List<LoveKaoServiceReference.试题外部信息WCF> listOutside = client.得到主站下载试题列表(out 返回总条数, 关键字,用户信息.CurrentUser.用户名, 第几页, 页的大小);
client.Close();
return listOutside;
}
catch (Exception)
{
throw new Exception("连接爱考网服务器出错，请稍后再试！");
}
}
/// <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;
}
}
/// <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>
/// 返回0成功，1用户名已被他人使用，2邮箱已被他人使用，3已经绑定过账号
/// </summary>
public static int 绑定新账号(string 用户名, string 密码, string 邮箱)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
if (db.绑定账号表.Any(a => a.本地账号ID == 用户信息.CurrentUser.用户ID) == true)
{
异常处理.抛出异常(6);
}
IPHostEntry IPHost = Dns.Resolve(Dns.GetHostName());
string IPAddress = IPHost.AddressList[0].ToString();
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result = client.绑定新账号(用户名, 密码, 邮箱, IPAddress,用户信息.CurrentUser.用户名);
client.Close();
switch (result)
{
case 0:
{
添加绑定账号(用户名, 密码, 邮箱);
break;
}
case 1:
{
异常处理.抛出异常(7);
break;
}
case 2:
{
异常处理.抛出异常(8);
break;
}
}
return result;
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
/// <summary>
/// 返回0成功，1账号不存在，2密码错误，3账号已绑定过，4绑定账号被禁用,5禁止绑定任何账号
/// </summary>
public static int 绑定已有账号(string 用户名, string 密码)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
IPHostEntry IPHost = Dns.Resolve(Dns.GetHostName());
string IPAddress = IPHost.AddressList[0].ToString();
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
string email = string.Empty;
string userName = string.Empty;
int result = client.绑定已有账号(out email,out userName, 用户名, 密码, IPAddress,用户信息.CurrentUser.用户名);
client.Close();
switch(result)
{
case 0:
{
添加绑定账号(userName, 密码, email);
break;
}
case 1:
{
异常处理.抛出异常(4);
break;
}
case 2:
{
异常处理.抛出异常(5);
break;
}
case 3:
{
异常处理.抛出异常(6);
break;
}
case 4:
{
异常处理.抛出异常(1);
break;
}
case 5:
{
异常处理.抛出异常(2);
break;
}
}
return result;
}
catch (Exception ex)
{
异常处理.Catch异常处理(ex.Message);
throw;
}
}
/// <summary>
/// 返回null说明未绑定
/// </summary>
/// <param name="result">0正常，1绑定账号被禁用，2禁止绑定任何账号</param>
public static 绑定账号表 得到用户绑定信息(Guid 用户ID,out LKPageException 异常信息)
{
try
{
LoveKaoExamEntities db = new LoveKaoExamEntities();
绑定账号表 bind = db.绑定账号表.Where(a => a.本地账号ID == 用户ID).FirstOrDefault();
if (bind == null)
{
异常信息 = new LKPageException();
return null;
}
else
{
LoveKaoServiceReference.LoveKaoServiceInterfaceClient client = new LoveKaoServiceReference.LoveKaoServiceInterfaceClient();
int result = client.得到用户绑定信息(bind.爱考网账号);
client.Close();
if (result == 1)
{
异常信息 = new LKPageException(异常处理.得到异常信息(1));
}
else if (result == 2)
{
异常信息 = new LKPageException(异常处理.得到异常信息(2));
}
else
{
异常信息 = new LKPageException();
}
return bind;
}
}
catch (Exception)
{
异常信息 = new LKPageException(异常处理.得到无法连接爱考网异常信息(),3);
return new 绑定账号表();
}
}
