public async Task <IActionResult> Register(RegisterModel model)
{
if (!SystemController.webServerRules.AllowRegistrationOfNewUsers)
{
return(View("Error", "Registration of new users is prohibited. Please contact administrator."));
}
if (db == null)
{
return(View("Error", NO_DB_ERROR));
}
if (ModelState.IsValid)
{
User user = db.GetUser(model.Name);
if (user == null)
{
user = new User()
{
Name = model.Name,
Email = model.Email,
Password = model.Password,
};
db.AddUser(user);
await Authenticate(user);
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "User already exists");
}
return(View(model));
}
public IActionResult Register([FromBody] UserCreateDto user)
{
if (!TryValidateModel(user))
{
return(ValidationProblem(ModelState));
}
var userToInsert = _mapper.Map <User>(user);
_usersRepository.AddUser(userToInsert);
_usersRepository.Save();
return(CreatedAtAction("GetUserById",
new { userId = userToInsert.Id }, _mapper.Map <UserDto>(userToInsert)));
}
//[RequestHeaderMatchesMediaType("Accept", new[] {"..."} )]
public ActionResult CreateUser([FromBody] UserForCreationDto user)
{
if (user == null)
{
return(BadRequest());
}
var userEntity = _mapper.Map <User>(user);
_usersRepository.AddUser(userEntity);
if (!_usersRepository.Save())
{
throw new Exception("Creating a user failed on save.");
}
var userToReturn = _mapper.Map <UserDto>(userEntity);
var links = CreateLinksForUser(userToReturn.Id, null);
var linkedResourceToReturn = userToReturn.ShapeData(null)
as IDictionary <string, object>;
linkedResourceToReturn.Add("links", links);
return(CreatedAtRoute("GetUser",
new { id = linkedResourceToReturn["Id"] },
linkedResourceToReturn));
}
public HttpResponseMessage AddUser(UserModel userModel)
{
try
{
if (userModel == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
byte[] bytes = Convert.FromBase64String(userModel.userImage);
string[] extensions = userModel.userPicture.Split('.');
string extension = extensions[extensions.Length - 1];
string fileName = Guid.NewGuid().ToString();
string filePath = HttpContext.Current.Server.MapPath("~/assets/images/users/" + fileName + "." + extension);
using (FileStream binaryFileStream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
{
binaryFileStream.Write(bytes, 0, bytes.Length);
userModel.userPicture = fileName + "." + extension;
}
userModel.userImage = string.Empty;
UserModel addedUser = usersRepository.AddUser(userModel);
return(Request.CreateResponse(HttpStatusCode.Created, addedUser));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, errors));
}
}
private void AddUserButton_Click(object sender, RoutedEventArgs e)
{
if (_isAddingNewUser)
{
if (CheckUserFields(_newUser))
{
if (_userRepository.DoesUserExist(UserNameTextBox.Text))
{
MessageBox.Show("User name already exists, please try a different user name");
return;
}
var _newUser = AssignPropsToUserClass();
if (_newUser == null)
{
return;
}
_userRepository.AddUser(_newUser);
Logging.GetInstance().LogAddUser(_newUser.UserName);
_currentUserID = _userRepository.ReturnLastUserID() - 1;
_isAddingNewUser = false;
EnableNewUserButtons(true);
ResetBackgroundColours();
EnableProtectedUserCheckBox();
}
}
}
public HttpResponseMessage AddUser(UserModel userModel)
{
try
{
byte[] bytes = Convert.FromBase64String(userModel.userImage);
string[] extensions = userModel.userPicture.Split('.');
string extension = extensions[extensions.Length - 1];
string fileName = Guid.NewGuid().ToString();
string filePath = HttpContext.Current.Server.MapPath("~/assets/images/users/" + fileName + "." + extension);
using (FileStream binaryFileStream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
{
binaryFileStream.Write(bytes, 0, bytes.Length);
userModel.userPicture = fileName + "." + extension;
}
userModel.userImage = string.Empty;
HttpResponseMessage hrm = new HttpResponseMessage(HttpStatusCode.Created)
{
Content = new StringContent(JsonConvert.SerializeObject(usersRepository.AddUser(userModel)))
};
return(hrm);
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
HttpResponseMessage hr = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(errors.ToString())
};
return(hr);
}
}
public void PostUser([FromBody] DataForSignUp data)
{
data.User.Role = "user";
data.Password = BCrypt.Net.BCrypt.HashPassword(data.Password);
KeyAndVectorModel kav = keyAndVectorRep.GetKeyAndVector();
if (kav.key == null & kav.iv == null)
{
Aes myAes = Aes.Create();
kav.key = myAes.Key;
kav.iv = myAes.IV;
keyAndVectorRep.SetKeyAndVector(kav);
}
UsersModel toDb = new UsersModel();
toDb.Role = data.User.Role;
toDb.UserName = data.User.UserName;
toDb.Email = data.User.Email;
toDb.FirstName = AesEncrDecr.EncryptStringToBytes_Aes(data.User.FirstName, kav.key, kav.iv);
toDb.SecondName = AesEncrDecr.EncryptStringToBytes_Aes(data.User.SecondName, kav.key, kav.iv);
toDb.BirthDate = AesEncrDecr.EncryptStringToBytes_Aes(data.User.BirthDate, kav.key, kav.iv);
usersRep.AddUser(toDb, data.Password);
_logger.LogInformation("User with name " + data.User.UserName + " Signed up");
}
public IActionResult Register(Users user)
{
bool IsExisted = _usersRepository.IsExisted(user.UserName);
if (ModelState.IsValid && !IsExisted)
{
//哈希密码
user.Password = EncryptProvider.Md5(user.Password);
var man = new Users()
{
//UserId 主键自增
UserName = user.UserName,
Name = "",
Avatar = "img/defaultAvt.png",
Birthday = DateTime.Now.ToString("D"),
Sex = "保密",
Email = "",
Password = user.Password
};
_usersRepository.AddUser(man);
return(Ok("注册成功"));
}
else
{
return(StatusCode(422, "用户已存在"));
}
}
public async Task <IActionResult> AddUser([FromBody] Users model)
{
if (ModelState.IsValid)
{
try
{
var userId = await userRepository.AddUser(model);
if (userId > 0)
{
return(Ok(userId));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public IList <Anagram> GetAnagrams(string word, string ipAddress)
{
var freeSearchesCount = Convert.ToInt32(_appConfig.GetConfiguration()["FreeSearchesCount"]);
var user = _usersRepository
.GetUsers()
.FirstOrDefault(u => u.Ip == ipAddress);
if (user == null)
{
_usersRepository.AddUser(new User {
Ip = ipAddress
});
user = _usersRepository
.GetUsers()
.FirstOrDefault(u => u.Ip == ipAddress);
}
if (user.SearchesLeft > 0)
{
return(_anagramSolver.GetAnagrams(word, user));
}
throw new Exception("You exceeded free searched limit, please add new word");
}
/// <inheritdoc />
public async Task <ServiceResponse <string> > CreateNewUser(UserRegisterDto userData)
{
var serviceResponse = new ServiceResponse <string>();
if (await _usersRepository.UserExists(userData.Email))
{
serviceResponse.StatusCode = 400;
serviceResponse.Message = "User with this email already exists.";
serviceResponse.MessageRu = "Пользователь с таким email уже существует.";
return(serviceResponse);
}
var user = new User
{
Email = userData.Email,
FirstName = userData.FirstName,
LastName = userData.LastName,
Access = "unknown"
};
CreatePasswordHash(userData.Password, out var passwordHash, out var passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
var userId = await _usersRepository.AddUser(user);
serviceResponse.StatusCode = 201;
serviceResponse.Data = CreateToken(userId, user.Email);
serviceResponse.Message = "User is created successfully.";
serviceResponse.MessageRu = "Пользователь успешно создан.";
return(serviceResponse);
}
public IActionResult AddUser(UserModel userModel)
{
try
{
if (userModel == null)
{
return(BadRequest("Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(BadRequest(errors));
}
byte[] bytes = Convert.FromBase64String(userModel.userImage);
string[] extensions = userModel.userPicture.Split('.');
string extension = extensions[extensions.Length - 1];
string fileName = Guid.NewGuid().ToString();
string filePath = environment.WebRootPath + "/assets/images/users/" + fileName + "." + extension;
using (FileStream binaryFileStream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
{
binaryFileStream.Write(bytes, 0, bytes.Length);
userModel.userPicture = fileName + "." + extension;
}
userModel.userImage = string.Empty;
UserModel addedUser = usersRepository.AddUser(userModel);
return(StatusCode(StatusCodes.Status201Created, addedUser));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(StatusCode(StatusCodes.Status500InternalServerError, errors));
}
}
public ActionResult SignUp(IFormCollection collection, Models.Users user)
{
PizzaBox.Domain.Users dmc = new Users();
dmc.FirstName = user.FirstName;
dmc.LastName = user.LastName;
dmc.Street = user.Street;
dmc.City = user.City;
dmc.State = user.State;
dmc.ZipCode = user.ZipCode;
dmc.Phone = user.Phone;
dmc.Email = user.Email;
dmc.Password = user.Password;
try
{
db.AddUser(dmc);
db.Save();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
private void AddUser(User user)
{
user.CreatetedAt = DateTime.Now;
user.UpdatedAt = DateTime.Now;
user.Password = BCrypt.Net.BCrypt.HashPassword(user.GeneratedCode,
BCrypt.Net.BCrypt.GenerateSalt((int)Constants.WorkFactor));
_usersRepository.AddUser(user);
}
private void AddUser()
{
var editedUser = GetUserFromView();
int newId = userRepository.AddUser(editedUser);
Debug.WriteLine(string.Format("User with id: {0} added", newId));
MainPresenter?.UpdateView();
}
public ActionResult AddUser(AddUserViewModel viewModel)
{
var model = FromAddViewModel(viewModel);
repository.AddUser(model);
return(Ok(
ToViewModel(model)
));
}
public async Task <IActionResult> AddUser([FromBody] UserDto user)
{
try {
return(Ok(await _usersReposiotry.AddUser(_mapper.Map <UserDb>(user))));
}
catch (Exception ex) {
return(BadRequest("Bład przy dodawaniu nowego użytkownika" + ex.Message));
}
}
public async Task <RegisterResult> Register(UserViewModel registerModel)
{
registerModel.Password = passwordHash.GetHash(registerModel.Password);
var userModel = usersModelBuilder.GetUserModelByUserView(registerModel);
await usersRepository.AddUser(userModel);
return(new RegisterResult {
Successful = true
});
}
public async Task AddUser(UserDto userDto, User loggedUser)
{
User user = UserDtoToUser(userDto);
user.Id = 0;
user = await RetrievePermisions(user);
user.Permissions = FilterPermissions(user.Permissions, loggedUser.Permissions.Max(p => p.Permission.Level));
await usersRepository.AddUser(user);
}
public async Task <IActionResult> AddUser(UserToRegisterDTO user)
{
var userDB = await _repo.AddUser(user);
if (userDB == null)
{
return(StatusCode(409)); // Status Code 409 Conflict / Email exists
}
return(Ok(userDB));
}
public async Task <User> AddUser(User user)
{
var existedUser = await _repository.GetUserByUserName(user.UserName);
if (existedUser != null)
{
throw new UserAlreadyExistsException();
}
return(await _repository.AddUser(user));
}
protected override async Task HandleMessage(UserWasCreated message)
{
var user = new User
{
Id = message.Id,
Name = message.UserName
};
await _usersRepository.AddUser(user);
}
public User AddUser(User user)
{
if (UserExists(user.Username))
{
throw new ArgumentException($"The user with username: {user.Username} already exists");
}
_usersRepository.AddUser(user);
return(user);
}
public async Task <IActionResult> SignUp([FromBody] UserSignUpDTO user)
{
try
{
return(Ok(await _usersRepository.AddUser(user)));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <ActionResult <UserAuth> > AddUser([FromBody] UserCredentials userCredentials)
{
if (await _usersRepository.AddUser(userCredentials.Username))
{
return(Ok(new UserAuth {
Username = userCredentials.Username, Token = generateToken(userCredentials.Username)
}));
}
return(BadRequest());
}
public async Task <ActionResult> AddUser([FromBody] User user)
{
if (user.Username == null || user.Username == "" || user.Password == null || user.Password == "" || user.EmailAddress == null || user.EmailAddress == "")
{
return(BadRequest());
}
await usersRepository.AddUser(user.Username, user.Password, user.EmailAddress);
return(Ok());
}
public IActionResult AddUser([FromBody] NewUserModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newUser = _usersRepository.AddUser(user);
return(Ok(new ResultModel <User>(newUser)));
}
public void Init()
{
var user = new User
{
Name = "testUser",
UserLogin = "******",
Password = "******"
};
TestUser = _usersRepository.AddUser(user);
}
public IActionResult Post([FromBody] User user)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
var createdUser = users.AddUser(user);
return(CreatedAtAction(nameof(Get), new { id = createdUser.UserId }, createdUser));
}
public IActionResult Register([Bind] Users usr)
{
if (ModelState.IsValid)
{
usr.AccountNumber = GenerateAccountNumber(15);
usr.Balance = 0;
usr.CreatedDate = DateTime.Now;
_repo.AddUser(usr);
return(RedirectToAction("Index"));
}
return(View(usr));
}
