/// <summary>
/// 初始化超级用户
/// </summary>
/// <returns></returns>
public bool InitSuperUser(NewUserRequest request)
{
bool success = false;
var super = UsersAccessor.GetSuperUser();
string[] codes = PermissionCache.Instance.GetCodeArray();
if (super != null)
{
UserManage manage = new UserManage(super);
success = manage.ModifyTo(new UserModifyState
{
Email = request.Email,
Mobile = request.Mobile,
Name = request.Name,
Title = request.Title,
UserName = request.Username,
Password = request.Password,
Permissions = codes
});
}
else
{
request.Permissions = codes;
NewUser newUser = new NewUser(request, true);
success = newUser.Save();
}
return(success);
}
public bool Save()
{
ThrowExceptionIfValidateFailure();
string permissionCodes = string.Empty;
if (Permissions != null)
{
permissionCodes = string.Join(",", Permissions);
}
//新用户仓储对象
Users user = new Users
{
UserId = ID,
Username = Username,
Name = Name,
Password = EncryptPassword,
Title = Title,
Email = Email,
Mobile = Mobile,
CreateTime = DateTime.Now,
LastTime = DateTime.Now,
LoginCount = 0,
Status = Status,
PermissionCode = permissionCodes,
IsSuper = IsSuper
};
return(UsersAccessor.Add(user, Study));
}
/// <summary>
/// 业务数据检测
/// </summary>
protected override void Validate()
{
//课程标题为空时
if (string.IsNullOrWhiteSpace(Title))
{
AddBrokenRule(NewCourseFailureRule.TITLE_CANNOT_NULL_OR_EMPTY);
}
//课程内容为空时
if (string.IsNullOrWhiteSpace(Content))
{
AddBrokenRule(NewCourseFailureRule.CONTENT_CANNOT_NULL_OR_EMPTY);
}
//学习目标为空时
if (string.IsNullOrWhiteSpace(Objective))
{
AddBrokenRule(NewCourseFailureRule.OBJECTIVE_CANNOT_NULL_OR_EMPTY);
}
//所属科目不存在时
if (!SubjectsAccessor.Exists(SubjectId))
{
AddBrokenRule(NewCourseFailureRule.SUBJECT_NOT_EXISTS);
}
//创建课程的用户不存在时
if (!UsersAccessor.Exists(UserId))
{
AddBrokenRule(NewCourseFailureRule.CREATER_NOT_EXISTS);
}
}
/// <summary>
/// 搜索学习计划信息
/// </summary>
/// <param name="pageSize"></param>
/// <param name="pageIndex"></param>
/// <param name="keyword"></param>
/// <param name="status"></param>
/// <returns></returns>
public PagerModel <StudyPlanResponse> Search(int pageSize, int pageIndex, string keyword, int?status)
{
StudyPlanSearch search = new StudyPlanSearch(pageIndex, pageSize, keyword, status);
var result = search.Search();
var userIds = result.Table.Select(p => p.UserId);
var names = UsersAccessor.GetUsernames(userIds);
List <StudyPlanResponse> list = new List <StudyPlanResponse>();
foreach (var item in result.Table)
{
var temp = new StudyPlanResponse(item);
string userName = names.ContainsKey(item.UserId) ? names[item.UserId] : string.Empty;
temp.Creator = userName;
list.Add(temp);
}
return(new PagerModel <StudyPlanResponse>
{
Count = result.Count,
Index = result.Index,
Size = result.Size,
Table = list
});
}
UserSessionStorage CreateStorage()
{
if (user.IsGuest)
{
var storage = new UserSessionStorage();
return(storage);
}
var data = UsersAccessor.Get(user.UserId);
if (data != null)
{
try
{
var storage = new UserSessionStorage();
storage.SessionId = data.UserId;
storage.Username = data.Username;
storage.Mobile = data.Mobile;
storage.Email = data.Email;
storage.Title = data.Title;
storage.Name = data.Name;
storage.Password = data.Password;
storage.PermissionCode = data.PermissionCode;
return(storage);
}
catch
{
user.Logout();
}
}
user.Logout();
return(new UserSessionStorage());
}
/// <summary>
/// 获取学员集合
/// </summary>
/// <returns></returns>
private List <Student> GetStudents()
{
ThrowExceptionIfValidateFailure();
var tempStudents = new List <Student>();
//获取学员学习计划集合
var studentPlans = UserStudyPlanAccessor.GetStudentStudyPlans(ID);
//学员ID集合
var studentIds = studentPlans.Select(p => p.UserId).ToArray();
//根据学员ID集合获取学员信息
var students = UsersAccessor.GetUserList(studentIds);
foreach (var user in students)
{
var plan = studentPlans.FirstOrDefault(p => p.UserId == user.UserId);
tempStudents.Add(new Student
{
UserId = user.UserId,
Email = user.Email,
Mobile = user.Mobile,
Title = user.Title,
Name = user.Name,
Username = user.Username,
StudyStatus = plan.Status,
Progress = plan.Progress,
LastStudyTime = plan.UpdateTime
});
}
return(tempStudents);
}
public override void Execute()
{
Validate();
var state = State as UserSignedEventState;
UsersAccessor.UpdateSignInfo(state.UserId, state.SignedTime);
}
/// <summary>
/// Аутентификацию пользователя
/// </summary>
/// <param name="user">Пользователь</param>
/// <param name="usersAccessor">Класс доступа к данным о пользователях</param>
/// <returns>Статус аутентификации. True - успешная аутентификация</returns>
internal static bool Login(this UserEntity user, UsersAccessor usersAccessor)
{
var isCorrectUser = usersAccessor.IsCorrectUser(user);
if (!isCorrectUser) return false;
FormsAuthentication.SetAuthCookie(user.Login, false);
return true;
}
/// <summary>
/// 将<see cref="ExamUsers"/>类型转换为<see cref="UserExamSearchResultItem"/>类型数据
/// </summary>
/// <param name="sourceData"><see cref="ExamUsers"/>源数据</param>
/// <returns></returns>
public IEnumerable <UserExamSearchResultItem> ConvertToSearchResult(IEnumerable <ExamUsers> sourceData)
{
if (sourceData == null)
{
yield break;
}
//得到用户集合
long[] userIds = sourceData.Select(p => p.UserId).ToArray();
var users = UsersAccessor.GetSimpleUsers(userIds);
//得到考卷模板集合
long[] examIds = sourceData.Select(p => p.ExamId).ToArray();
var exams = ExamsAccessor.GetSimpleExams(examIds);
//循环处理
foreach (var item in sourceData)
{
var user = users.FirstOrDefault(p => p.UserId == item.UserId);
var exam = exams.FirstOrDefault(p => p.ExamId == item.ExamId);
var result = new UserExamSearchResultItem
{
UserExamId = item.Id,
UserId = item.UserId,
ExamId = item.ExamId,
ActualTime = item.Times,
MarkingStatus = item.MarkingStatus,
MarkingTime = item.MarkingTime,
CreateTime = item.CreateTime,
PostTime = item.PostTime,
Score = item.Total
};
if (user != null)
{
result.UserMobile = user.Mobile;
result.UserName = user.Name;
result.UserTitle = user.Title;
}
if (exam != null)
{
result.ExamTitle = exam.Title;
result.ExamType = exam.ExamType;
result.MaxTime = exam.Time;
result.Total = exam.Total;
result.Pass = exam.Pass;
}
yield return(result);
}
}
/// <summary>
/// 转换数据
/// </summary>
/// <param name="userPlans">用户学习计划情况集合</param>
/// <returns></returns>
private List <UserStudyPlanSearchResultItem> TransferData(IEnumerable <Data.Entity.UserStudyPlan> userPlans)
{
if (userPlans == null || userPlans.Count() < 1)
{
return(new List <UserStudyPlanSearchResultItem>());
}
//用户学习计划ID集合
var planIds = userPlans.Select(p => p.PlanId).ToArray();
//获取所有的学习计划
var plans = StudyPlanAccessor.GetList(planIds);
if (plans == null || plans.Count() < 1)
{
return(null);
}
//计划制定者ID集合
var creatorIds = plans.Select(p => p.UserId);
//获取制定者名称集合
var creatorNames = UsersAccessor.GetUsernames(creatorIds);
var list = new List <UserStudyPlanSearchResultItem>();
foreach (var plan in plans)
{
//用户学习计划执行情况
var userPlan = userPlans.FirstOrDefault(p => p.PlanId == plan.PlanId);
//制定者名称
var creatorName = creatorNames[plan.UserId];
list.Add(new UserStudyPlanSearchResultItem
{
UserId = userPlan.UserId,
PlanId = plan.PlanId,
Title = plan.Title,
Content = plan.Content,
CreatorId = plan.UserId,
Creator = creatorName,
StudentCount = plan.Student,
PlanStatus = plan.Status,
CreateTime = plan.CreateTime,
StudyStatus = userPlan.Status,
Progress = userPlan.Progress,
LastStudyTime = userPlan.UpdateTime
});
}
return(list);
}
public NewsService()
{
UsersAccessor = new UsersAccessor();
Mapper.CreateMap<UserEntity, UserDto>();
Mapper.CreateMap<UserDto, UserEntity>();
NewsPostsAccessor = new NewsPostsAccessor();
Mapper.CreateMap<NewsPostEntity, NewsPostDto>();
Mapper.CreateMap<NewsPostDto, NewsPostEntity>();
LogsAccessor = new LogsAccessor();
Mapper.CreateMap<LogEntity, LogDto>();
Mapper.CreateMap<LogDto, LogEntity>();
}
/// <summary>
/// 执行搜索
/// </summary>
public PagerModel <Users> Search()
{
this.ThrowExceptionIfValidateFailure();
PagerModel <Users> pager = new PagerModel <Users>()
{
Index = PageIndex,
Size = PageSize
};
UsersAccessor.Get(pager, Keyword, Status);
return(pager);
}
/// <summary>
/// 设置为禁用状态
/// </summary>
public bool SetDisabled()
{
//如果用户信息验证失败，则抛出异常
ThrowExceptionIfValidateFailure(() =>
{
//不允许设置为禁用时，抛出错误异常
if (!CanSetDisabled())
{
AddBrokenRule(UserAccountFailureRules.CANNET_SET_DISABLED);
}
});
return(UsersAccessor.SetStatus(ID, (int)UserStatus.DISABLED));
}
protected override void Validate()
{
//计划制定者不存在
if (!UsersAccessor.Exists(StudyPlan.UserId))
{
AddBrokenRule(NewStudyPlanFailureRule.CREATOR_NOT_EXISTS);
}
//标题为空
if (string.IsNullOrWhiteSpace(StudyPlan.Title))
{
AddBrokenRule(NewStudyPlanFailureRule.TITLE_CANNOT_EMPTY);
}
//标题已存在
if (StudyPlanAccessor.Exists(StudyPlan.Title))
{
AddBrokenRule(NewStudyPlanFailureRule.TITLE_CANNOT_REPEAT);
}
//计划内容说明为空
if (string.IsNullOrWhiteSpace(StudyPlan.Content))
{
AddBrokenRule(NewStudyPlanFailureRule.CONTENT_CANNOT_EMPTY);
}
//未指定学员
if (_studentIds == null || _studentIds.Count() < 1)
{
AddBrokenRule(NewStudyPlanFailureRule.STUDENTS_CANNOT_EMPTY);
}
//未指定关联课程
if (_courseIds == null || _courseIds.Count() < 1)
{
AddBrokenRule(NewStudyPlanFailureRule.COURSE_CANNOT_EMPTY);
}
//并非所有课程都存在
if (!CourseAccessor.AllExists(_courseIds))
{
AddBrokenRule(NewStudyPlanFailureRule.PARTOF_COURSE_NOT_EXSITS);
}
}
/// <summary>
/// 获取并转换为<see cref="ExamsDetails"/>类型数据对象
/// </summary>
/// <returns></returns>
public ExamsDetails ConvertToExamsDetails()
{
if (Exams == null)
{
return(null);
}
var details = new ExamsDetails
{
ExamId = Exams.ExamId,
ExamType = Exams.ExamType,
Title = Exams.Title,
Remarks = Exams.Remarks,
Time = Exams.Time,
Total = Exams.Total,
Pass = Exams.Pass,
Status = Exams.Status,
UserId = Exams.UserId,
UseCount = Exams.UseCount,
Answers = Exams.Answers,
Radio = Exams.Radio,
RedioTotal = Exams.RedioTotal,
Multiple = Exams.Multiple,
MultipleTotal = Exams.MultipleTotal,
Judge = Exams.Judge,
JudgeTotal = Exams.JudgeTotal,
Filling = Exams.Filling,
FillingTotal = Exams.FillingTotal,
Ask = Exams.Ask,
AskTotal = Exams.AskTotal,
CreateTime = Exams.CreateTime,
StartTime = Exams.StartTime,
EndTime = Exams.EndTime
};
details.CreatorName = UsersAccessor.GetUsernameFor(Exams.UserId);
details.Questions = SimpleQuestions;
details.Courses = DicCoursesTitle;
return(details);
}
/// <summary>
/// 申请登陆
/// </summary>
/// <param name="name">账户名</param>
/// <param name="password">登陆密码</param>
/// <param name="effectiveTime">保存时间</param>
/// <param name="isAdmin">是否管理员登陆</param>
/// <returns></returns>
private EnumLoginState ApplyLogin(string name, string password, int effectiveTime, bool isAdmin)
{
if (string.IsNullOrEmpty(name))
{
return(EnumLoginState.AccountError);
}
Users user = new Users();
if (name.Contains("@"))
{
user = UsersAccessor.GetByEmail(name);
}
else
{
user = UsersAccessor.GetByMobile(name);
}
if (user == null)
{
return(EnumLoginState.AccountError);
}
if (!string.Equals(user.Password, Strings.PasswordEncrypt(password)))
{
return(EnumLoginState.PasswordError);
}
UserId = user.UserId;
Password = user.Password;
Username = user.Username;
Mobile = user.Mobile;
Email = user.Email;
CurrentLoginTime = DateTime.Now;
PermissionCode = user.PermissionCode;
SaveLogin(this, effectiveTime);
SessionBag.Refresh();
SessionBag.CopyValue();
//更新用户登陆次数
//更新在线数据
return(EnumLoginState.Succeed);
}
/// <summary>
/// 获取指定学员的学习进度信息
/// </summary>
/// <returns></returns>
private Student GetStudent(long studentId)
{
Student student = null;
if (Students != null)
{
student = Students.FirstOrDefault(p => p.UserId == studentId);
}
else
{
//该学员的学习计划
var userPlan = UserStudyPlanAccessor.Get(ID, studentId);
//学习信息
var user = UsersAccessor.Get(studentId);
ThrowExceptionIfValidateFailure(() =>
{
if (userPlan == null)
{
AddBrokenRule(StudyPlanEditFailureRule.STUDENT_NOT_EXISTS);
}
});
return(new Student
{
UserId = studentId,
Email = user.Email,
Mobile = user.Mobile,
Username = user.Username,
Name = user.Name,
Title = user.Title,
StudyStatus = userPlan.Status,
Progress = userPlan.Progress,
LastStudyTime = userPlan.UpdateTime
});
}
return(student);
}
/// <summary>
/// 重置用户登录密码
/// </summary>
/// <param name = "newWord" > </param>
/// <returns> </returns>
public bool ResetPassword(string newWord)
{
//如果用户信息验证失败，则抛出异常
ThrowExceptionIfValidateFailure(() =>
{
//新密码不能为空
if (string.IsNullOrWhiteSpace(newWord))
{
AddBrokenRule(UserAccountFailureRules.NEW_PASSWORD_CANNOT_NULL);
}
});
string encryptPwd = newWord.PasswordEncrypt();
//重置后的密码与重置前密码一致，则无须修改
if (encryptPwd.Equals(UserInfo.Password, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(UsersAccessor.ResetPassword(ID, encryptPwd));
}
/// <summary>
/// 修改用户登录密码
/// </summary>
/// <param name = "oldWord" > </param>
/// <param name = "newWord" > </param>
/// <returns> </returns>
public bool ModifyPassword(string oldWord, string newWord)
{
bool success = false;
//如果用户信息验证失败，则抛出异常
ThrowExceptionIfValidateFailure(() =>
{
//新密码不能为空
if (string.IsNullOrWhiteSpace(newWord))
{
AddBrokenRule(UserAccountFailureRules.NEW_PASSWORD_CANNOT_NULL);
}
//验证旧密码是否正确
else if (string.IsNullOrWhiteSpace(oldWord) || !oldWord.PasswordEncrypt()
.Equals(UserInfo.Password, StringComparison.OrdinalIgnoreCase))
{
AddBrokenRule(UserAccountFailureRules.OLD_PASSWORD_CHECK_FAILURE);
}
});
//新旧密码不一致时，将新密码更新到数据库
if (!oldWord.Equals(newWord))
{
string encryptPwd = newWord.PasswordEncrypt();
if (encryptPwd.Equals(UserInfo.Password, StringComparison.OrdinalIgnoreCase))
{
success = true;
}
else
{
success = UsersAccessor.ResetPassword(ID, encryptPwd);
}
}
return(success);
}
/// <summary>
/// 是否已存在超级用户
/// </summary>
/// <returns></returns>
public bool HasSuper()
{
return(UsersAccessor.HasSuperUser());
}
/// <summary>
/// 检测手机号是否被使用
/// </summary>
/// <returns></returns>
public bool CheckForMobile()
{
return(UsersAccessor.MobileExists(Mobile));
}
/// <summary>
/// 检测邮箱是否被使用
/// </summary>
/// <returns></returns>
public bool CheckForEmail()
{
return(UsersAccessor.EmailExists(Email));
}
/// <summary>
/// 检测用户名是否被使用
/// </summary>
/// <returns></returns>
public bool CheckForUsername()
{
return(UsersAccessor.UsernameExists(Username));
}
/// <summary>
/// 实例化<see cref="CourseStudy"/>对象
/// </summary>
/// <param name="studentId">学员ID</param>
/// <param name="chapterId">学习的课程章节ID</param>
public CourseStudy(long studentId, long chapterId)
{
Chapter = ChapterAccessor.Get(chapterId);
Student = UsersAccessor.Get(studentId);
}
/// <summary>
/// 实例化<see cref="CourseStudy"/>对象
/// </summary>
/// <param name="chapter">课程章节</param>
/// <param name="studentId">学员ID</param>
public CourseStudy(long studentId, Data.Entity.Chapter chapter)
{
Chapter = chapter;
Student = UsersAccessor.Get(studentId);
}
/// <summary>
/// 修改资料
/// </summary>
/// <param name = "state" > 用户名 </param>
/// <returns> </returns>
public bool ModifyTo(UserModifyState state)
{
ThrowExceptionIfValidateFailure(() =>
{
//编辑的内容为NULl
if (state == null)
{
AddBrokenRule(UserAccountFailureRules.MODIFYSTATE_CANNOT_NULL);
}
else
{
// 用户名不能为空
if (string.IsNullOrWhiteSpace(state.UserName))
{
AddBrokenRule(UserAccountFailureRules.USERNAME_REQUIRE);
}
// 姓名不能为空
else if (string.IsNullOrWhiteSpace(state.Name))
{
AddBrokenRule(UserAccountFailureRules.NAME_REQUIRE);
}
// Email不能为空且格式要正确
else if (!state.Email.IsEmail())
{
AddBrokenRule(UserAccountFailureRules.EMAIL_ERROR);
}
// 手机号不能为空且格式要正确
else if (!state.Mobile.IsCnPhone())
{
AddBrokenRule(UserAccountFailureRules.MOBILE_ERROR);
}
// 用户名被使用
else if (UsersAccessor.UsernameExists(state.UserName, ID))
{
AddBrokenRule(UserAccountFailureRules.USERNAME_EXISTS);
}
// 邮箱被使用
else if (UsersAccessor.EmailExists(state.Email, ID))
{
AddBrokenRule(UserAccountFailureRules.EMAIL_EXISTS);
}
// 手机号被使用
else if (UsersAccessor.MobileExists(state.Mobile, ID))
{
AddBrokenRule(UserAccountFailureRules.MOBILE_EXISTS);
}
}
});
//权限编号序列组
string permissionCodes = string.Empty;
if (state.Permissions != null)
{
permissionCodes = string.Join(",", state.Permissions);
}
bool success = false;
if (state.IsModifyBySelf)
{
success = UsersAccessor.UpdateFor(ID, state.UserName, state.Email, state.Mobile, state.Title, state.Name);
}
else if (string.IsNullOrWhiteSpace(state.Password))
{
success = UsersAccessor.UpdateFor(ID, state.UserName, state.Email, state.Mobile, state.Title, state.Name, permissionCodes);
}
else
{
success = UsersAccessor.UpdateFor(ID, state.UserName, state.Email, state.Mobile, state.Title, state.Name, state.EncryptPassword, permissionCodes);
}
return(success);
}
protected override void Validate()
{
//题目创建用户不存在
if (!UsersAccessor.Exists(UserId))
{
AddBrokenRule(NewQuestionFailureRule.QUESTION_CREATOR_NOT_EXISTS);
}
//题目所属课程不存在
if (!CourseAccessor.Exists(CourseId))
{
AddBrokenRule(NewQuestionFailureRule.COURSE_NOT_EXISTS);
}
//题目类型无效
if (!((IList <int>)Enum.GetValues(typeof(QuestionType))).Contains(Type))
{
AddBrokenRule(NewQuestionFailureRule.QUESTION_TYPE_ERROR);
}
//题目标题不能为空
if (string.IsNullOrWhiteSpace(Topic))
{
AddBrokenRule(NewQuestionFailureRule.TOPIC_CANNOT_EMPTY);
}
// 如果->非问答题且答案项为NULL，则抛出错误；
// 否则->题目类型与答案项进能校验，校验规则如下：
// 1、匹配，则验证答案项设置是否有效
// 2、不匹配，则添加业务错误
if (Type != (int)QuestionType.ESSAY_QUESTION && AnswerOptions == null)
{
AddBrokenRule(NewQuestionFailureRule.ANSWER_OPTIONS_CANNOT_EMPTY);
}
else if (QuestionTools.CheckAnswerOptionsType(AnswerOptions, Type))
{
//题目的答案项验证失败
if (!AnswerOptions.Validate())
{
if (AnswerOptions is SingleChoiceAnswer)
{
AddBrokenRule(NewQuestionFailureRule.SINGLE_CHOICE_ANSWER_OPTIONS_ERROR);
}
else if (AnswerOptions is MultipleChoiceAnswer)
{
AddBrokenRule(NewQuestionFailureRule.MULTIPLE_CHOICE_ANSWER_OPTIONS_ERROR);
}
else if (AnswerOptions is TrueFalseAnswer)
{
AddBrokenRule(NewQuestionFailureRule.TRUE_FALSE_ANSWER_OPTIONS_ERROR);
}
else if (AnswerOptions is GapFillingAnswer)
{
AddBrokenRule(NewQuestionFailureRule.GAP_FILLING_ANSWER_OPTIONS_ERROR);
}
}
}
else
{
AddBrokenRule(NewQuestionFailureRule.QUESTION_TYPE_AND_ANSWER_OPTIONS_REGEX_FAILURE);
}
}
/// <summary>
/// 获取指定用户的简要数据集合
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
public List <UserSimpleInfo> GetSimpleUsers(int?status = null)
{
return(UsersAccessor.GetSimpleUsers(status));
}
