public async Task <UserDTO> SignupUserAsync(SignUpPayload payload, CancellationToken ct = default)
{
var count = await _users.CountDocumentsAsync(user => user.Email !.Equals(payload.Email), null, ct);
if (count > 0)
{
throw new ArgumentException("User Already Exists");
}
var password = BCryptNet.EnhancedHashPassword(payload.Password);
var user = new User
{
Email = payload.Email,
LastName = payload.LastName,
Name = payload.Name,
Password = password
};
await _users.InsertOneAsync(user, null, ct);
var newUser = await _users.FindAsync(user => user.Email == payload.Email, null, ct);
var firstuser = newUser.FirstOrDefault(ct);
return(new UserDTO
{
Email = firstuser.Email,
LastName = firstuser.LastName,
Name = firstuser.Name,
Id = firstuser.Id
});
}
public async Task <bool> SignupAsync(SignUpPayload payload)
{
using var http = _httpFactory.CreateClient(Constants.AUTH_CLIENT_NAME);
try
{
var res = await http.PostAsJsonAsync($"{http.BaseAddress}/signup", payload);
if (res.IsSuccessStatusCode)
{
var auth = await res.Content.ReadFromJsonAsync <AuthResponse>();
_localstorage.SetItem(Constants.ACCESS_TOKEN_NAME, auth?.Token);
_localstorage.SetItem(Constants.USER_DATA_NAME, auth?.User);
}
else
{
var content = await res.Content.ReadFromJsonAsync <ErrorResponse>();
Console.Error.WriteLine($"Failed to Login: {content?.Message}");
return(false);
}
}
catch (System.Exception e)
{
Console.Error.WriteLine($"Error at signup {e.Message} - {e.StackTrace}");
return(false);
}
return(true);
}
public static void SignUpUser(SignUpPayload payload, ResponseCallback callback, ResponseFallback fallback)
{
HttpClient httpClient = new HttpClient();
Request request = new Request(HttpClient.Method.POST, Route.SIGNUP_ROUTE, payload);
httpClient.Request(
request,
(statusCode, response) => {
SignUpResponse signUpResponse = Deserialize(response);
callback(signUpResponse);
},
(statusCode, error) => {
if (statusCode == StatusCodes.CODE_VALIDATION_ERROR)
{
ValidationError validationError = ErrorDeserilizer.DeserializeValidationErrorData(error);
fallback(statusCode, validationError);
}
else
{
GenericError genericError = ErrorDeserilizer.DeserializeGenericErrorData(error);
fallback(statusCode, genericError);
}
}
);
}
private async Task <IResult> OnSignUp(SignUpPayload payload, IAuthService _auth, HttpContext ctx)
{
var result = ctx.Request.Validate(payload);
if (!result.IsValid)
{
return(Results.BadRequest(new ErrorResponse("Failed Validation")
{
Errors = result.GetFormattedErrors()
}));
}
try
{
var user = await _auth.SignupUserAsync(payload);
if (user is null)
{
return(Results.UnprocessableEntity(new ErrorResponse("Failed to signup user")));
}
var token = _auth.SignJwtToken(user);
return(Results.Ok(new AuthResponse(token, user)));
}
catch (System.ArgumentException e)
{
return(Results.BadRequest(new ErrorResponse(e.Message)));
}
}
