public string NewUser(NewUserRequest model)
{
var duplicate = _context.User.Any(i => i.Email == model.Email);
if (!duplicate)
{
string password = Encrypt.GetSHA256(model.Password);
if (model.Password == model.ConfirmPassword)
{
User newUser = new User
{
Email = model.Email,
Password = password,
Name = model.Name
};
_context.User.Add(newUser);
_context.SaveChanges();
return(newUser.ToString());
}
return("Incorrect Password");
}
return("Duplicate Email");
}
/// <summary>
/// Used only when admin is adding new user
/// </summary>
/// <param name="newUserRequest"></param>
/// <param name="adminId"></param>
/// <returns></returns>
public async Task <Core.Models.Result.Result <string> > AddUser(NewUserRequest newUserRequest, string adminId)
{
ValidationResult validationResult = _newUserValidator.Validate(newUserRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid NewUserRequest. Admin {adminId}");
return(Core.Models.Result.Result.Fail <string>(ResultUtils.ToResultError(validationResult.Errors)));
}
BaseRegisterRequest baseRegisterRequest = new BaseRegisterRequest
{
Username = newUserRequest.UserName,
Email = newUserRequest.Email,
FirstName = newUserRequest.FirstName,
LastName = newUserRequest.LastName,
};
Result <AppUserEntity> addUserResult = await AddUser(baseRegisterRequest, false, false, false);
if (addUserResult.Failure)
{
return(Core.Models.Result.Result.Fail <string>(addUserResult.ResultMessages.Select(x => new Core.Models.Result.Result.ResultError(x.Code, x.Code)).ToList()));
}
return(Core.Models.Result.Result.Ok(addUserResult.Value.Id));
}
private IActionResult CreateNewUser(NewUserRequest newUserRequest)
{
try
{
User u = new User(
newUserRequest.Name,
null,
newUserRequest.Surname,
DateTime.ParseExact(newUserRequest.Birthday, "dd/MM/yyyy", null),
newUserRequest.Kennitala,
0,
0.0,
null
);
iupUsersContext.Users.Add(u);
AppIdentity aId = new AppIdentity(newUserRequest.Kennitala, BCrypt.Net.BCrypt.HashPassword(newUserRequest.Password));
iupUsersContext.AppIdentities.Add(aId);
iupUsersContext.SaveChanges();
return(Ok());
}
catch (Exception)
{
//Eccezione da gestire nel modo corretto
return(StatusCode(500));
}
}
/// <summary>
/// 初始化超级用户
/// </summary>
/// <returns></returns>
public bool InitSuperUser(NewUserRequest request)
{
bool success = false;
var super = UsersAccessor.GetSuperUser();
string[] codes = PermissionCache.Instance.GetCodeArray();
if (super != null)
{
UserManage manage = new UserManage(super);
success = manage.ModifyTo(new UserModifyState
{
Email = request.Email,
Mobile = request.Mobile,
Name = request.Name,
Title = request.Title,
UserName = request.Username,
Password = request.Password,
Permissions = codes
});
}
else
{
request.Permissions = codes;
NewUser newUser = new NewUser(request, true);
success = newUser.Save();
}
return(success);
}
private static async Task <NewUserRequest> AddUser()
{
var client = new HttpClient();
var uuid = Guid.Parse("876eb143-e9f6-4024-8908-db14704e9678");
var user = new NewUserRequest()
{
UUid = uuid,
Id = 46457,
Email = "*****@*****.**",
EmailVerified = true,
FamilyName = "Palotes",
GivenName = "Pepito",
Locale = "en",
Name = "Pepito Palotes",
NickName = "pepito",
Password = "******",
Picture = "https://cdn.pixabay.com/photo/2020/02/22/16/29/penguin-4871045_1280.png",
Sub = $"auth0|{uuid}",
UpdatedAt = DateTime.UtcNow,
UserZoomName = "Pepito Palotes",
};
var request = new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json");
var result = await client.PostAsync($"{hostAddress}/Instrumentation", request);
result.EnsureSuccessStatusCode();
return(user);
}
public async Task <Response> RegisterUserAsync(
string _urlBase,
string _servicePrefix,
string _controller,
NewUserRequest _newUserRequest)
{
try
{
var request = JsonConvert.SerializeObject(_newUserRequest);
var content = new StringContent(request, Encoding.UTF8, "application/json");
var client = new HttpClient
{
BaseAddress = new Uri(_urlBase)
};
var url = $"{_servicePrefix}{_controller}";
var response = await client.PostAsync(url, content);
var answer = await response.Content.ReadAsStringAsync();
var obj = JsonConvert.DeserializeObject <Response>(answer);
return(obj);
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message,
});
}
}
private void AssertIsValid(NewUserRequest newUserRequest)
{
if (string.IsNullOrEmpty(newUserRequest.UserName))
{
throw new ArgumentException(nameof(newUserRequest), $"{nameof(newUserRequest.UserName)} is missing");
}
}
public NewUser(NewUserRequest request, bool isSuperUser)
{
ID = IDProvider.NewId;
if (request != null)
{
Username = request.Username;
Email = request.Email;
Mobile = request.Mobile;
Password = request.Password;
Name = request.Name;
Title = request.Title;
Permissions = request.Permissions;
IgnorePermission = request.IgnorePermission;
IsSuper = isSuperUser;
}
Study = new UserStudy
{
UserId = this.ID,
Answers = 0,
Average = 0,
ReadCount = 0,
StudyPlans = 0,
StudyTimes = 0,
TestExams = 0
};
}
public async void Create_NewUser_ReturnCreatedResponse()
{
//Arrange
var newUser = new NewUserRequest
{
CPF = "49779200070",
Name = "Novo usuário incluido",
Email = "*****@*****.**",
Password = "******",
Role = UserRoleEnum.Consumer
};
//Act
var response = await TestClient.PostAsJsonAsync(ApiRoutes.User.Register, newUser);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.Created);
var returnedUser = await response.Content.ReadFromJsonAsync <NewUserResponse>();
returnedUser.Id.Should().BeGreaterThan(0);
returnedUser.CPF.Should().Be(newUser.CPF);
returnedUser.Name.Should().Be(newUser.Name);
returnedUser.Email.Should().Be(newUser.Email);
returnedUser.Role.Should().Be(newUser.Role);
}
public NewUserResponse RegisterUser(NewUserRequest newUserRequest)
{
var newUser = new User
{
CPF = newUserRequest.CPF,
Name = newUserRequest.Name,
Email = newUserRequest.Email,
Password = _crypoHelper.GenerateHash(newUserRequest.Password),
Phone = newUserRequest.Phone,
Role = newUserRequest.Role
};
var addedUser = _userRepository.Add(newUser);
_userRepository.SaveChanges();
return(new NewUserResponse
{
Id = addedUser.Id,
CPF = addedUser.CPF.ToString(),
Name = addedUser.Name,
Email = addedUser.Email,
Phone = addedUser.Phone,
Role = addedUser.Role
});
}
public async Task <IActionResult> PostUser([FromBody] NewUserRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = "Bad request"
}));
}
var user = await _userHelper.GetUserByEmailAsync(request.Email);
if (user != null)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = "This email is already registered."
}));
}
user = new Data.Entities.User
{
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
UserName = request.Email,
Address = request.Address,
PhoneNumber = request.Phone,
EmailConfirmed = true
};
var result = await _userHelper.AddUserAsync(user, request.Password);
if (result != IdentityResult.Success)
{
return(BadRequest(result.Errors.FirstOrDefault()?.Description));
}
return(Ok());
// Email confirmation commented
//var myToken = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
//var tokenLink = Url.Action("ConfirmEmail", "Account", new
//{
// userid = user.Id,
// token = myToken
//}, protocol: HttpContext.Request.Scheme);
//_mailHelper.SendMail(request.Email, "Email confirmation", $"<h1>Email Confirmation</h1>" +
// $"To allow the user, " +
// $"please click in this link:</br></br><a href = \"{tokenLink}\">Confirm Email</a>");
//return Ok(new Response
//{
// IsSuccess = true,
// Message = "A Confirmation email was sent. Please confirm your account and log into the App."
//});
}
// Request to create a new user in the server, returns the user id of new user if successful
public static int?CreateNewUser(string userName, string email)
{
var req = new NewUserRequest();
req.email = email;
req.userName = userName;
req.timestamp = GetTimeStamp();
req.token = Password;
WWWForm form = new WWWForm();
form.AddField("message", JsonUtility.ToJson(req));
WWW w = new WWW(NewUserUrl, form);
// wait until complete
while (!w.isDone)
{
}
if (!string.IsNullOrEmpty(w.error))
{
Debug.Log(w.error);
return(null);
}
else
{
ThrowExceptionIfError(w.text);
var res = JsonUtility.FromJson <NewUserResponse>(w.text);
return(res.uid);
}
}
private static async Task DeleteUser(NewUserRequest request)
{
var client = new HttpClient();
var result = await client.DeleteAsync($"{hostAddress}/Instrumentation/{request.UUid}");
result.EnsureSuccessStatusCode();
}
public async Task<IActionResult> RegisterUserAsync([FromBody] NewUserRequest request)
{
if (!ModelState.IsValid)
{ return BadRequest(new Resp<object>{ IsSuccess = false, Message = MessageErrorHelper.showModelStateError(ModelState) }); }
var user = await _userHelper.GetUserByEmailAsync(request.Correo);
if (user != null)
{ return BadRequest(new Resp<object> { IsSuccess = false, Message = MessageCenter.appTextEmailUsed }); }
var newUser = new UsuarioViewModel { Correo = request.Correo
, CellPhone = request.CellPhone
, FirstName = request.FirstName
, LastName = request.LastName
, RoleId = request.RoleId
, Rol = _combosHelper.GetComboRolesByValue(request.RoleId.ToString())
, Password = request.Password
, PasswordConfirm = request.PasswordConfirm
};
var addUserResult = await _userHelper.AddUsuario(newUser);
if (addUserResult != IdentityResult.Success)
{ return BadRequest(new Resp<object> { IsSuccess = false, Message = MessageErrorHelper.showIdentityResultError(addUserResult) }); }
var userLogin = await _userHelper.GetUserByEmailAsync(request.Correo);
var myToken = await _userHelper.GenerateEmailConfirmationTokenAsync(userLogin);
var tokenLink = Url.Action("ConfirmEmail", "Account", new { userid = userLogin.Id,
token = myToken
}, protocol: HttpContext.Request.Scheme);
_mailHelper.SendEmailAccountConfirmation(request.Correo, tokenLink);
return Ok(new Resp<object>{ IsSuccess = true, Message = MessageCenter.commonMessageEmailInst });
}
public async Task <IActionResult> PostUser([FromBody] NewUserRequest request)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(new Response
{
IsSuccess = false,
Message = "Bad request"
}));
}
var user = await this.userHelper.GetUserByEmailAsync(request.Email);
if (user != null)
{
return(this.BadRequest(new Response
{
IsSuccess = false,
Message = "This email is already registered."
}));
}
var city = await cityRepository.GetCityByIdAsync(request.CityId);
if (city == null)
{
return(this.BadRequest(new Response
{
IsSuccess = false,
Message = "City don't exists."
}));
}
user = new Models.User // Api/Models
{
FirstName = request.FirstName,
Email = request.Email,
UserName = request.Email,
CityId = request.CityId,
City = city
};
var result = await this.userHelper.AddUserAsync(user, request.Password);
if (result != IdentityResult.Success)
{
return(this.BadRequest(result.Errors.FirstOrDefault()?.Description));
}
// Aniadimos el rol al usuario y guardamos en bbdd
await this.userHelper.AddUserToRoleAsync(user, "Customer");
return(Ok(new Response
{
IsSuccess = true,
Message = "Usuario creado correctamente."
}));
}
private UserResponse ExpectedUserResponse(string email, NewUserRequest request, string roleId)
=> new UserResponse()
{
Email = email,
FirstName = request.FirstName,
LastName = request.LastName,
Role = roleId ?? RoleId.User,
Status = UserStatusId.Pending,
};
private void AddUserClick(object sender, RoutedEventArgs e)
{
NewUserRequest?.Invoke(this, new NewUSerEventArgs(username.Text, firstname.Text, lastname.Text));
username.Clear();
firstname.Clear();
lastname.Clear();
username.Focus();
}
/// <summary>
/// Initializes the target object for the page
/// </summary>
/// <remarks>Many pages have "target" objects that the page operates on. For instance, when viewing
/// an event, the target object is an event. When looking up a directory, that's the target
/// object. This method is intended to be overriden to initialize the target object for
/// each page that needs it.</remarks>
protected override void InitializeTargetObject()
{
base.InitializeTargetObject();
targetRequest = MultiStepWizards.CreateAccount.Request;
if (targetRequest == null)
{
GoTo("~/profile/CreateAccount_BasicInfo.aspx");
}
}
public void Should_add_new_users(string username)
{
var userRequest = new NewUserRequest {
Username = username
};
var result = _sut.AddUserAsync(userRequest).Result;
Assert.Equal(username, result.Username);
Assert.NotEqual(Guid.Empty, result._id);
}
private string ValidateUser(NewUserRequest model)
{
var reg = new Regex(@"^\S+@\S+$");
if (!reg.Match(model.Email).Success)
{
return("Invalid Email");
}
return(null);
}
public async Task <ActionResult <NewUserResponse> > Register([FromBody] NewUserRequest newUserRequest)
{
var response = _userService.RegisterUser(newUserRequest);
if (response == null)
{
return(BadRequest(response));
}
return(Created(ApiRoutes.User.BaseRoute + "/" + response.Id, response));
}
public async Task <ActionResult> CreateBuyer(NewUserRequest newUserRequest)
{
newUserRequest.Id = this.GetRequestUserId();
Response response = await this.buyersManager.CreateBuyer(newUserRequest).ConfigureAwait(false);
if (response.IsOperationSucceeded)
{
return(this.StatusCode(StatusCodes.Status201Created, response.SuccessOrFailureMessage));
}
return(this.StatusCode(StatusCodes.Status403Forbidden, response.SuccessOrFailureMessage));
}
public async Task <UserInfoResponse> AddUserAsync(NewUserRequest request)
{
var user = new User {
UserName = request.Username
};
var savedUser = repository.AddUser(user);
await repository.UnitOfWork.SaveChangesAsync();
return(new UserInfoResponse {
_id = savedUser.Id, Username = savedUser.UserName
});
}
public IActionResult Register(NewUserRequest newUser)
{
var result = _userRepository.Save(_mapper.Map <User>(newUser));
if (!result.IsSuccess)
{
return(BadRequest(result));
}
result.Data = _mapper.Map <UserViewModel>(result.Data);
return(Ok(result));
}
public async Task <NewUserResponse> NewUser(NewUserRequest request)
{
using var httpClient = new HttpClient();
StringContent content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
using var response = await httpClient.PostAsync(_configuration["ApiUrl"] + "/user/newuser", content);
string apiResponse = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <NewUserResponse>(apiResponse));
}
// USER
public async Task <AddUserResponse> AddUser(NewUserRequest user)
{
var uri = new Uri(_baseAddress + "/users/Add");
var message = new HttpRequestMessage(HttpMethod.Post, uri)
{
Content = new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json")
};
var response = await GetResponse <AddUserResponse>(message);
return(response);
}
public async Task <IActionResult> Create([FromBody] NewUserRequest login)
{
var results = await _userManager.CreateAsync(new ApplicationUser { UserName = login.UserName }, login.Password);
if (results.Succeeded)
{
return(Ok());
}
else
{
return(BadRequest(results.Errors));
}
}
public async Task<IActionResult> Create([FromBody] NewUserRequest request)
{
var results = await _userService.CreateUser(_mapper.Map<ApplicationUser>(request), request.Password);
if (results.Succeeded)
{
return Ok(new { message = "Created" });
}
else
{
return BadRequest(results.Errors);
}
}
public async Task <AddUserResponse> RegisterUser(string userName, string password, string email, int countryId)
{
try
{
var user = new NewUserRequest(userName, Encryption.ComputeHash(password), email, countryId);
var userId = await _apiClient.AddUser(user);
return(userId);
}
catch (System.Exception)
{
return(new AddUserResponse(UserCodes.Invalid));
}
}
public IActionResult CreateUser([FromBody] NewUserRequest request)
{
if (request == null)
{
return(BadRequest());
}
try {
var token = _authManager.CreateUser(request.UserName, request.Password);
return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) }));
} catch (DuplicateUserException) {
return(BadRequest("User already exists"));
}
}
public NewUserViewModel New(NewUserRequest request)
{
return new NewUserViewModel();
}
