public void UserController_Put_UserServiceReturnsNull()
{
//Arrange
UserDomainModel nullUser = null;
Task <UserDomainModel> nullDomainModel = Task.FromResult(nullUser);
Task <UserDomainModel> userDomainModel = Task.FromResult(_userDomainModel);
string expectedMessage = Messages.USER_NOT_FOUND;
int expectedStatusCode = 400;
ErrorResponseModel errorResponseModel = new ErrorResponseModel();
errorResponseModel.ErrorMessage = expectedMessage;
errorResponseModel.StatusCode = System.Net.HttpStatusCode.InternalServerError;
UsersController usersController = new UsersController(_mockUserService.Object);
_mockUserService.Setup(x => x.UpdateUser(It.IsAny <UserDomainModel>())).Returns(userDomainModel);
_mockUserService.Setup(x => x.GetUserByIdAsync(It.IsAny <Guid>())).Returns(nullDomainModel);
//Act
var result = usersController.Put(_userDomainModel.Id, _createUserModel).ConfigureAwait(false).GetAwaiter().GetResult();
ObjectResult viewResult = (ObjectResult)result;
var messageResult = (ErrorResponseModel)viewResult.Value;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(expectedMessage, messageResult.ErrorMessage);
Assert.AreEqual(expectedStatusCode, (int)messageResult.StatusCode);
}
/// <summary>
/// 根据ID获取用户领域模型。
/// </summary>
/// <param name="userId"></param>
/// <param name="clear"></param>
/// <returns></returns>
public UserDomainModel GetUserDomainModelById(string userId, bool clear)
{
if (string.IsNullOrEmpty(userId))
{
return(null);
}
string cacheKey = CacheKey.GetKeyDefine(CacheKey.USERDOMAIN_INFO, userId);
UserDomainModel result = CacheUtil.Get <UserDomainModel>(cacheKey);
if (result == null || clear)
{
UserInfoModel basicInfo = GetUserModelByIdFromDatabase(userId);
if (basicInfo != null)
{
result = new UserDomainModel();
result.BasicInfo = basicInfo;
result.InGroupList = UserGroupInfoService.Instance.GetUserInGroupListFromDatabase(basicInfo.UserId);
CacheUtil.Set(cacheKey, result);
}
}
return(result);
}
public async Task <IEnumerable <UserDomainModel> > GetAllAsync()
{
var data = await _usersRepository.GetAll();
if (data == null)
{
return(null);
}
List <UserDomainModel> result = new List <UserDomainModel>();
UserDomainModel model;
foreach (var item in data)
{
model = new UserDomainModel
{
Id = item.Id,
FirstName = item.FirstName,
LastName = item.LastName,
UserName = item.UserName,
IsAdmin = item.IsAdmin,
IsSuperUser = item.IsSuperUser,
IsUser = item.IsUser,
BonusPoints = item.BonusPoints
};
result.Add(model);
}
return(result);
}
public void UpdateUser(UserDomainModel user)
{
var updateUser = mapper.Map <ApplicationUser>(user);
userRepository.UpdateUser(updateUser);
userRepository.Save();
}
public void Get_User_By_UserName_Return_Successful()
{
UserDomainModel userDomainModel = new UserDomainModel
{
Id = 1,
UserRole = 0,
FirstName = "milos",
LastName = "milosevic",
UserName = "******"
};
Task <UserDomainModel> responseTask = Task.FromResult(userDomainModel);
int expectedStatusCode = 200;
_userService = new Mock <IUserService>();
_userService.Setup(x => x.GetUserByUserName(It.IsAny <string>())).Returns(responseTask);
UsersController usersController = new UsersController(_userService.Object);
//Act
var result = usersController.GetbyUserNameAsync(userDomainModel.UserName).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultObject = ((OkObjectResult)result).Value;
var userDomainModelResult = (UserDomainModel)resultObject;
//Assert
Assert.IsNotNull(userDomainModelResult);
Assert.AreEqual(userDomainModel.Id, userDomainModelResult.Id);
Assert.AreEqual(userDomainModel.UserName, userDomainModelResult.UserName);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
/// <summary>
/// 用户注册命令处理
/// </summary>
/// <param name="request">用户注册命令模型</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <bool> Handle(UserRegisterCommandModel request, CancellationToken cancellationToken)
{
//验证
if (!request.IsValid())
{
await HandleValidateFailedAsync(request);
return(await Task.FromResult(false));
}
//判断
if (_repository.GetByMobileAsync(request.Mobile) != null)
{
await HandleFailedAsync(new NotificationModel(nameof(UserRegisterCommandModel), "该手机号已被注册!"));
return(await Task.FromResult(false));
}
var user = new UserDomainModel(0, request.UserName, request.Password, request.Mobile, request.NickName, request.AvatarPath);
await _repository.AddAsync(user);
//提交才会真正保存到数据库
if (await CommitAsync() > 0)
{
await HandleSucceedAsync(new UserRegisteredEventModel(user.Id, user.UserName, user.Password, user.Mobile, user.NickName, user.AvatarPath));
}
return(await Task.FromResult(true));
}
public void Get_Async_Return_User_By_Id()
{
//Arrange
UserDomainModel userDomainModel = new UserDomainModel
{
Id = Guid.NewGuid(),
FirstName = "milos",
LastName = "milosevic",
IsAdmin = true,
Points = 50,
RoleId = 20,
UserName = "******"
};
Task <UserDomainModel> responseTask = Task.FromResult(userDomainModel);
int expectedStatusCode = 200;
_userService = new Mock <IUserService>();
_userService.Setup(x => x.GetUserByIdAsync(It.IsAny <Guid>())).Returns(responseTask);
UsersController usersController = new UsersController(_userService.Object);
//Act
var result = usersController.GetbyIdAsync(userDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultValue = ((OkObjectResult)result).Value;
var userDomainModelResult = (UserDomainModel)resultValue;
//Assert
Assert.IsNotNull(userDomainModelResult);
Assert.AreEqual(userDomainModel.Id, userDomainModelResult.Id);
Assert.AreEqual(userDomainModel.RoleId, userDomainModelResult.RoleId);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void UserController_Post_UserServiceReturnsNull()
{
//Arrange
UserDomainModel nullDomainModel = null;
Task <UserDomainModel> nullTask = Task.FromResult(nullDomainModel);
string expectedMessage = Messages.USER_CREATION_ERROR;
int expectedStatusCode = 500;
ErrorResponseModel errorResponseModel = new ErrorResponseModel();
errorResponseModel.ErrorMessage = expectedMessage;
errorResponseModel.StatusCode = System.Net.HttpStatusCode.InternalServerError;
UsersController usersController = new UsersController(_mockUserService.Object);
_mockUserService.Setup(x => x.AddUser(It.IsAny <UserDomainModel>())).Returns(nullTask);
//Act
var result = usersController.Post(_createUserModel).ConfigureAwait(false).GetAwaiter().GetResult();
ObjectResult viewResult = (ObjectResult)result;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(viewResult.Value.ToString(), errorResponseModel.ToString());
Assert.AreEqual(viewResult.StatusCode, expectedStatusCode);
}
public async Task <UserDomainModel> DeleteUserById(Guid userId)
{
var reservationData = await _reservationService.DeleteByUserId(userId);
if (reservationData == null)
{
return(null);
}
var userData = _usersRepository.Delete(userId);
if (userData == null)
{
return(null);
}
_usersRepository.Save();
UserDomainModel domainModel = new UserDomainModel
{
Id = userData.Id,
FirstName = userData.FirstName,
LastName = userData.LastName,
UserName = userData.UserName,
IsAdmin = userData.IsAdmin,
IsSuperUser = userData.IsSuperUser,
IsUser = userData.IsUser,
BonusPoints = userData.BonusPoints
};
return(domainModel);
}
public async Task <ActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
var userModel = new UserModel(model.Password, model.Name, model.Email, model.Line1, model.Line2, model.City, model.State, model.Country, model.ZipCode);
UserDomainModel userDomain = new UserDomainModel();
userDomain.AddUser(userModel);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <object> UserSave(UserDomainModel command)
{
try
{
var result = await Task.FromResult(_userHandler.Handle(command));
if (result.Equals(EnumValidate.Exist))
{
return(Response("E-mail already exists", HttpStatusCode.NotAcceptable));
}
if (result.Equals(EnumValidate.Invalid))
{
return(Response("Invalid fields", HttpStatusCode.BadRequest));
}
if (result.Equals(EnumValidate.Empty))
{
return(Response("Missing fields", HttpStatusCode.BadRequest));
}
_uow.Commit();
return(Response("User Save Success", HttpStatusCode.OK));
}
catch
{
return(Response("Error Aplication", HttpStatusCode.InternalServerError));
}
}
public void TestInitialize()
{
_userDomainModel = new UserDomainModel
{
Id = Guid.NewGuid(),
FirstName = "David",
LastName = "Strbac",
UserName = "******",
BonusPoints = 0,
IsAdmin = false,
IsSuperUser = false,
IsUser = true
};
_createUserModel = new CreateUserModel
{
FirstName = "David",
LastName = "Strbac",
UserName = "******"
};
List <UserDomainModel> userList = new List <UserDomainModel>();
userList.Add(_userDomainModel);
IEnumerable <UserDomainModel> users = userList;
Task <IEnumerable <UserDomainModel> > responseTask = Task.FromResult(users);
_mockUserService = new Mock <IUserService>();
}
public void Get_User_By_UserName_Return_Not_Found()
{
//Arrange
UserDomainModel userDomainModel = null;
string expectedMessage = Messages.USER_NOT_FOUND;
Task <UserDomainModel> responseTask = Task.FromResult(userDomainModel);
int expectedStatusCode = 404;
_userService = new Mock <IUserService>();
_userService.Setup(x => x.GetUserByUserName(It.IsAny <string>())).Returns(responseTask);
UsersController usersController = new UsersController(_userService.Object);
//Act
var result = usersController.GetbyUserNameAsync("asd").ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultObject = ((NotFoundObjectResult)result).Value;
var messageReturned = (string)resultObject;
//Assert
Assert.IsNotNull(messageReturned);
Assert.AreEqual(expectedMessage, messageReturned);
Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
Assert.AreEqual(expectedStatusCode, ((NotFoundObjectResult)result).StatusCode);
}
public async Task <string> AddUpdateUser(UserVM userVM)
{
UserDomainModel userDM = new UserDomainModel();
AutoMapper.Mapper.Map(userVM, userDM);
return(await userBusiness.AddUpdateUser(userDM));
}
public void TestInitialize()
{
_user = new User
{
Id = Guid.NewGuid(),
FirstName = "Uros",
LastName = "Markov",
IsAdmin = false,
Points = 2900,
RoleId = 2,
UserName = "******"
};
_userDomainModel = new UserDomainModel
{
Id = _user.Id,
FirstName = _user.FirstName,
LastName = _user.LastName,
IsAdmin = _user.IsAdmin,
Points = _user.Points,
RoleId = _user.RoleId,
UserName = _user.UserName
};
_mockUserRepository = new Mock <IUsersRepository>();
_mockRoleRepository = new Mock <IRolesRepository>();
_userService = new UserService(_mockUserRepository.Object);
}
private UserViewModel GetUserViewModel(string whereCondition, int?page)
{
UserViewModel userListViewModel = new UserViewModel();
PagingInfo <UserDomainModel> userPaging = null;
var userList = _userLogic.GetUserByWhereCondition(whereCondition);
var enumerable = userList as IList <User> ?? userList.ToList();
if (enumerable.Any())
{
var listmodel = new List <UserDomainModel>();
foreach (var user in enumerable)
{
var usermodel = new UserDomainModel();
ConvertModel.ConvertMoudle(user, usermodel);
listmodel.Add(usermodel);
}
userPaging = new PagingInfo <UserDomainModel>(PageSize, listmodel)
{
PageIndex = page ?? 1
};
userListViewModel.Users = userPaging.GetPagingData();
}
userListViewModel.PagingInfo = userPaging;
userListViewModel.User = new UserDomainModel();
return(userListViewModel);
}
/// <summary>
/// 设置用户在组内的角色
/// </summary>
/// <param name="roleInGroup">0:成员，1：负责人</param>
/// <param name="groupId"></param>
/// <param name="userId"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool SetGroupUserRoleInGroup(int roleInGroup, string groupId, string userId, out string message)
{
bool result = false;
message = "操作失败，请与管理员联系";
if (string.IsNullOrEmpty(groupId) || string.IsNullOrEmpty(userId))
{
message = "参数错误，请与管理员联系";
return(false);
}
if (GetUserGroupList(false).ContainsKey(groupId) == false)
{
message = "参数错误，不存在的用户组ID";
return(false);
}
UserDomainModel user = UserInfoService.Instance.GetUserDomainModelById(userId, false);
if (user == null)
{
message = "操作失败，尝试操作不存在的用户ID";
return(false);
}
string sql = "UPDATE rel_user_group SET role_in_group = 0 WHERE group_id = $group_id$";
string sql2 = "UPDATE rel_user_group SET role_in_group = 1 WHERE user_id = $user_id$ AND group_id = $group_id$";
ParameterCollection pc = new ParameterCollection();
pc.Clear();
pc.Add("user_id", userId);
pc.Add("group_id", groupId);
try
{
BeginTransaction();
ExecuteNonQuery(sql, pc);
if (ExecuteNonQuery(sql2, pc) == 1)
{
CommitTransaction();
message = "成功设置选中用户在本组内角色";
return(true);
}
RollbackTransaction();
}
catch (Exception ex)
{
RollbackTransaction();
LogUtil.Error("设置用户在组内角色异常", ex);
throw ex;
}
return(result);
}
public static UserViewModel MapFrom(UserDomainModel domainModel)
{
return(new UserViewModel
{
FirstName = domainModel.FirstName,
LastName = domainModel.LastName,
Email = domainModel.Email
});
}
public static UserDatabaseModel MapFrom(UserDomainModel domainModel)
{
return(new UserDatabaseModel
{
Id = domainModel.Id,
FirstName = domainModel.FirstName,
LastName = domainModel.LastName,
Email = domainModel.Email,
Password = domainModel.Password
});
}
public bool RemoveGroupUserById(string groupId, string userId, out string message)
{
bool result = false;
message = "操作失败，请与管理员联系";
if (string.IsNullOrEmpty(groupId) || string.IsNullOrEmpty(userId))
{
message = "参数错误，请与管理员联系";
return(false);
}
if (GetUserGroupList(false).ContainsKey(groupId) == false)
{
message = "参数错误，不存在的用户组ID";
return(false);
}
UserDomainModel user = UserInfoService.Instance.GetUserDomainModelById(userId, false);
if (user == null)
{
message = "操作失败，尝试操作不存在的用户ID";
return(false);
}
string sql = "DELETE FROM rel_user_group WHERE user_id = $user_id$ AND group_id = $group_id$";
ParameterCollection pc = new ParameterCollection();
pc.Clear();
pc.Add("user_id", userId);
pc.Add("group_id", groupId);
try
{
BeginTransaction();
if (ExecuteNonQuery(sql, pc) == 1)
{
CommitTransaction();
message = "成功移除选中用户";
result = true;
}
}
catch (Exception ex)
{
RollbackTransaction();
LogUtil.Error("移除用户组用户异常", ex);
throw ex;
}
return(result);
}
public async Task <IHttpActionResult> GetUserById(int id)
{
UserToReturnVM userToReturnVM = new UserToReturnVM();
UserDomainModel userDomainModel = await userBusiness.GetUserById(id);
if (userDomainModel.user_id > 0)
{
AutoMapper.Mapper.Map(userDomainModel, userToReturnVM);
return(Ok(userToReturnVM));
}
return(Ok(404));
}
public bool AuthenticateUser(UserDomainModel user)
{
//Actual Database logic goes here
if (user.UserName.ToLower() == "admin" && user.Password == "admin")
{
return(true);
}
else
{
return(false);
}
}
public UserDomainModel GetUser(string key)
{
UserDomainModel userToCheck = _httpContextAccessor.HttpContext.Session.GetObject <UserDomainModel>(key);
if (userToCheck == null)
{
SetUser(key, new UserDomainModel());
userToCheck = _httpContextAccessor.HttpContext.Session.GetObject <UserDomainModel>(key);
}
return(userToCheck);
}
public ActionResult Create(UserDomainModel model)
{
User user = new User();
ConvertModel.ConvertMoudle(model, user);
if (model.UserId == 0)
{
_userLogic.Create(user);
}
else
{
_userLogic.Edit(user);
}
return(RedirectToAction("Management"));
}
/// <summary>
/// 根据用户ID获取用户领域模型。
/// </summary>
/// <param name="loginName"></param>
/// <param name="loginPwd"></param>
/// <param name="validCode"></param>
/// <returns></returns>
protected UserDomainModel GetUserDomainModelFromDatabase(string loginInput)
{
UserDomainModel model = null;
UserInfoModel basicInfo = GetUserModelByLoginNameFromDatabase(loginInput);
if (basicInfo != null)
{
model = new UserDomainModel();
model.BasicInfo = basicInfo;
model.InGroupList = UserGroupInfoService.Instance.GetUserInGroupListFromDatabase(basicInfo.UserId);
}
return(model);
}
public void TestInitialize()
{
_user = new User
{
Id = Guid.NewGuid(),
FirstName = "Ime",
LastName = "Prezime",
UserName = "******",
IsAdmin = false,
IsSuperUser = false,
IsUser = true
};
_userDomainModel = new UserDomainModel
{
Id = _user.Id,
FirstName = "Ime",
LastName = "Prezime",
UserName = "******",
IsAdmin = false,
IsSuperUser = false,
IsUser = true
};
_reservationDomainModel = new ReservationDomainModel
{
ProjectionId = Guid.NewGuid(),
SeatId = Guid.NewGuid(),
UserId = _user.Id
};
List <User> userModelsList = new List <User>();
userModelsList.Add(_user);
IEnumerable <User> users = userModelsList;
Task <IEnumerable <User> > responseTask = Task.FromResult(users);
_mockUsersRepository = new Mock <IUsersRepository>();
List <ReservationDomainModel> reservationDomainModelsList = new List <ReservationDomainModel>();
reservationDomainModelsList.Add(_reservationDomainModel);
IEnumerable <ReservationDomainModel> reservations = reservationDomainModelsList;
Task <IEnumerable <ReservationDomainModel> > reservationResponseTask = Task.FromResult(reservations);
_mockReservationService = new Mock <IReservationService>();
}
//
// GET: /Manage/Index
public async Task <ActionResult> Index(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
var userId = User.Identity.GetUserId();
UserDomainModel userDomain = new UserDomainModel();
var model = new IndexViewModel
{
HasPassword = HasPassword(),
UserInfo = userDomain.GetUserInfo(User.Identity.Name)
};
return(View(model));
}
public JsonResult LoginUser(UserDomainModel _user)
{
string user = userBusiness.authenticateUser(_user);
string result = "Cannot Login";
if (user.Equals("Admin"))
{
Session["UserType"] = "Admin";
result = "Success";
}
else if (user.Equals("Standard"))
{
Session["UserType"] = "Standard";
result = "Success";
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void Save(UserDomainModel userToSave)
{
var mappedDbModel = UserDatabaseModelMapper.MapFrom(userToSave);
var userFromDb = _databaseContext.Users.SingleOrDefault(x => x.Id == mappedDbModel.Id);
if (userFromDb != null)
{
userFromDb.FirstName = mappedDbModel.FirstName;
userFromDb.LastName = mappedDbModel.LastName;
userFromDb.Email = mappedDbModel.Email;
userFromDb.Password = mappedDbModel.Password;
}
else
{
_databaseContext.Users.Add(mappedDbModel);
}
_databaseContext.SaveChanges();
}
public async Task <UserDomainModel> GetUserById(int id)
{
UserDomainModel user = new UserDomainModel();
var model = await userRepository.SingleOrDefault(u => u.user_id == id);
if (model != null)
{
user = new UserDomainModel();
user.user_id = model.user_id;
user.firstname = model.firstname;
user.lastname = model.lastname;
user.userRoll = model.userRoll;
user.status = model.status;
user.username = model.username;
user.email = model.email;
user.contact = model.contact;
}
return(user);
}
