public void Add(AddUserDto dto)
{
var user = dto.MapTo <User>();
AddAndSave(user);
SaveChanges();
}
public void Execute(AddUserDto request)
{
if (Context.Users.Any(u => u.Username.ToLower() == request.Username.ToLower()))
{
throw new EntityAlreadyExistsException("User with that username");
}
if (Context.Users.Any(u => u.Email.ToLower() == request.Email.ToLower()))
{
throw new EntityAlreadyExistsException("User with that email");
}
if (request.Password != request.ConfirmPassword)
{
throw new EntityMustHaveConfirmedPassword("Password fields must match.");
}
Context.Users.Add(new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Username = request.Username,
Email = request.Email,
Password = request.Password,
RoleId = request.RoleId
});
Context.SaveChanges();
}
public async Task <CreationState> AddUserAsnc(AddUserDto addUserDto)
{
var creationState = new CreationState {
IsCreatedSuccessfully = false, CreatedObjectId = null
};
var checkUsersAddedBefore = await _unitOfWork.UserRepository.FindElementAsync(x => x.Email == addUserDto.Email || x.PhoneNumber == addUserDto.PhoneNumber);
if (checkUsersAddedBefore == null)
{
var newUser = _mapper.Map <AddUserDto, UsersProfile>(addUserDto);
await _unitOfWork.UserRepository.CreateAsync(newUser);
creationState.IsCreatedSuccessfully = await _unitOfWork.SaveAsync() > 0;
creationState.CreatedObjectId = newUser.Id;
string extention = Path.GetExtension(addUserDto.File.FileName);
string path = _hostEnvironment.WebRootPath + "/Uploads/" + newUser.Id + extention;
using (var stream = new FileStream(path, FileMode.Create))
{
await addUserDto.File.CopyToAsync(stream);
}
}
else
{
creationState.ErrorMessages.Add("This user added before");
}
return(creationState);
}
public async Task <UserClaimsDto> Register(AddUserDto userDto)
{
if (await _genericRepository.FindBy(x => x.Email == userDto.Email).AnyAsync())
{
return(null);
}
User user = new User {
UserName = userDto.Username, Email = userDto.Email
};
if (!string.IsNullOrEmpty(userDto.Password))
{
byte[] passwordHash, passwordSalt;
HashSaltHelper.GeneratePasswordHashAndSalt(userDto.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _genericRepository.Add(user);
return(_mapper.Map <UserClaimsDto>(user));
}
return(null);
}
public async Task <ServiceResponse <List <GetUserDto> > > AddUser(AddUserDto newUser)
{
ServiceResponse <List <GetUserDto> > serviceResponse = new ServiceResponse <List <GetUserDto> >();
var user = _mapper.Map <User>(newUser);
user.DateCreated = DateTime.Now.ToUniversalTime().ToString();
Guid g = Guid.NewGuid();
user.ActivateKey = g.ToString().Replace("-", "");
//user.Password = BC.HashPassword(newUser.Password);
user.PasswordHash = customPasswordHasher.HashPassword(newUser.Password);
user.Status = UserStatus.Disabled;
try
{
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
serviceResponse.Data = (_context.Users.Select(u => _mapper.Map <GetUserDto>(u))).ToList();
}
catch (System.Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.ToString();
}
return(serviceResponse);
}
public ActionResult Create(AddUserDto dto)
{
if (!ModelState.IsValid)
{
TempData["error"] = Messages.INPUT_ERROR;
return(RedirectToAction(nameof(Create)));
}
try
{
executor.ExecuteCommand(addUser, dto);
addUserCases.Execute(dto.Username);
TempData["success"] = Messages.USER_CREATE_SUCCESS;
return(RedirectToAction(nameof(Index)));
}
catch (EntityNotAllowedException)
{
return(RedirectToAction("PageNotFound", "Redirections"));
}
catch (EntityAlreadyExistsException e)
{
TempData["error"] = e.Message;
}
catch (Exception)
{
TempData["error"] = Messages.USER_CREATE_ERROR;
}
return(RedirectToAction("Create"));
}
public void Execute(AddUserDto request)
{
if (Context.Users.Any(c => c.Username == request.UserName))
{
throw new EntityAlreadyExists();
}
Context.Add(new Domen.User
{
Username = request.UserName,
Email = request.Email,
Password = request.Password,
UserTypeId = request.userType
});
Context.SaveChanges();
var email = request.Email;
_emailSender.Subject = "Uspesna registracija";
_emailSender.Body = "Uspesno ste se registrovali.";
_emailSender.ToEmail = email;
_emailSender.Send();
}
public IActionResult Post([FromBody] AddUserDto dto)
{
try
{
addUser.Execute(dto);
return(StatusCode(201));
}
catch (EntityAlreadyExistsException e)
{
return(StatusCode(409, new
{
Errors = new List <string> {
e.Message
}
}));
}
catch (Exception e)
{
return(StatusCode(500, new
{
Errors = new List <string> {
e.Message
}
}));
}
}
public void Execute(AddUserDto reqest)
{
if (context.Users.Any(u => u.Email == reqest.Email))
{
throw new AlreadyExistsEx("User with this email already exists");
}
if (!context.Roles.Any(r => r.Id == reqest.RoleId))
{
throw new NotFoundEx();
}
var user = new User
{
FirstName = reqest.FirstName,
LastName = reqest.LastName,
Email = reqest.Email,
Password = reqest.Password,
RoleId = reqest.RoleId
};
context.Users.Add(user);
context.SaveChanges();
emailer.Subject = "Server Message";
emailer.Body = "A User has been created and added to the database";
emailer.ToEmail = "*****@*****.**";
emailer.Send();
}
public async Task <IActionResult> UpdateUser(int updatedById, [FromBody] AddUserDto userDto)
{
if (userDto == null || updatedById <= 0)
{
_logger.LogError("User or UpdatedByUserId cannot be zero or null");
return(BadRequest(new ResponseMessages {
Message = "User Is Null", status = "400"
}));
}
var userEntity = _mapper.Map <User>(userDto);
var userVal = await _userManager.Update(userEntity);
if (userVal != 0)
{
var updatedUser = _mapper.Map <AddUserDto>(userVal);
_logger.LogInfo($"Update user successfully as login id :{updatedUser.LoginId} and updated by userid : {updatedById}");
return(CreatedAtRoute("UserById", new { userid = updatedUser.userId }, updatedUser));
}
else
{
return(BadRequest(new ResponseMessages {
Message = "User Not Updated", status = "400"
}));
}
}
public async Task <IActionResult> RegisterUser([FromBody] AddUserDto userDto)
{
if (userDto == null)
{
_logger.LogError("User Object cannot be zero or null");
return(BadRequest(new ResponseMessages {
Message = "User is null ", status = "400"
}));
}
var userEntity = _mapper.Map <User>(userDto);
var userVal = await _userManager.Add(userEntity);
if (userVal != 0)
{
//var createdUser = _mapper.Map<AddUserDto>(userEntity);
_logger.LogInfo($"New created user as login ID : {userEntity.LoginID}");
//return CreatedAtRoute("UserById", new { userid = createdUser.userId }, createdUser);
return(Ok(new ResponseMessages {
Message = "User Created Successfully", status = "200"
}));
}
else
{
return(BadRequest(new ResponseMessages {
Message = "User Not Created ", status = "400"
}));
}
}
public async Task <IActionResult> AddAdmin([FromBody] AddUserDto userDto)
{
var a = CurrentUserId;
await _userService.AddAdmin(userDto);
return(Ok());
}
private async Task CompleteUserCreation(string code, string state)
{
if (string.IsNullOrEmpty(code))
{
ErrorMessage = "Invalid external code. Please try again later";
}
// redirect url should not be encoded
var data = await _apiClient.ExchangeCodeAsync(code, _discordOAuth.RedirectUrl);
if (data?.User == null || data.User.Id == 0)
{
ErrorMessage = "Failed to communicate with Discord servers. Please try again later";
return;
}
else
{
var dto = new AddUserDto()
{
Code = code,
HardwareId = state,
DiscordUserId = data.User.Id
};
ApiUser apiUser = await _apiUserService.GetOrAddAsync(dto);
ApiKey = apiUser.ApiKey;
}
}
public async Task <ActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
if (model.Password == model.ConfirmPassword)
{
var UserExist = await _userService.IsUserExistAsync(model.Email, model.Password);
if (!UserExist)
{
AddUserDto userDto = new AddUserDto(model.Email, model.Password);
await _userService.AddUserAsync(userDto);
var PersonId = _userService.GetPersonId(model.Email).ToString();
_authenticationService.AuthorizeContext(HttpContext.GetOwinContext(), _authenticationService.CreateClaim(PersonId));
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "User with this Email already exist!");
}
}
}
return(View(model));
}
public static ResponseDto <int> ValidateAddUser(AddUserDto userToAdd, User user)
{
var response = new ResponseDto <int>();
if (user != null)
{
response.AddError(UserErrors.LoginTaken);
}
if (string.IsNullOrEmpty(userToAdd.Login))
{
response.AddError(UserErrors.EmptyLogin);
}
if (string.IsNullOrEmpty(userToAdd.Email))
{
response.AddError(UserErrors.EmptyEmail);
}
if (string.IsNullOrEmpty(userToAdd.FirstName))
{
response.AddError(UserErrors.EmptyFirstName);
}
if (string.IsNullOrEmpty(userToAdd.LastName))
{
response.AddError(UserErrors.EmptyLastName);
}
if (!new EmailAddressAttribute().IsValid(userToAdd.Email))
{
response.AddError(UserErrors.EmailInvalid);
}
return(response);
}
public ActionResult UserSignup(UserSignupViewModel model)
{
try
{
AddUserDto dto = new AddUserDto();
dto.UserName = model.UserName;
dto.UserPassword = CommonTools.ToMd5(model.UserPassword);
dto.UserRoles = model.UserRoles;
dto.UserStatus = true;
string userJsonString = JsonHelper.JsonSerializerBySingleData(dto);
Message msg = CMSService.Insert("User", userJsonString);
// return RedirectTo("/Login/Login", msg.MessageInfo);
return(RedirectToAction("Login", "Login", new { ac = "SignupSuccess" }));
}
catch
{
Message msg = new Message();
msg.MessageStatus = "Error";
msg.MessageInfo = "注册失败了";
ViewBag.Status = msg.MessageStatus;
ViewBag.msg = msg.MessageInfo;
return(View("Login"));
}
}
public ActionResult <UserDto> AddNewUser(AddUserDto userDto)
{
User user = _mapper.Map <User>(userDto);
_repository.AddUser(user);
return(Ok(_mapper.Map <UserDto>(user)));
}
public async Task <ApplicationResponse <bool> > AddUser(AddUserDto addUserDto)
{
var isValidUser = await _userRepository.GetAsync(x => x.EMail == addUserDto.EMail);
if (isValidUser is not null)
{
return(new ApplicationResponse <bool>(ResponseState.Error, ResponseMessage.Error.ValidUser));
}
var company = await _companyRepository.GetAsync(x => x.Id == addUserDto.CompanyId);
if (company is null)
{
return(new ApplicationResponse <bool>(ResponseState.Error, ResponseMessage.Error.CompanyNotFound));
}
// test kullanıcı olarak eklendi, kaldırılacaktır
var salt = SecurityHelper.GenerateSalt(70);
var hashPassword = SecurityHelper.HashPassword(addUserDto.Password, salt);
var mongoUser = new User
{
EMail = addUserDto.EMail,
Password = hashPassword,
PasswordSalt = salt,
Name = addUserDto.Name,
Surname = addUserDto.Surname,
Company = company
};
await _userRepository.AddAsync(mongoUser);
return(new ApplicationResponse <bool>(true));
}
public ActionResult Create(UserAddViewModel model)
{
try
{
AddUserDto dto = new AddUserDto();
dto.UserName = model.UserName;
dto.UserPassword = CommonTools.ToMd5(model.UserPassword);
dto.UserRoles = "45";
dto.UserStatus = true;
string userJsonString = JsonHelper.JsonSerializerBySingleData(dto);
Message msg = CMSService.Insert("User", userJsonString);
return(RedirectTo("/User/Index", msg.MessageInfo));
}
catch
{
Message msg = new Message();
msg.MessageStatus = "Error";
msg.MessageInfo = "操作出错了";
ViewBag.Status = msg.MessageStatus;
ViewBag.msg = msg.MessageInfo;
return(View());
}
}
public async Task <ApiUser> GetOrAddAsync(AddUserDto addUserDto)
{
var existing = await _users.Value.Find(u => u.Discord.UserId == addUserDto.DiscordUserId).SingleOrDefaultAsync();
if (existing != null)
{
return(existing);
}
var apiUser = new ApiUser()
{
ApiKey = Guid.NewGuid().ToString(),
CreatedAt = 0,
Discord = new DiscordAccount()
{
UserId = addUserDto.DiscordUserId
},
HardwareIds =
{
addUserDto.HardwareId
},
Id = Guid.NewGuid(),
IsBanned = false
};
await _users.Value.InsertOneAsync(apiUser);
return(apiUser);
}
public async Task <UserResponse> AddUser(AddUserDto userDto)
{
// Check if name already exists
var exists = await UserExistsByEmail(userDto.Email);
if (exists != null)
{
throw new Exception("Conflict");
}
var newUser = new User
{
FirstName = userDto.FirstName,
LastName = userDto.LastName,
Email = userDto.Email,
Password = userDto.Password
};
newUser.Password = GeneratePasswordHash(newUser, newUser.Password);
await _context.Users.AddAsync(newUser);
await _context.SaveChangesAsync();
return(newUser.ToDTO());
}
public async Task <CreationState> AddUserAsync(AddUserDto addUserDto)
{
var creationState = new CreationState {
IsCreatedSuccessfully = false, CreatedObjectId = null
};
try
{
//Identity User Mapping
var newUserIdentity = _mapper.Map <AddUserDto, IdentityUser>(addUserDto);
var checkUsersAddedBefore = await _unitOfWork.UserRepository.FindElementAsync(x => x.Email == addUserDto.Email || x.PhoneNumber == addUserDto.PhoneNumber);
if (checkUsersAddedBefore == null)
{
//Adding User
var result = await _userManager.CreateAsync(newUserIdentity, addUserDto.Password);
//Check If User Added
if (result.Succeeded)
{
var userId = Guid.Parse(await _userManager.GetUserIdAsync(newUserIdentity));
var newUser = _mapper.Map <AddUserDto, UsersProfile>(addUserDto);
newUser.Id = userId;
await _unitOfWork.UserRepository.CreateAsync(newUser);
creationState.IsCreatedSuccessfully = await _unitOfWork.SaveAsync() > 0;
creationState.CreatedObjectId = newUser.Id;
creationState.CreatedObjectId = userId;
if (addUserDto.File != null)
{
string extention = Path.GetExtension(addUserDto.File.FileName);
string path = _hostEnvironment.WebRootPath + "/Uploads/" + newUser.Id + extention;
using (var stream = new FileStream(path, FileMode.Create))
{
await addUserDto.File.CopyToAsync(stream);
}
}
}
else
{
foreach (IdentityError item in result.Errors)
{
creationState.ErrorMessages.Add(item.Description);
}
}
}
else
{
creationState.ErrorMessages.Add("This user added before");
}
}
catch (Exception ex)
{
creationState.ErrorMessages.Add(ex.Message);
}
return(creationState);
}
public AddUserDto GetAddUser()
{
var userGroupSelectItems = GetUserGroupSelectItems(ApplicationUserClient_Id);
var dto = new AddUserDto(ApplicationUserClient_Id, userGroupSelectItems);
dto.userGroupIds = new int[] { };
return(dto);
}
public async Task <IdentityResult> CreateUserAsync(AddUserDto dto)
{
var user = dto.ToEntity();
var result = await _userManager.CreateAsync(user, dto.Password);
return(result);
}
public AddUserDto ToModel(AddUserDto dto)
{
dto.Email = this.Email;
dto.Password = this.Password;
dto.PhoneNumber = this.PhoneNumber;
return(dto);
}
public async Task <IActionResult> Add(AddUserDto model)
{
var vm = new AddUserVM {
Cities = await _unitOfWork.UserRepo.GetCities(), User = model
};
return(View(vm));
}
[HttpPost] // POST localhost/User
public async Task <IActionResult> AddUser(AddUserDto newUser)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Ok(await _userService.AddUser(newUser)));
}
public ResponseDto AddUser(AddUserDto user)
{
var entity = user.MapTo <User, AddUserDto>();
_userRepository.Add(entity);
return(new ResponseDto {
Code = 200, Message = "添加用户成功！"
});
}
public void AddUser(AddUserDto addUserDto)
{
addUserDto.Name.ThrowExceptionIfNullOrEmpty("addUserDto.Name");
addUserDto.Password.ThrowExceptionIfNullOrEmpty("addUserDto.Password");
addUserDto.Role.ThrowExceptionIfNullOrEmpty("addUserDto.Role");
addUserDto.ServerParks.ThrowExceptionIfNullOrEmpty("addUserDto.ServerParks");
_blaiseApi.AddUser(addUserDto.Name, addUserDto.Password, addUserDto.Role, addUserDto.ServerParks, addUserDto.DefaultServerPark);
}
public async Task <List <GetUserDto> > AddUser(AddUserDto newUser)
{
User usr = _mapper.Map <User>(newUser);
await _context.Users.AddAsync(usr);
await _context.SaveChangesAsync();
return((_context.Users.Select(u => _mapper.Map <GetUserDto>(u))).ToList());
}