protected async override void OnStepCommand()
{
if (ValidateForm())
{
if (_collectedInputsArgs != null)
{
ResetCancellationTokenSource(ref _checkUserNameCancellationTokenSource);
CancellationTokenSource cancellationTokenSource = _checkUserNameCancellationTokenSource;
Guid busyKey = Guid.NewGuid();
SetBusy(busyKey, true);
try {
UserNameAvailability userNameAvailability = await _identityService.CheckUserNameAvailabiltyAsync(MainInput.Value, cancellationTokenSource.Token);
if (userNameAvailability != null)
{
if (userNameAvailability.IsRequestSuccess)
{
_collectedInputsArgs.Name = MainInput.Value;
await NavigationService.NavigateToAsync <PasswordRegisterStepViewModel>(_collectedInputsArgs);
}
else
{
ServerError = userNameAvailability.Message;
}
}
}
catch (Exception ex) {
var error = JsonConvert.DeserializeObject <HttpRequestExceptionResult>(ex.Message);
ServerError = error.Message;
Debug.WriteLine($"ERROR:{ex.Message}");
Debugger.Break();
}
SetBusy(busyKey, false);
}
else
{
Debugger.Break();
await NavigationService.GoBackAsync();
}
}
}
public async Task <UserNameAvailability> CheckUserNameAvailabiltyAsync(string userNmae, CancellationToken cancellationToken = default(CancellationToken)) =>
await Task.Run(async() => {
UserNameAvailability userNameAvailability = null;
string url = string.Format(BaseSingleton <GlobalSetting> .Instance.RestEndpoints.IdentityEndpoints.CheckUserNameEndpoint, userNmae);
try {
userNameAvailability = await _requestProvider.GetAsync <UserNameAvailability>(url);
}
catch (ConnectivityException ex) {
throw ex;
}
catch (HttpRequestExceptionEx ex) {
throw ex;
}
catch (Exception ex) {
Debug.WriteLine($"ERROR:{ex.Message}");
Debugger.Break();
}
return(userNameAvailability);
}, cancellationToken);
public MediatorResponse <RegisterViewModel> Register(RegisterViewModel registerViewModel)
{
var emailAddress = string.IsNullOrWhiteSpace(registerViewModel.EmailAddress)
? string.Empty
: registerViewModel.EmailAddress.Trim();
UserNameAvailability userNameAvailable;
if (string.IsNullOrWhiteSpace(emailAddress))
{
userNameAvailable = new UserNameAvailability
{
HasError = false,
IsUserNameAvailable = false
};
}
else
{
userNameAvailable = _candidateServiceProvider.IsUsernameAvailable(emailAddress);
}
if (!userNameAvailable.HasError)
{
registerViewModel.IsUsernameAvailable = userNameAvailable.IsUserNameAvailable;
var validationResult = _registerViewModelServerValidator.Validate(registerViewModel);
if (!validationResult.IsValid)
{
return(GetMediatorResponse(RegisterMediatorCodes.Register.ValidationFailed, registerViewModel, validationResult));
}
var registered = _candidateServiceProvider.Register(registerViewModel);
if (registered)
{
return(GetMediatorResponse(RegisterMediatorCodes.Register.SuccessfullyRegistered, registerViewModel));
}
}
return(GetMediatorResponse(RegisterMediatorCodes.Register.RegistrationFailed, registerViewModel, RegisterPageMessages.RegistrationFailed, UserMessageLevel.Warning));
}
public UserNameAvailability IsUsernameAvailable(string username)
{
_logger.Debug("Calling CandidateServiceProvider to if the username {0} is available.", username);
var userNameAvailability = new UserNameAvailability();
try
{
userNameAvailability.IsUserNameAvailable = _userAccountService.IsUsernameAvailable(username);
}
catch (Exception ex)
{
const string errorMessage = "Error checking user name availability for {0}";
var message = string.Format(errorMessage, username);
_logger.Error(message, ex);
userNameAvailability.HasError = true;
userNameAvailability.ErrorMessage = errorMessage;
}
return(userNameAvailability);
}
