public int CreateUser(UserRequestModel userRequestModel)
{
if (userRequestModel == null || string.IsNullOrWhiteSpace(userRequestModel.Username) || string.IsNullOrWhiteSpace(userRequestModel.Password))
{
return(Invalid);
}
try
{
UserModel userModel = new UserModel()
{
RoleId = userRequestModel.RoleId,
Username = userRequestModel.Username,
Password = userRequestModel.Password
};
return(UserRepository.CreateUser(userModel));
}
catch (Exception ex)
{
Logger.LogFile($"Error creating a User: {ex.Message}");
return(Invalid);
}
}
public async Task Register_Happy()
{
var credentials = new UserRequestModel()
{
UserName = "******",
Password = "******"
};
IOptions <JWTSettings> options = Options.Create(new JWTSettings
{
SecretKey = "myverysecretkeyofsecrets",
Issuer = "theissuer"
});
var userStore = new Mock <IUserStore <ApiUser> >();
var userManager = new Mock <UserManager <ApiUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <ApiUser> >();
userManager.Setup(x => x.CreateAsync(It.Is <ApiUser>(u => u.UserName == credentials.UserName), credentials.Password))
.ReturnsAsync(IdentityResult.Success);
var signInManager = new Mock <SignInManager <ApiUser> >(userManager.Object, contextAccessor.Object, userPrincipalFactory.Object, null, null, null);
var userService = new Mock <IUserService>();
var controller = new UsersController(userManager.Object, signInManager.Object, userService.Object, null, options);
OkObjectResult result = await controller.Post(credentials) as OkObjectResult;
userService.Verify(x => x.GetUser(credentials.UserName, credentials.UserName));
Assert.NotNull(result);
Assert.NotNull(result.Value);
}
public bool UpdateUser(UserRequestModel userRequestModel)
{
if (userRequestModel?.UserId == null || string.IsNullOrWhiteSpace(userRequestModel.Password))
{
return(false);
}
try
{
UserModel userModel = new UserModel()
{
UserId = (int)userRequestModel.UserId,
RoleId = userRequestModel.RoleId,
Password = userRequestModel.Password
};
return(UserRepository.UpdateUser(userModel));
}
catch (Exception ex)
{
Logger.LogFile($"Error updating a User: {ex.Message}");
}
return(false);
}
public IActionResult Register(long id, [FromBody] UserRequestModel userViewModel)
{
userViewModel.UserId = id;
_mappedUserRepositoryService.AddOrUpdateUsingProcedure(userViewModel);
return(RedirectToAction("Get", "User"));
}
public void CheckIfUserDontExist()
{
UserRequestModel user = apiAccess.GetUserPayload();
var response = apiAccess.GetUserByEmail(TestData.UserData.USER.Email);
Assert.AreEqual(0, response.Data.Length);
}
public ActionResult <int> CreateUser([FromBody] UserRequestModel userRequestModel)
{
if (userRequestModel == null || string.IsNullOrWhiteSpace(userRequestModel.Username) || string.IsNullOrWhiteSpace(userRequestModel.Password))
{
return(StatusCode(400));
}
int result = HeaderValidation.ValidateUserCredentials(Request.Headers[Username], Request.Headers[Password]);
if (result == -1)
{
return(StatusCode(401));
}
if (!HeaderValidation.ValidateUserPermissions(result))
{
return(StatusCode(403));
}
result = UserService.CreateUser(userRequestModel);
if (result == -1)
{
return(StatusCode(500));
}
return(StatusCode(201, result));
}
public async Task <IActionResult> signup([FromHeader] String Authorization, [FromBody] UserRequestModel userRequestModel)
{
try {
string auth = Encoding.UTF8.GetString(Convert.FromBase64String(Authorization.Substring(5)));
string username = auth.Substring(0, auth.IndexOf(":"));
string password = auth.Substring(auth.IndexOf(":") + 1);
var user = await _user.FindByUsername(username);
if (user != null)
{
return(BadRequest(new Respone(400, "Username does exist", null)));
}
var newUser = new User
{
username = username,
password = password,
address = userRequestModel.address,
phone = userRequestModel.phone,
email = userRequestModel.email,
lat = userRequestModel.lat,
lon = userRequestModel.lon,
role = "user"
};
await _user.Add(newUser);
return(Ok(new Respone(200, "ok", new { token = genToken(newUser) })));
} catch (Exception e) {
return(BadRequest(new Respone(400, "Failed", null)));
}
}
public async Task <TokenResponseModel> GenerateTokensAsync(UserRequestModel userRequestModel)
{
var user = await _userRepository.FirstOrDefault(u => string.Equals(u.Username, userRequestModel.Username) &&
string.Equals(u.Password, userRequestModel.Password));
if (user != null)
{
var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("superSecretKey@345"));
var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);
var claims = new List <Claim>
{
new Claim("UserId", user.Id.ToString()),
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Role, "Manager")
};
var accessToken = GenerateAccessToken(claims);
var refreshToken = GenerateRefreshToken();
user.RefreshToken = refreshToken;
user.RefreshTokenExpiryTime = DateTime.UtcNow.AddDays(3);
await _userRepository.UpdateAsync(user);
return(new TokenResponseModel()
{
AccessToken = accessToken,
RefreshToken = refreshToken
});
}
else
{
return(null);
}
}
public async Task <IActionResult> Post([FromBody] UserRequestModel credentials)
{
ApiUser apiUser = new ApiUser(credentials.UserName);
var result = await _userManager.CreateAsync(apiUser, credentials.Password);
if (!result.Succeeded)
{
_logger.LogError($"User creation error: {String.Join(" | ", result.Errors.Select(x => x.Description).ToArray())}");
throw new ApplicationException("Could not create user.");
}
var now = DateTime.Now;
var key = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_options.SecretKey));
var tokenHandler = new JsonWebTokenHandler();
var descriptor = new SecurityTokenDescriptor
{
Issuer = _options.Issuer,
IssuedAt = now,
NotBefore = now,
Expires = now.AddHours(1),
Claims = new Dictionary <string, object> {
{ JwtRegisteredClaimNames.Sub, apiUser.UserName }
},
SigningCredentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256)
};
TegetgramUserDTO user = await _userService.GetUser(apiUser.UserName, apiUser.UserName);
return(Ok(new
{
access_token = tokenHandler.CreateToken(descriptor),
user = user
}));
}
/// <summary>
/// Create
/// </summary>
/// <param name="userResponseModel"></param>
/// <param name="ct"></param>
/// <returns></returns>
public async Task <UserResponseModel> Create(UserRequestModel userRequestModel, CancellationToken ct = default)
{
int agencyId = 1;// this value cames by parameter, from token claims
Agency agency = await _agencyRepository.FindAsync(x => x.Id == agencyId);
if (agency is null)
{
// report agency doesn't exist
}
User user = await _userRepository.FindAsync(x => x.UserName == userRequestModel.Email);
if (user != null)
{
// report user with this email exists
}
user = _mapper.Map <User>(userRequestModel);
user.Password = Guid.NewGuid().ToString();
user.Agency = agency;
user.Employee.Agency = user.Agency;
_userRepository.Add(user);
await _unitOfWork.SaveChangesAsync(ct);
var data = _mapper.Map <UserResponseModel>(user);
return(data);
}
public async Task <UserResponseModel> PutUser(
int userId,
[FromForm] UserRequestModel model,
CancellationToken cancellationToken
)
{
cancellationToken.ThrowIfCancellationRequested();
var command = new UpdateUserCommand(
userId,
model.Login,
model.Password,
model.PersonId
);
await _mediator.Send(command, cancellationToken);
var query = new FindUserByIdQuery(userId);
var user = await _mediator.Send(query, cancellationToken);
var response = _mapper.Map <UserResponseModel>(user);
return(response);
}
Returns_409_If_Request_Authorized_But_Conflicted()
{
// Arrange
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService()));
// This is not a valid user request to create new one
var userRequestModel = new UserRequestModel {
Name = Constants.ValidAdminUserName,
Email = "*****@*****.**",
Password = "******",
Roles = new[] { "Admin", "Employee" }
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Post,
uri: string.Format(
"https://localhost/{0}",
"api/users"),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent <UserRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
var response = await IntegrationTestHelper
.GetResponseAsync(config, request);
// Assert
Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
}
public async Task <IActionResult> PutAsync([FromBody] UserRequestModel userRequest)
{
try
{
var success = await this.fulfillment.UpdateUserAsync(userRequest);
return(this.Ok(success));
}
catch (InvalidUserRequestException ex)
{
return(new ContentResult {
StatusCode = 400, Content = ex.Message
});
}
catch (FabricNotPrimaryException)
{
return(new ContentResult {
StatusCode = 410, Content = "The primary replica has moved. Please re-resolve the service."
});
}
catch (FabricException)
{
return(new ContentResult {
StatusCode = 503, Content = "The service was unable to process the request. Please try again."
});
}
}
public static void ThrowIfNotValidUserRequest(UserRequestModel user)
{
if (string.IsNullOrWhiteSpace(user.Username))
{
throw new InvalidUserRequestException("Username cannot be null, empty or contain whitespace");
}
}
public User(UserRequestModel user)
{
Id = Guid.NewGuid();
Name = user.Name;
Age = user.Age;
Cpf = user.Cpf;
}
public async Task <string> Create(UserRequestModel userRequestModel)
{
var user = _mapper.Map <User>(userRequestModel);
var mobileNumber = _mapper.Map <List <UserMobileNumber> >(userRequestModel.UserMobileNumbers);
var images = _mapper.Map <List <UserImage> >(userRequestModel.Images);
var userRelateds = _mapper.Map <List <UseRelated> >(userRequestModel.userRelateds);
await _userRepository.AddAsync(user);
if (mobileNumber.Count > 0)
{
mobileNumber.ForEach(x => x.AssignedUserId(user.Id));
mobileNumber.ForEach(x => _userMobileRepository.AddAsync(x).Wait());
}
await UserSaveImages(userRequestModel.Images, user.Id);
if (userRelateds.Count > 0)
{
userRelateds.ForEach(x => x.AssignedUserId(user.Id));
userRelateds.ForEach(x => _userRelatedRepository.AddAsync(x).Wait());
}
return(ResultStatus.SUCCESS);
}
public async Task <IActionResult> PutUser([FromRoute] string userId, [FromBody] UserRequestModel userModel)
{
var user = UserRequestModel.MapToUser(userModel, userId);
await _userStore.SaveUserAsync(user);
return(Ok(UserResponseModel.MapFrom(user, Url)));
}
public async Task <IActionResult> PostUser([FromBody] UserRequestModel userModel)
{
var user = UserRequestModel.MapToUser(userModel, userId: null);
await _userStore.SaveUserAsync(user);
return(CreatedAtRoute(nameof(GetUser), new { userId = user.UserId }, null));
}
public ActionResult <User> PostUser([FromBody] UserRequestModel user)
{
try
{
User _user = new User
{
Address = user.Address,
City = new City
{
Id = user.CityId
},
ContactNumber = new ContactNumberFormat(user.CountryCode, user.CompanyCode, user.Phone),
Location = user.Location,
Name = user.Name
};
using (var scope = container.BeginLifetimeScope())
{
using (var repository = scope.Resolve <IUserRepository>())
{
_user = repository.Read(repository.Create(_user));
}
}
return(_user);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult Put([FromBody] UserRequestModel user)
{
try
{
User _user = new User
{
Address = user.Address,
Name = user.Name,
Location = user.Location,
City = new City
{
Id = user.CityId
},
Id = user.Id,
ContactNumber = new EFarmer.Models.Helpers.ContactNumberFormat(user.CountryCode, user.CompanyCode, user.Phone)
};
using (var scope = container.BeginLifetimeScope())
{
using (var repository = scope.Resolve <IUserRepository>())
{
repository.Update(_user);
}
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ResponseModel SaveUserAccount(UserRequestModel request)
{
ResponseModel response = new ResponseModel();
using (var dbContextTransaction = _context.Database.BeginTransaction())
{
try
{
UserEntity userid = _context.userEntities.Where(w => w.UserName == request.UserName.Trim()).FirstOrDefault();
if (userid == null)
{
userid = new UserEntity()
{
UserName = request.UserName,
EmailAddress = request.EmailAddress,
RealName = null,
ModifiedDate = DateTime.Now
};
_context.userEntities.Add(userid);
_context.SaveChanges();
userid.UsersID = userid.UsersID;
WebpagesMembershipEntity members = _context.membershipEntities.Where(w => w.UserId == userid.UsersID).FirstOrDefault();
if (members == null)
{
var memData = new WebpagesMembershipEntity()
{
UserId = userid.UsersID,
CreateDate = DateTime.Now,
PasswordFailuresSinceLastSuccess = 0,
Password = request.Password,
PasswordSalt = "O"
};
_context.membershipEntities.Add(memData);
_context.SaveChanges();
}
dbContextTransaction.Commit();
}
response.data = userid;
response.success = true;
response.message = "OK";
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
dbContextTransaction.Rollback();
response.success = false;
response.error = ex.Message;
}
}
return(response);
}
/// <summary>
/// Create
/// </summary>
/// <param name="userResponseModel"></param>
/// <param name="ct"></param>
/// <returns></returns>
public async Task <UserResponseModel> CreateAsync(UserRequestModel userRequestModel, int agencyId, CancellationToken ct = default)
{
Agency agency = await _agencyRepository.FindAsync(x => x.Id == agencyId, ct);
if (agency is null)
{
throw new IdentityException("Invalid Agency.");
}
User user = await _userRepository.FindAsync(x => x.UserName == userRequestModel.Email, ct);
if (user != null)
{
throw new IdentityException("This email already registered.");
}
user = _mapper.Map <User>(userRequestModel);
user.Password = _passHasher.HashPassword(user, userRequestModel.Password);
user.Employee.Agency = agency;
user.Status = Status.Active;
_userRepository.Add(user);
await _unitOfWork.SaveChangesAsync(ct);
var data = _mapper.Map <UserResponseModel>(user);
return(data);
}
/// <summary>
/// Updates a user in the user store.
/// </summary>
/// <param name="userRequest"></param>
/// <returns></returns>
public async Task <bool> UpdateUserAsync(UserRequestModel userRequest, CancellationToken cancellationToken = default(CancellationToken))
{
Validation.ThrowIfNotValidUserRequest(userRequest);
var success = await this.Users.UpdateUserAsync(userRequest, cancellationToken);
return(success);
}
public async void SignUp_API_Should_Create_ConsumerType_User()
{
//Arrange
var services = BuildServices("SignUp_API_Should_Create_ConsumerType_User");
var context = services.GetRequiredService <FoodAppDbContext>();
var userService = services.GetRequiredService <IUserService>();
var controller = new AuthController(userService, new Models.Config.ConfigSettings {
SigningKey = Guid.NewGuid().ToString(), AuthTokenExpiryInHours = "1"
}, new Mock <ILogger <AuthController> >().Object);
var userRequestModel = new UserRequestModel
{
Email = "*****@*****.**",
Password = "******",
FirstName = "Test",
LastName = "User"
};
//Act
var result = await controller.SignUp(userRequestModel);
// Assert
var okResult = result as AcceptedResult;
var user = await context.Users.FirstOrDefaultAsync(x => x.Email == userRequestModel.Email);
Assert.NotNull(user);
Assert.Equal(user.UserType, (int)UserType.Consumer);
Assert.Equal((int)HttpStatusCode.Accepted, okResult.StatusCode);
}
public ActionResult UserRequests()
{
var model = new List <UserRequestModel>();
var result = UserRequestsRepo.LoadRequests();
if (result.HasError)
{
ViewBag.Error = result.Message;
return(View(model));
}
foreach (var v in result.Data)
{
var modelObj = new UserRequestModel();
modelObj.UserName = v.UserName;
modelObj.FullName = v.Name;
modelObj.Email = v.Email;
modelObj.Address = v.Address;
modelObj.ID = v.ID;
modelObj.Status = "Not Approved";
modelObj.selectedList = "0";
model.Add(modelObj);
}
return(View(model));
}
/// <summary>
/// Adds a new user to the user store.
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public async Task <string> AddUserAsync(UserRequestModel userRequest, CancellationToken cancellationToken)
{
Validation.ThrowIfNotValidUserRequest(userRequest);
var userId = await this.Users.AddUserAsync(userRequest, cancellationToken);
return(userId);
}
public async Task should_update_user()
{
//arrange
var userId = Guid.NewGuid();
var model = new UserRequestModel()
{
IsActive = false,
Login = "******",
Name = "Grahl12",
Password = "******"
};
var user = new UserBuilder()
.WithName("Grahl")
.ComLogin("grahl")
.IsActive()
.ComSenha("123456789")
.Construct();
_userRepository
.GetById(userId)
.Returns(user);
//action
await _userService
.Update(userId, model);
//assert
await _userRepository
.Received(1)
.Update(Arg.Is <User>(d => d.IsActive == false &&
d.Login == "grahl" &&
d.Name.ToString() == "Grahl12" &&
d.Password == "12345678"));
}
//need username
public async Task <ActionResult <MessageModel> > DeleteUser(UserRequestModel requestModel)
{
//need username
var currentUser = HttpContext.User;
return(await _userService.DeleteUser(currentUser, requestModel));
}
public async Task <ActionResult <MessageModel> > CreateUser(UserRequestModel requestModel)
{
//need user(Firstname, Lastname, username, password, birthdate, email)
var currentUser = HttpContext.User;
return(await _userService.CreateUser(currentUser, requestModel));
}
public async Task <int> Post([FromBody] UserRequestModel model)
{
var command = new CreateUserCommandRequest(model);
var response = await mediator.Send(command);
return(response);
}
public IHttpActionResult Put(UserRequestModel userRequest)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest("Invalid Id and Value");
}
this.userServices.UpdateRate(int.Parse(userRequest.UserId), int.Parse(userRequest.Value));
return this.Ok();
}
private async void ExecuteLoginCommand()
{
Requester requester = new Requester();
UserRequestModel requestModel = new UserRequestModel
{
UserName = this.UserName,
Password = Password
};
string requestBody = JsonConvert.SerializeObject(requestModel);
HttpStringContent requestContent = new HttpStringContent(requestBody, UnicodeEncoding.Utf8, "application/json");
string response = string.Empty;
try
{
response = await requester.PutJsonAsync("/api/users/token", requestContent);
}
catch (Exception)
{
MessageDialogNotifier.Notify("There was an error on the server. Please contact the server administrators.");
}
UserResponseModel user = JsonConvert.DeserializeObject<UserResponseModel>(response);
if (string.IsNullOrEmpty(user.UserName) ||
string.IsNullOrEmpty(user.Token))
{
MessageDialogNotifier.Notify("Invalid username or password.");
}
else
{
Data data = new Data();
UserDatabaseModel databaseUser = new UserDatabaseModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Id = user.Id,
RegistrationDate = user.RegistrationDate,
UserName = user.UserName,
Token = user.Token
};
await data.UpdateCurrentUserAsync(databaseUser);
UserDatabaseModel currentUser = await data.GetCurrentUser();
MessageDialogNotifier.Notify(string.Format("Hello {0} {1}!\nYou are now logged in.", currentUser.FirstName, currentUser.LastName));
}
}
