public async Task <IActionResult> ExternalAuth([FromBody] ExternalUserDto externalUser)
{
try
{
var userData = await authenticationService.GetUserDataByEmail(externalUser.Email);
if (userData != null)
{
var personalData = await personService.GetPersonalDataByUserId(userData.Id);
var personDataBasic = mapper.Map <PersonBasicDto>(personalData);
return(CustomResponse(await authenticationService.GenerateJwt(userData.Email, personDataBasic)));
}
else
{
var result = await authenticationService.CreateNewExternalUser(externalUser);
if (result.Succeeded)
{
var user = await authenticationService.GetUserDataByEmail(externalUser.Email);
var person = new CreatePersonDto
{
PersonId = Guid.NewGuid(),
FirstName = externalUser.FirstName,
LastName = externalUser.LastName,
CreatedDate = DateTime.Now,
UserId = Guid.Parse(user.Id)
};
if (await personService.CreatePerson(person))
{
var personDataBasic = mapper.Map <PersonBasicDto>(person);
return(CustomResponse(await authenticationService.GenerateJwt(externalUser.Email, personDataBasic)));
}
else
{
var createdUser = await userManager.FindByEmailAsync(externalUser.Email);
await userManager.DeleteAsync(createdUser);
AddProccessError("Falha ao registrar novo usuário");
}
}
foreach (var error in result.Errors)
{
AddProccessError(error.Description);
}
return(CustomResponse());
}
}
catch (Exception ex)
{
return(HandleException(ex.Message));
}
}
public async Task <ActionResult> ExternalAuth([FromBody] ExternalUserDto externalUser)
{
var user = _userManager.Users.Where(x => x.ExternalUserId == externalUser.ExternalUserId).FirstOrDefault();
if (user != null)
{
return(CustomResponse(await _authenticationService.GenerateJWT(user.Email)));
}
else
{
var newUser = new ApplicationUser
{
FirstName = externalUser.FirstName,
LastName = externalUser.LastName,
UserName = externalUser.Email,
Email = externalUser.Email,
Provider = externalUser.Provider,
ExternalUserId = externalUser.ExternalUserId
};
var result = await _userManager.CreateAsync(newUser);
if (result.Succeeded)
{
return(CustomResponse(await _authenticationService.GenerateJWT(externalUser.Email)));
}
foreach (var error in result.Errors)
{
AddProccessError(error.Description);
}
return(CustomResponse());
}
}
public async Task Init()
{
newUser = new UserRegisterDto
{
FirstName = "Test",
LastName = "Testaroo",
Email = "*****@*****.**",
Password = "******",
PasswordConfirmation = "test123456"
};
var response = await DoPostRequest(AUTH_REGISTER, newUser);
response.EnsureSuccessStatusCode();
externalUser = new ExternalUserDto
{
FirstName = "Test",
LastName = "Test2",
Email = "*****@*****.**",
Provider = "GOOGLE",
ExternalUserId = EXTERNAL_USER_ID
};
var externalRegisterResponse = await DoPostRequest(AUTH_EXTERNAL, externalUser);
externalRegisterResponse.EnsureSuccessStatusCode();
}
public async Task ExternalUserAuthentication_GivenThatTheUserDoesExist_ShouldAuthenticateUserAndReturnLoginToken()
{
var externalUserLogin = new ExternalUserDto
{
FirstName = "Test",
LastName = "Test2",
Email = "*****@*****.**",
Provider = "GOOGLE",
ExternalUserId = EXTERNAL_USER_ID
};
var response = await DoPostRequest(AUTH_EXTERNAL, externalUserLogin);
response.EnsureSuccessStatusCode();
var respString = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize <UserLoginTokenResponseDto>(respString, new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(result);
Assert.NotNull(result.UserToken);
Assert.AreEqual(result.UserToken.Email, externalUser.Email);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.AccessToken));
}
public async Task <IdentityResult> CreateNewExternalUser(ExternalUserDto externalUser)
{
var newUser = new ApplicationUser
{
UserName = externalUser.Email,
Email = externalUser.Email,
Provider = externalUser.Provider,
ExternalUserId = externalUser.ExternalUserId
};
return(await userManager.CreateAsync(newUser));
}
private static ExternalUserDto CreateExternalUser(string email, string firstname, string lastname, string pictureSrc)
{
var externalUser = new ExternalUserDto
{
Email = email,
FirstName = firstname,
LastName = lastname,
PictureSrc = pictureSrc
};
return(externalUser);
}
public async Task ExternalUserAuthentication_GivenThatUserDoesNotExistAndModelStateIsInvalid_ShouldReturnBadRequest()
{
var externalUser = new ExternalUserDto
{
FirstName = "Test",
LastName = "Test2"
};
var response = await DoPostRequest(AUTH_EXTERNAL, externalUser);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
private ExternalUserDto CreateUserFromFacebook(dynamic profile)
{
var email = profile[_facebookOptions.EmailKey];
var firstname = profile[_facebookOptions.FirstNameKey];
var lastname = profile[_facebookOptions.LastNameKey];
var pictureSrc = GetPhotoFromFacebook(profile);
var externalUser = new ExternalUserDto
{
Email = email,
FirstName = firstname,
LastName = lastname,
PictureSrc = pictureSrc
};
return(externalUser);
}
public CreateUser(ExternalUserDto externalUserDto)
{
ExternalUserDto = externalUserDto;
}
