public async Task <UserModel> AddAsync(UserModel model, string password, int clientId, int userId)
{
if (!await _permissionManager.HasPermission(clientId, userId, Permission.CanAddUser))
{
throw new Exception("User has not permission to perform this operation");
}
var existing = _usersRepository.GetUserByEmail(model.Email);
if (existing != null)
{
throw new Exception("Email already exists");
//errors = "Email already exists";
//return new EnumerableQuery<MonsciergeDataModel.User>(new MonsciergeDataModel.User[0]);
}
if (!PasswordHelpers.IsValidPassword(password, new PasswordRequirements()))
{
throw new Exception("Password doesn't meet requirements");
//errors = "Password doesn't meet requirements";
//return new EnumerableQuery<MonsciergeDataModel.User>(new MonsciergeDataModel.User[0]);
}
var user = new User()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
ClientId = clientId,
Role = (int)UserRoles.HRUser,
IsActive = true,
CreatedOn = DateTime.UtcNow,
UpdatedOn = DateTime.UtcNow
};
string salt;
string passwordHash;
PasswordHelpers.GenerateSaltAndHash(password, out salt, out passwordHash);
user.Salt = salt;
user.PasswordHash = passwordHash;
user = await _usersRepository.AddAsync(user);
return(_usersMapper.ConvertToModel(user));
}
public async Task HandleAsync(AdminRegisterEvent @event)
{
var user = new User()
{
Id = @event.UserId,
Name = @event.Name,
Surname = @event.Surname,
MiddleName = @event.MiddleName,
Email = @event.Email
};
await _usersRepository.AddAsync(user).ConfigureAwait(false);
await _usersRepository.AddRoleToUserAsync(@event.UserId, Roles.Lecturer).ConfigureAwait(false);
await _usersRepository.AddRoleToUserAsync(@event.UserId, Roles.Curator).ConfigureAwait(false);
}
public async Task <ShopUser> Create(ShopUser user, string password)
{
if (await _usersRepository.IsUsernameTaken(user.Name))
{
throw new ArgumentException("Username \"" + user.Name + "\" is already taken");
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _usersRepository.AddAsync(user);
return(user);
}
public async Task <Result> HandleAsync(RegisterCommand command)
{
var task = _usersRepository.GetByEmailAsync(command.Email);
var salt = _passwordService.GetSalt();
var hash = _passwordService.GetHash(command.Password, salt);
if (task.GetAwaiter().GetResult() != null)
{
return(Result.Failure("Email already exists."));
}
var user = new User(Guid.NewGuid(), command.Email, false, Enumerable.Empty <Role>(), hash, salt, DateTime.Now);
await _usersRepository.AddAsync(user);
return(Result.Success());
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Create([FromBody] UserViewModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User newUser = new User
{
LastName = user.LastName,
FirstMidName = user.FirstMidName,
HireDate = user.HireDate
};
// One-to-Many
if (user.SelectedRoles != null)
{
newUser.RoleAssignments = new List <RoleAssignment>();
foreach (var role in user.SelectedRoles)
{
var roleToAdd = new RoleAssignment {
UserID = user.ID, RoleID = int.Parse(role)
};
newUser.RoleAssignments.Add(roleToAdd);
}
}
await _usersRepository.AddAsync(newUser);
await _usersRepository.CommitAsync();
// Need to grab Course (.ThenInclude(ca => ca.Course)) since newInstructor does not retrieve Course entity after CommitAsync()
// when InstructorViewModel maps (Title = ca.Course.Title)
User UserWithRole = await _usersRepository.GetUserRoles(newUser.ID);
user = Mapper.Map <User, UserViewModel>(UserWithRole);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = user.ID }, user));
}
public async Task HandleAsync(SignUpCommand command)
{
var user = await _usersRepository.GetAsync(command.Email);
if (user != null)
{
throw new MyShopException("email_in_use",
$"Email: '{command.Email}' as already in use.");
}
user = new User(command.Id, command.Email, Role.User);
user.SetPassword(command.Password, _passwordHasher);
await _usersRepository.AddAsync(user);
var newCustomer = new Customer(command.Id, command.Email);
await _customersRepository.AddAsync(newCustomer);
var newCart = new Cart(command.Id);
await _cartsRepository.AddAsync(newCart);
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Create([FromBody] UserViewModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User newUser = new User
{
LastName = user.LastName,
FirstMidName = user.FirstMidName,
EnrollmentDate = user.EnrollmentDate
};
await _usersRepository.AddAsync(newUser);
await _usersRepository.CommitAsync();
user = Mapper.Map <User, UserViewModel>(newUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = user.ID }, user));
}
public async Task <IActionResult> Get(string userName)
{
if (userName == string.Empty || userName == "null")
{
return(BadRequest("userName is Empty"));
}
var u = await _userRepository.GetUserAsync(userName, Request.Headers["User-Agent"].ToString());
if (u != null)
{
return(Ok(u));
}
u = new User
{
Name = userName,
Agent = Request.Headers["User-Agent"].ToString()
};
var result = await _userRepository.AddAsync(u);
return(result.State ? (IActionResult)Ok(u) : BadRequest(result.Error));
}
public Task AddAsync(PostUserDTO user)
{
return(_repository.AddAsync(user.AsEntity(Guid.NewGuid())));
}
public async Task AddUserAsync(User user)
{
await _usersRepository.AddAsync(user.MapToUsersEntity());
}
public async Task <Users> AddUser(Users user)
{
return(await _usersRepository.AddAsync(user));
}
public async Task <UserModel> AddUserAsync(UserModel newUser)
{
ValidateUser(newUser);
return(await usersRepository.AddAsync(newUser));
}
public async Task AddUser(User user)
{
await _usersRepository.AddAsync(user);
}
public async Task <User> CreateAsync(User user)
{
await _usersRepository.AddAsync(user);
return(user);
}
public async Task HandleAsync(RegisterUserCommand command)
{
var user = new User(command.Username, command.Email, command.HashPassword, command.Salt);
await usersRepository.AddAsync(user);
}
public virtual async Task <BaseResponse> AddAsync(User user)
{
try
{
int result = await _usersRepository.AddAsync(user);
if (result == 0)
{
throw new Exception($"User with login {user.Login} was not saved");
}
BaseResponse response = new()
{
Id = user.Id,
ErrorMessage = string.Empty,
IsSuccess = true
};
LogData log = new()
{
CallSide = nameof(UsersService),
CallerMethodName = nameof(AddAsync),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = user,
Response = response
};
_logger.AddLog(log);
return(response);
}
catch (ArgumentException aex)
{
LogData log = new()
{
CallSide = nameof(UsersService),
CallerMethodName = nameof(AddAsync),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = user,
Response = aex
};
_logger.AddErrorLog(log);
return(new BaseResponse
{
IsSuccess = false,
ErrorMessage = aex.Message
});
}
catch (InvalidOperationException ioex)
{
LogData log = new()
{
CallSide = nameof(UsersService),
CallerMethodName = nameof(AddAsync),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = user,
Response = ioex
};
_logger.AddErrorLog(log);
return(new BaseResponse
{
IsSuccess = false,
ErrorMessage = ioex.Message
});
}
catch (DbUpdateException duex)
{
LogData log = new()
{
CallSide = nameof(UsersService),
CallerMethodName = nameof(AddAsync),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = user,
Response = duex
};
_logger.AddErrorLog(log);
return(new BaseResponse
{
IsSuccess = false,
ErrorMessage = "An error occured while saving user"
});
}
catch (Exception ex)
{
LogData log = new()
{
CallSide = nameof(UsersService),
CallerMethodName = nameof(AddAsync),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = user,
Response = ex
};
_logger.AddErrorLog(log);
return(new BaseResponse
{
IsSuccess = false,
ErrorMessage = ex.Message
});
}
}
// RegisterUsersCommand命令的处理程序
// 整个命令处理程序的核心都在这里
// 不仅包括命令验证的收集，持久化，还有领域事件和通知的添加
public async Task <Response <Users> > Handle(RegisterUsersCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
NotifyValidationErrors(request);
//return new Response<Users>("Validation failed.");
return(await Task.FromResult(new Response <Users>("Validation failed.")));
}
#region
var user = new Users();
var address = new Address(request.Province, request.City, request.County, request.Street, request.Detailed);
user.Type = request.Type;
user.MtypeId = request.MtypeId;
user.NickName = request.NickName;
user.Surname = request.Surname;
user.Name = request.Name;
user.RealName = request.RealName;
user.Phone = request.Phone;
user.Email = request.Email;
user.BirthDate = request.BirthDate;
user.Sex = request.Sex;
user.Age = request.Age;
user.Gravatar = request.Gravatar;
user.Avatar = request.Avatar;
user.Motto = request.Motto;
user.Bio = request.Bio;
user.Idcard = request.Idcard;
user.Major = request.Major;
user.Polity = request.Polity;
user.NowState = request.NowState;
user.State = request.State;
user.Address = address;
user.Company = request.Company;
user.Website = request.Website;
user.Weibo = request.Weibo;
user.Blog = request.Blog;
user.Url = request.Url;
user.RegisterTime = request.RegisterTime;
user.RegisterIp = request.RegisterIp;
user.LastLoginTime = request.LastLoginTime;
user.LastLoginIp = request.LastLoginIp;
user.LastModifiedTime = request.LastModifiedTime;
user.LastModifiedIp = request.LastModifiedIp;
user.UserAuths = request.UserAuths;
user.Sort = request.Sort;
//user.IsSuperMan = request.IsSuperMan;
#endregion
#region 检查
//// 判断用户名是否存在
//// 这些业务逻辑，当然要在领域层中（领域命令处理程序中）进行处理
//var existingUsers = _UsersRepository.GetByName(users.Name);
//if (existingUsers != null && existingUsers.Id != users.Id)
//{
// //引发错误事件
// Bus.RaiseEvent(new DomainNotification("", "该用户名已经被使用！"));
// return Task.FromResult(new Unit());
//}
// 判断邮箱是否存在
var existingUsers = _UsersRepository.GetByEmail(user.Email);
if (existingUsers != null && existingUsers.Id != user.Id)
{
if (!existingUsers.Equals(user))
{
await Bus.RaiseEvent(new DomainNotification("", "该邮箱已经被使用！"));
return(await Task.FromResult(new Response <Users>("该邮箱已经被使用.")));
}
}
#endregion
await _UsersRepository.AddAsync(user);
//var result = await CommitAsync();
if (await CommitAsync())
{
#region
var usersregisteredevent = new UsersRegisteredEvent(
user.Id,
user.Type,
user.MtypeId,
user.NickName,
user.Surname,
user.Name,
user.RealName,
user.Phone,
user.Email,
user.BirthDate,
user.Sex,
user.Age,
user.Gravatar,
user.Avatar,
user.Motto,
user.Bio,
user.Idcard,
user.Major,
user.Polity,
user.NowState,
user.State,
user.Address.Province, user.Address.City, user.Address.County, user.Address.Street, user.Address.Detailed,
user.Company,
user.Website,
user.Weibo,
user.Blog,
user.Url,
user.RegisterTime,
user.RegisterIp,
user.LastLoginTime,
user.LastLoginIp,
user.LastModifiedTime,
user.LastModifiedIp,
user.UserAuths,
user.Sort
);
#endregion
await Bus.RaiseEvent(usersregisteredevent);
}
//return new Response<Users>(user);
return(await Task.FromResult(new Response <Users>(user)));
}
