public async Task <IActionResult> Post([FromBody] User value)
{
var response = await _dataRepository.Add(value, "User");
if (response.Length > 0)
{
return(Conflict(response));
}
return(Ok(response));
}
public void ShouldCreateAndGetUser()
{
User testUser = new User
{
Name = "Tony",
Email = "*****@*****.**"
};
var newUser = _usersRepository.Add(testUser.Name, testUser.Email);
var result = _usersRepository.Get(newUser.UserId);
Assert.AreEqual(newUser.Name, result.Name);
Assert.AreEqual(newUser.Email, result.Email);
}
public async Task <IActionResult> FollowOrganization(int userId, int organizationId)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var follow = await _repo.GetOrganizationFollow(userId, organizationId);
if (follow != null)
{
return(BadRequest("You already follow this organization"));
}
if (await _repo.GetOrganizationById(organizationId) == null)
{
return(NotFound());
}
follow = new OrganizationFollow
{
FollowerId = userId,
FolloweeId = organizationId
};
_repo.Add <OrganizationFollow>(follow);
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest("Failed to follow organization"));
}
public async Task <IActionResult> RegisterAccount([FromBody] Models.Users user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
bool bDuplicateEmail = _usersRepository.FindDuplicateEmail(user.Email);
if (bDuplicateEmail)
{
return(Conflict("Duplicate Email"));
}
bool bDuplicateaUserName = _usersRepository.FindDuplicateEmail(user.UserName);
if (bDuplicateaUserName)
{
return(Conflict("Duplicate UserName"));
}
user = await _usersRepository.Add(user);
var results = new ObjectResult(user)
{
StatusCode = (int)HttpStatusCode.OK
};
return(results);
}
public ActionResult Create(User user)
{
_repository.Add(user);
var fu = _repository.FindByName(user.UserName);
return(Json(fu, JsonRequestBehavior.AllowGet));
}
public async Task <HttpResponseMessage> Add([FromBody] UsersModel objUsersModel)
{
HttpRequestMessage request = new HttpRequestMessage();
try
{
if (!ModelState.IsValid)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
Users objUsers = new Users {
Name = objUsersModel.name
};
await Task.Run(() =>
{
_usersRepository.Add(objUsers);
});
return(request.CreateResponse(HttpStatusCode.OK, objUsers, Configuration.Formatters.JsonFormatter));
}
catch (Exception ex)
{
return(request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public IActionResult Create([FromBody] CreateUsers usrToCreate)
{
User user = Data.Domain.Entities.User.Create(usrToCreate.Name, usrToCreate.IsAdmin, usrToCreate.Email, usrToCreate.Password, usrToCreate.Token, usrToCreate.Description);
_repository.Add(user);
return(Ok(user));
}
public async Task <Response> Execute(Request request)
{
request.Treatment();
Validate(request);
var user = await _usersRepository.GetByCpf(request.Cpf);
if (user != null)
{
_notifications.Add($"Já existe um usuário com o CPF {request.Cpf}.", nameof(Request.Cpf));
}
if (!_notifications.IsValid())
{
return(new Response()
{
Errors = _notifications.Notifications
});
}
user = request.ToUser();
await _usersRepository.Add(user);
var token = await _tokenService.GenerateToken(user);
return(new Response()
{
User = UserDto.From(user),
Token = token,
Errors = _notifications.Notifications
});
}
public void ShouldAddNewUser()
{
var user = UsuarioBuilder.New().WithId(id).Build();
var ret = usersRepository.Add(user);
ret.Should().BeGreaterThan(0);
}
public void Create([FromBody] User user)
{
if (user != null)
{
_UsersRepo.Add(user);
}
}
public IActionResult Post([FromBody] User user)
{
if (ModelState.IsValid)
{
string hashedPassword = Convert.ToBase64String(KeyDerivation.Pbkdf2(
password: user.PasswordHash,
salt: Salt.SALT,
prf: KeyDerivationPrf.HMACSHA1,
iterationCount: 10000,
numBytesRequested: 256 / 8));
user.PasswordHash = hashedPassword;
if (user.Role != "admin" && String.IsNullOrWhiteSpace(user.Role))
{
user.Role = "user";
}
_usersRepository.Add(user);
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> LikeUser(int id, int recipientId)
{
if (checkUser(id))
{
return(Unauthorized());
}
var like = await _usersRepository.GetLike(id, recipientId);
if (like != null)
{
return(BadRequest("You already like this user"));
}
if (await _usersRepository.GetUser(recipientId) == null)
{
return(NotFound());
}
like = new Like
{
LikerId = id,
LikeeId = recipientId
};
await _usersRepository.Add <Like>(like);
if (await _usersRepository.SaveAll())
{
return(Ok());
}
return(BadRequest("Failed to like user"));
}
public async Task <IActionResult> CreateMessage(int userId, MessageForCreationDto messageForCreationDto)
{
var sender = await _repo.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageForCreationDto.SenderId = userId;
var recipient = await _repo.GetUser(messageForCreationDto.RecipientId);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
var message = _mapper.Map <Message>(messageForCreationDto);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageForReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
throw new Exception("Creating the message failed on save");
}
public void Create(CreateUserInputDto userInput, string password)
{
if (string.IsNullOrEmpty(password))
{
throw new PasswordIsRequiredException();
}
if (_usersRepository.Get(e => e.Email == userInput.Email).Any())
{
throw new EmailIsAlreadyTakenException(userInput.Email);
}
CreatePasswordHash(password, out var passwordHash, out var passwordSalt);
var user = new User
{
FirstName = userInput.FirstName,
LastName = userInput.LastName,
Email = userInput.Email,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
_usersRepository.Add(user);
}
public CreatedUserDTO Create(
string name,
string cpf,
string email,
string phone,
string state,
string city,
string district,
string zipCode,
string houseNumber,
string addressComplement,
UserProfile profile,
string password
)
{
var crypt = new Crypt();
var cryptPassword = crypt.CreateMD5(password);
var user = new User(name, cpf, email, phone, state, city, district, zipCode, houseNumber, addressComplement, profile, cryptPassword);
var userValidation = user.Validate();
if (userValidation.isValid)
{
_usersRepository.Add(user);
return(new CreatedUserDTO(user.Id));
}
return(new CreatedUserDTO(userValidation.errors));
}
public async Task <UserModel> Register(UserRegisterModel userRegisterModel)
{
var user = await _userRepository.GetByUsername(userRegisterModel.UserName);
if (user != null)
{
return(null);
}
var newUser = new User(
userRegisterModel.UserName,
userRegisterModel.Email,
_passwordHasher.CreateHash(userRegisterModel.Password),
userRegisterModel.Role,
userRegisterModel.FirstName,
userRegisterModel.LastName,
userRegisterModel.PhoneNumber);
newUser.UpdateAddress(userRegisterModel.Address);
await _userRepository.Add(newUser);
if (userRegisterModel.Role == Role.Student)
{
await _studentService.AddStudentToFaculty(userRegisterModel.UniversityId, userRegisterModel.FacultyId, newUser.Id);
}
await _userRepository.SaveChanges();
return(_mapper.Map <UserModel>(newUser));
}
public StatusModel SignUp(User user)
{
var response = new StatusModel();
var exist = _usersRepository.CheckIfExists(user.Username, user.Email);
if (exist)
{
response.IsSuccessful = false;
response.Message = "User with username or email already exists";
return(response);
}
else
{
var newUser = new User()
{
Username = user.Username,
Email = user.Email,
DateCreated = DateTime.Now,
Password = BCrypt.Net.BCrypt.HashPassword(user.Password),
};
_usersRepository.Add(newUser);
return(response);
}
}
public object Post(User added)
{
object json;
try
{
User posted = repository.Add(added);
json = new
{
total = 1,
data = posted,
success = true
};
}
catch (Exception ex)
{
LogManager.Write("ERROR:" + Environment.NewLine + "\tMETHOD = " + this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + Environment.NewLine + "\tMESSAGE = " + ex.Message);
json = new
{
message = ex.Message,
success = false
};
};
return(json);
}
public void RegisterUser(RegisterInputModel registerInputModel)
{
var user = new Users()
{
DateAdded = DateTime.Now,
EmailAddress = registerInputModel.EmailAddress,
FirstName = registerInputModel.FirstName,
LastName = registerInputModel.LastName,
Id = Guid.NewGuid(),
Password = registerInputModel.Password
};
_usersRepository.Add(user);
_usersRepository.SaveChanges();
if (registerInputModel.Score.HasValue)
{
_quizScoresRepository.Add(new QuizScores()
{
Id = Guid.NewGuid(),
Score = registerInputModel.Score.Value,
DateAdded = DateTime.Now,
UserId = user.Id,
User = user
});
_quizScoresRepository.SaveChanges();
}
}
public async Task <ActionResult <Users> > PostUsers(Users users)
{
userRepo.Add(users);
await userRepo.SaveChangesAsync();
return(CreatedAtAction("GetUsers", new { id = users.UserId }, users));
}
public IHttpActionResult AddUser([FromBody] UserDTO userData)
{
if (userData == null)
{
return(BadRequest());
}
User user = Mapper.Map <UserDTO, User>(userData);
User newUser = null;
if (userData.UserId == 0)
{
newUser = _usersRepository.Add(user);
if (newUser.UserId > 0)
{
return(Created(Request.RequestUri + "/" + user.UserId.ToString(),
Mapper.Map <User, UserDTO>(newUser)));
}
}
return(BadRequest());
}
public async Task <IActionResult> CreateMessage(int id, [FromBody] MessageForCreationDto messageForCreationDto)
{
if (checkUser(id))
{
return(Unauthorized());
}
var recipient = await this._userRepo.GetUser(messageForCreationDto.RecipientId);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
messageForCreationDto.SenderId = id;
var message = _mapper.Map <Message>(messageForCreationDto);
await _userRepo.Add(message);
if (await _userRepo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageToReturnDto>(await _userRepo.GetMessage(message.Id));
return(CreatedAtRoute("GetMessage", new { id, messageId = message.Id }, messageToReturn));
}
throw new Exception("Creating the message failed on save");
}
public StatusModel SignUp(User user)
{
var response = new StatusModel();
var exist = _usersRepository.CheckIfExists(user.Username, user.Email);
if (exist)
{
response.Success = false;
response.Message = "This username has alredy been taken. Please try with another username.";
}
else
{
var newUser = new User()
{
Username = user.Username,
Name = user.Name,
Lastname = user.Lastname,
Password = BCrypt.Net.BCrypt.HashPassword(user.Password),
Address = user.Address,
Email = user.Email,
DateCreated = DateTime.Now,
};
_usersRepository.Add(newUser);
response.Success = true;
}
return(response);
}
public async Task <IdentityResult> CreateAsync(ApplicationUser user, CancellationToken cancellationToken)
{
user.Id = Guid.NewGuid().ToString();
await _repo.Add(user);
return(await Task.FromResult(IdentityResult.Success));
}
public void Create(User user)
{
lockService.Execute(() =>
{
user.Assert(() => new ArgumentNullException("user"))
.Do(u => ValidateAndThrowIfErrors(u))
.Do(u => usersRepository.Add(u));
});
}
public async Task SaveAccount(RegisterRequest register)
{
await Validate(register);
var user = _mapper.Map <User>(register);
user.PasswordHash = _hasher.HashPassword(user, register.Password);
await _repository.Add(user);
}
public User Add(UserDTO UserDTO)
{
IEnumerable <UserRole> userRoles = _usersRepo.GetUserRoles(UserDTO.UserRoles);
User user = _mapper.Map <User>(UserDTO);
_usersRepo.Add(user, userRoles);
return(user);
}
public async Task <Guid> Handle(CreateUserCommand command, CancellationToken cancellationToken)
{
var user = new User(command.Email, command.FirstName, command.LastName, _passwordService.HashPassword(command.Password));
await _usersRepository.Add(user);
await _usersRepository.UnitOfWork.SaveEntitiesAsync();
return(user.Id);
}
public async Task <IActionResult> Create([Bind("Id,Name,Password,Username,Email,Gender,Age,FollowId,CurrentFollowers")] Users users)
{
if (ModelState.IsValid)
{
await _dataAccessProvider.Add(users);
return(RedirectToAction(nameof(Index)));
}
return(View(users));
}
public IActionResult Post([FromBody] UserItem item)
{
var result = repository.Add(item);
if (result == null)
{
return(NotFound());
}
return(Ok());
}
