/// <summary>
/// 获取教职工信息
/// </summary>
/// <param name="id">教职工编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <StaffEditViewModel> GetStaffAsync(long id, ApplicationDbContext context)
{
var webModel = new StaffEditViewModel();
try
{
var model = await PSURepository.GetUserByIdAsync(id, context);
webModel.Id = model.Id.ToString();
webModel.IsEnabled = (Enable)(model.IsEnabled ? 1 : 0);
webModel.Name = model.Name;
webModel.QQ = model.QQ.ToString();
webModel.Wechat = model.Wechat;
webModel.DepartmentId = model.DepartmentId;
webModel.DepartmentName = model.Department;
webModel.Account = model.Account;
webModel.Address = model.Address;
webModel.Age = model.Age;
webModel.Email = model.Email;
webModel.Gender = model.Gender;
webModel.IdNumber = model.IdNumber;
webModel.IsMaster = model.IsMaster;
webModel.Password = model.Password;
webModel.Phone = model.Phone;
}
catch (Exception ex)
{
_logger.LogError("获取教职工数据失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
/// <summary>
/// 查找当前用户报名信息
/// </summary>
/// <param name="id">学生编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <InformationViewModel> GetInformationAsync(long id, ApplicationDbContext context)
{
var webModel = new InformationViewModel();
try
{
//Get register Data
var register = await RegisterRepository.GetEntityAsync(id, context);
if (register != null)
{
webModel.ArriveTime = register.ArriveTime.ToString("yyyy-MM-dd");
webModel.ExpressId = register.ExpressId;
webModel.Id = register.Id.ToString();
webModel.IsExpress = register.IsExpress;
webModel.Place = register.Place;
webModel.Remark = register.Remark;
webModel.Way = register.Way;
}
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
webModel.SId = user.Id.ToString();
webModel.Department = user.Department;
webModel.MajorClass = user.MajorClass;
webModel.Name = user.Name;
}
catch (Exception ex)
{
_logger.LogError("获取用户报名数据失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
/// <summary>
/// 设置当前登录用户
/// </summary>
public async Task SetCurrentUser(string oid, IHttpContextAccessor httpContextAccessor, ApplicationDbContext context)
{
CurrentUser.Configure(httpContextAccessor);
var user = await PSURepository.GetUserByOIDAsync(oid, context);
if (user != null)
{
string role = string.Empty;
switch (user.AccountType)
{
case 0:
role = "Administrator";
break;
case 1:
role = "Instructor";
break;
case 2:
role = "Student";
break;
}
CurrentUser.UserAccount = user.Account;
CurrentUser.UserId = user.Id;
CurrentUser.UserImage = user.ImageSrc;
CurrentUser.UserName = user.Name;
CurrentUser.UserOID = user.IdentityUserOID;
CurrentUser.UserRole = role;
CurrentUser.UserPage = user.HomePage;
}
}
/// <summary>
/// 获取个人信息
/// </summary>
/// <param name="id">用户编号</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public async Task <ProfileViewModel> GetProfileAsync(long id, ApplicationDbContext context)
{
var webModel = new ProfileViewModel();
try
{
var model = await PSURepository.GetUserByIdAsync(id, context);
webModel.Id = model.Id.ToString();
webModel.Name = model.Name;
webModel.Address = model.Address;
webModel.Age = model.Age;
webModel.CreateTime = model.CreatedOn.ToString();
webModel.Email = model.Email;
webModel.Gender = model.Gender;
webModel.Phone = model.Phone;
webModel.Account = model.Account;
webModel.Department = model.Department;
webModel.QQ = model.QQ.ToString();
webModel.Wechat = model.Wechat;
}
catch (Exception ex)
{
_logger.LogError("获取用户个人数据失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
/// <summary>
/// 获取公告详情页数据
/// </summary>
/// <param name="id">公告编号</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public async Task <BulletinDetailViewModel> GetBulletinDetailAsync(long id, ApplicationDbContext context)
{
//Get Bulletin Data
var bulletin = await HomeRepository.GetEntityAsync(id, context);
//Get Operate Data
var record = await PSURepository.GetRecordListAsync(id, context);
var list = new List <Operate>();
if (record != null && record.Any())
{
list.AddRange(record.Select(item => new Operate
{
Name = item.UserName,
DateTime = item.DateTime.ToString("yyyy-MM-dd HH:mm"),
Operating = item.Operate
}));
}
//Bulid Web Model
var webModel = new BulletinDetailViewModel
{
Title = bulletin.Title,
Content = bulletin.Content,
CreatedOn = bulletin.CreatedOn,
OperateName = bulletin.CreatedName,
OperateList = list.OrderBy(i => i.DateTime).ToList()
};
return(webModel);
}
/// <summary>
/// 获取寝室信息
/// </summary>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public static async Task <List <Dorm> > GetDormitoryListAsync(ApplicationDbContext context)
{
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
int gender = user.Gender ? 1 : 2;
var model = await context.Dorm.AsNoTracking().Where(i => i.IsEnabled == true && i.Count > i.SelectedCount && (i.Type == 3 || i.Type == gender)).ToListAsync();
return(model);
}
/// <summary>
/// 页面加载初始化
/// </summary>
/// <param name="id">当前用户编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <IndexViewModel> InitIndexPageAsync(long id, ApplicationDbContext context)
{
IndexViewModel webModel = new IndexViewModel();
try
{
webModel.Count = await Repository.Areas.Student.HomeRepository.GetSameCityCountAsync(context);
webModel.Question = Repository.Areas.Student.HomeRepository.GetQuestionCountAsync(context);
webModel.Todo = await Repository.Areas.Student.HomeRepository.GetTodoCountAsync(context);
webModel.ClassCount = await Repository.Areas.Student.HomeRepository.GetClassCountAsync(context);
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
var majorclass = await SchoolRepository.GetMajorClassAsync(user.MajorClassId, context);
var instructor = await PSURepository.GetUserByIdAsync(majorclass.InstructorId, context);
webModel.MyClass = new ClassData
{
Department = majorclass.DepartmentName,
InstructorName = majorclass.InstructorName,
InstructorPhone = instructor.Phone,
InstructorQQ = instructor.QQ.ToString(),
InstructorWechat = string.IsNullOrEmpty(instructor.Wechat) ? "未预留微信号" : instructor.Wechat,
Major = majorclass.MajorName,
Name = majorclass.Name,
QQ = majorclass.QQ,
Session = majorclass.SessionNum + "级",
Wechat = string.IsNullOrEmpty(majorclass.Wechat) ? "未预留微信号" : majorclass.Wechat,
};
var bulletin = await Repository.Areas.Student.HomeRepository.GetBulletinInfo(context);
webModel.BulletinInfo = new BulletinData
{
Id = bulletin.Id.ToString(),
Title = bulletin.Title,
Content = bulletin.Content
};
}
catch (Exception ex)
{
_logger.LogError("首页初始化失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
/// <summary>
/// 选择寝室信息
/// </summary>
/// <param name="id">寝室编号</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public static async Task <BunkInfo> InsertAsync(long id, ApplicationDbContext context)
{
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
var dorm = await DormitoryRepository.GetDormAsync(id, context);
//数据不准确
if (user == null || dorm == null)
{
return(new BunkInfo
{
Id = -1
});
}
// 寝室已被选完
if (dorm.SelectedCount == dorm.Count)
{
return(new BunkInfo
{
Id = -2
});
}
dorm.SelectedCount = Convert.ToInt16(dorm.SelectedCount + 1);
BunkInfo model = new BunkInfo
{
BuildingId = dorm.BuildingId,
BuildingName = dorm.BuildingName,
Chosen = dorm.SelectedCount,
Count = dorm.Count,
DormId = dorm.Id,
DormName = dorm.Name,
Floor = dorm.Floor,
InstructorId = user.InstructorId,
MajorClassId = user.MajorClassId,
MajorClassName = user.MajorClass,
StudentId = user.Id,
StudentName = user.Name,
BunkType = dorm.BunkName,
};
await context.BunkInfo.AddAsync(model);
return(model);
}
/// <summary>
/// 获取学生信息
/// </summary>
/// <param name="id">学生编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <StudentEditViewModel> GetStudentAsync(long id, ApplicationDbContext context)
{
var webModel = new StudentEditViewModel();
try
{
var model = await PSURepository.GetUserByIdAsync(id, context);
webModel.Id = model.Id.ToString();
webModel.Account = model.Account;
webModel.Address = model.Address;
webModel.Age = model.Age;
webModel.Birthday = model.Birthday.ToString("yyyy-MM-dd");
webModel.City = model.City;
webModel.CityId = model.CityId;
webModel.DepartmentId = model.DepartmentId;
webModel.DepartmentName = model.Department;
webModel.District = model.District;
webModel.DistrictId = model.DistrictId;
webModel.Email = model.Email;
webModel.EndDate = model.EndDate.ToString("yyyy-MM-dd");
webModel.StartDate = model.StartDate.ToString("yyyy-MM-dd");
webModel.TicketId = model.TicketId.ToString();
webModel.HighSchool = model.HighSchool;
webModel.Hobbies = model.Hobbies;
webModel.MajorClass = model.MajorClass;
webModel.MajorClassId = model.MajorClassId;
webModel.Province = model.Province;
webModel.ProvinceId = model.ProvinceId;
webModel.Winning = model.Winning;
webModel.IsEnabled = (Enable)(model.IsEnabled ? 1 : 0);
webModel.Name = model.Name;
webModel.QQ = model.QQ.ToString();
webModel.Wechat = model.Wechat;
webModel.Gender = model.Gender;
webModel.IdNumber = model.IdNumber;
webModel.Password = model.Password;
webModel.Phone = model.Phone;
}
catch (Exception ex)
{
_logger.LogError("获取学生数据失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
/// <summary>
/// 新增提问信息
/// </summary>
/// <param name="content">提问内容</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public static async Task <Question> InsertAsync(string content, ApplicationDbContext context)
{
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
var instructor = await PSURepository.GetUserByIdAsync(user.InstructorId, context);
if (user == null || instructor == null)
{
return(new Question
{
Id = -1
});
}
Question model = InsertModel(user, instructor, content);
await context.Question.AddAsync(model);
return(model);
}
/// <summary>
///删除宿舍楼信息
/// </summary>
/// <param name="id">宿舍楼编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> DeleteBuildingAsync(long id, ApplicationDbContext context)
{
try
{
//Delete Building Data
await DormitoryRepository.DeleteAsync(id, context);
//Add Operate Information
var operate = string.Format("删除宿舍楼数据，宿舍楼Id:{0}", id);
PSURepository.InsertRecordAsync("Building", "DormitoryDomain", "DeleteBuildingAsync", operate, (short)PSURepository.OperateCode.Delete, id, context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("删除宿舍楼失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 更新宿舍信息
/// </summary>
/// <param name="webModel">编辑页视图Model</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> UpdateInformationAsync(InformationEditViewModel webModel, ApplicationDbContext context)
{
try
{
//Update Building Data
DormitoryRepository.UpdateAsync(webModel, context);
//Add Operate Information
var operate = string.Format("修改宿舍信息，宿舍编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("Dorm", "DormitoryDomain", "UpdateInformationAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("更新宿舍失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
///删除迎新服务信息
/// </summary>
/// <param name="id">迎新服务编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> DeleteServiceAsync(long id, ApplicationDbContext context)
{
try
{
//Delete Service Data
await AdmissionRepository.DeleteServiceAsync(id, context);
//Add Operate Information
var operate = string.Format("删除迎新服务信息，迎新服务编号:{0}", id);
PSURepository.InsertRecordAsync("Service", "AdmissionDomain", "DeleteServiceAsync", operate, (short)PSURepository.OperateCode.Delete, id, context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("删除迎新服务失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 回复学生疑问信息
/// </summary>
/// <param name="webModel">回复信息页视图Model</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public async Task <bool> ReplyQuestionAsync(QuestionReplyViewModel webModel, ApplicationDbContext context)
{
try
{
//Update Question Data
QuestionRepository.ReplyQuestionAsync(webModel, context);
//Add Operate Information
var operate = string.Format("回复学生疑问信息，学生疑问编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("Question", "QuestionDomain", "ReplyQuestionAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("回复学生疑问失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
///删除学生信息
/// </summary>
/// <param name="id">学生编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> DeleteStudentAsync(long id, ApplicationDbContext context)
{
try
{
//Delete staff Data
await BasicRepository.DeleteStaffAsync(id, context);
//Add Operate Information
var operate = string.Format("删除学生数据，学生编号:{0}", id);
PSURepository.InsertRecordAsync("IdentityUser", "BasicDomain", "DeleteStudentAsync", operate, (short)PSURepository.OperateCode.Delete, id, context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("删除学生失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 更新物品信息
/// </summary>
/// <param name="webModel">编辑页视图Model</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> UpdateGoodsAsync(GoodsEditViewModel webModel, ApplicationDbContext context)
{
try
{
//Update Service Data
AdmissionRepository.UpdateAsync(webModel, context);
//Add Operate Information
var operate = string.Format("修改物品信息，物品编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("Goods", "AdmissionDomain", "UpdateGoodsAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("更新物品信息失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 更新专业班级数据
/// </summary>
/// <param name="webModel">编辑页视图Model</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> UpdateMajorClassAsync(MajorClassEditViewModel webModel, ApplicationDbContext context)
{
try
{
//Update Major Class Data
SchoolRepository.UpdateAsync(webModel, context);
//Add Operate Information
var operate = string.Format("修改专业班级信息，专业班级编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("MajorClass", "SchoolDomain", "UpdateMajorClassAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("更新专业班级失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 更新公告数据
/// </summary>
/// <param name="webModel">公告编辑页视图模型</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public async Task <bool> UpdateBulletinAsync(BulletinEditViewModel webModel, ApplicationDbContext context)
{
try
{
//Update Bulletin Data
HomeRepository.UpdateAsync(Convert.ToInt64(webModel.Id), webModel.Title, (short)webModel.Target, (short)webModel.Type, webModel.Content, context);
//Add Operate Information
var operate = string.Format("修改公告信息，公告编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("Bulletin", "HomeDomain", "UpdateBulletinAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2 ? true : false);
}
catch (Exception ex)
{
_logger.LogError("更新公告数据失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 更新个人信息
/// </summary>
/// <param name="webModel">个人信息页视图Model</param>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public async Task <bool> UpdateProfileAsync(ProfileViewModel webModel, ApplicationDbContext context)
{
try
{
//Update IdentityUser Data
UserRepository.UpdateAsync(webModel, context);
//Add Operate Information
var operate = string.Format("修改个人信息，账户编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("IdentityUser", "UserDomain", "UpdateProfileAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("更新个人信息失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 登录系统
/// </summary>
/// <param name="account"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <IdentityUser> GetUserAsync(string account, string password, ApplicationDbContext context)
{
return(await PSURepository.GetUserAsync(account, context));
}
/// <summary>
/// 判断当前用户名是否存在
/// </summary>
/// <param name="account"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> CheckAccountAsync(string account, ApplicationDbContext context)
{
var model = await PSURepository.GetUserByAccountAsync(account, context);
return(model != null);
}
/// <summary>
/// 获取班级人数
/// </summary>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public static async Task <int> GetClassCountAsync(ApplicationDbContext context)
{
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
return(context.IdentityUser.AsNoTracking().Select(i => i.MajorClassId == user.MajorClassId).ToList().Count());
}
/// <summary>
/// 获取同一城市的人
/// </summary>
/// <param name="context">数据库上下文对象</param>
/// <returns></returns>
public static async Task <int> GetSameCityCountAsync(ApplicationDbContext context)
{
var user = await PSURepository.GetUserByIdAsync(CurrentUser.UserId, context);
return(context.IdentityUser.AsNoTracking().Where(i => i.AccountType == 2 && i.CityId == user.CityId && i.Id != user.Id).ToList().Count());
}
