private async Task AssertNewUserIsPersisted(UserRegistrationResponse response)
{
var repository = _fixture.GetService <IAggregateStore <User> >();
var user = await repository.Load(response.Id);
Assert.NotNull(user);
}
public UserRegistrationPage()
{
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
// ImageCtryFlage.Source = "https://restcountries.eu/data/aut.svg";
_objCountryListResponse = new CountryListResponse();
_objUserRegistrationResponse = new UserRegistrationResponse();
_objUserRegistrationRequest = new UserRegistrationRequest();
BindingContext = _objUserRegistrationRequest;
_apiServices = new RestApi();
_baseUrl = Domain.GetCountryApiConstant;
_baseUrlSubmitRecord = Settings.Url + Domain.UserSignUpApiConstant;
LoadCountryData();
Device.BeginInvokeOnMainThread(() => {
Device.StartTimer(TimeSpan.FromSeconds(1), () =>
{
if (Settings.CountryCode > 0)
{
ImageCtryFlage.Source = Settings.CountryFlag;
}
return(true);
});
//if (Settings.CountryCode > 0)
//{
// ImageCtryFlage.Source = Settings.CountryFlag;
//}
});
}
public RegisterStepThreePage(UserRegistrationRequest objUserRegistrationRequest, RetailerList objRetailerList)
{
InitializeComponent();
NavigationPage.SetBackButtonTitle(this, "");
XFLblTAC.Text = $"T&C";
_objRetailerList = new RetailerList();
if (objRetailerList != null)
{
_objRetailerList = objRetailerList;
imgCompanyLogo.Source = objRetailerList.imagePath;
XFLBLCompanyRate.Text = $"{objRetailerList.rate:0.00}" + "c";
XFBTN_Duration.Text = objRetailerList.duration + " Months";
xflblnoAccounttext.Text = "Haven't started electric service at this address yet? Call " + objRetailerList.retailerName + "at " + objRetailerList.phoneNumber + " and set up an account for this address. Then enter the 20-digit number to complete your order.";
}
_objUserRegistrationRequest = new UserRegistrationRequest();
_objUserRegistrationRequest = objUserRegistrationRequest;
this.BindingContext = _objUserRegistrationRequest;
_objUserRegistrationResponse = new UserRegistrationResponse();
_apiService = new RestApi();
_baseUrl = Domain.Url + Domain.UserSignUpApiConstant;
_objHeaderModel = new HeaderModel();
}
public UserRegistrationResponse UserRegistration(UserRegistrationRequest request)
{
UserDAL userDAL = new UserDAL();
UserRegistrationResponse response = new UserRegistrationResponse();
User user = userDAL.GetUserByUsername(request.Username);
if (user != null)
{
response.StatusCode = StatusCodes.Status_User_Exists;
response.StatusMessage = "User already exists. Please login.";
}
else
{
user = new User();
user.Username = request.Username;
user.Password = request.Password;
user.Name = request.Name;
int insertResult = userDAL.Insert(user);
if (insertResult == 0)
{
response.StatusCode = StatusCodes.Status_Register_Failed;
response.StatusMessage = "Unable to register. Please try again";
}
}
return(response);
}
public async Task <IActionResult> RegisterUser(User newUser)
{
UserRegistrationResponse result = await _userService.RegisterUser(newUser);
if (result?.Success ?? false)
{
return(NoContent());
}
return(Conflict(result?.ErrorMessage));
}
public void TestUserRegistration()
{
UserRegistrationRequest request = new UserRegistrationRequest();
request.Username = "******";
request.Password = new UserDAL().GetStringSha256Hash("12345");
request.Name = "Test 300";
UserRegistrationResponse actual = bal.UserRegistration(request);
Assert.AreEqual(StatusCodes.Status_Success, actual.StatusCode);
}
public AddUser()
{
InitializeComponent();
NavigationPage.SetBackButtonTitle(this, "");
_objUserRegistrationResponse = new UserRegistrationResponse();
_objUserRegistrationRequest = new UserRegistrationRequest();
_objHeaderModel = new HeaderModel();
_apiService = new RestApi();
_baseUrl = Domain.Url + Domain.UserSignUpApiConstant;
this.BindingContext = _objUserRegistrationRequest;
}
public static UserRegistrationWebResponse AsWebResponse(this UserRegistrationResponse response)
{
var result = new UserRegistrationWebResponse
{
Errors = response.Errors,
Message = response.Message,
StatusCode = response.StatusCode,
IsSuccessful = response.IsSuccessful
};
return(result);
}
public ActionResult UserRegistration(string Username, string Password, string Name)
{
UserRegistrationRequest request = new UserRegistrationRequest();
request.Username = Username;
request.Password = new UserDAL().GetStringSha256Hash(Password);
request.Name = Name;
IUserBAL userBAL = new UserBAL();
UserRegistrationResponse response = userBAL.UserRegistration(request);
return(Json(response));
}
public void User_Registration(UserRegistrationRequest request, UserRegistrationResponse response)
{
"Given a user registraion request"
.x(() => request = GivenUserRequest());
"When i make a user registration request"
.x(async() => response = await MakeUserRegistrationRequest(request));
"Then ensure the response is not null"
.x(() => AssertResponseIsNotNull(response));
"Then ensure that the user is persisted"
.x(() => AssertNewUserIsPersisted(response));
"And userRegistered Event is published"
.x(() => AssertUserRegisteredEventWasPublished());
}
private async void XFBtnRegisterUser_Clicked(object sender, EventArgs e)
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
if (string.IsNullOrEmpty(_objUserRegistrationRequest.email) || string.IsNullOrEmpty(_objUserRegistrationRequest.password) || string.IsNullOrEmpty(_objUserRegistrationRequest.firstName) || string.IsNullOrEmpty(_objUserRegistrationRequest.lastName))
{
await DisplayAlert("", "Please provide Account details!", "(X)");
}
else
{
_objHeaderModel.TokenCode = Settings.TokenCode;
_objUserRegistrationResponse = await _apiService.UserRegistrationAsync(new Get_API_Url().CommonBaseApi(_baseUrl), false, _objHeaderModel, _objUserRegistrationRequest);
var Response = _objUserRegistrationResponse.response;
if (Response.statusCode == 200)
{
Device.BeginInvokeOnMainThread(() => {
DisplayAlert("Info!", Response.message, "(X)");
});
await App.NavigationPage.Navigation.PushAsync(new LoginPage());
}
else
{
Device.BeginInvokeOnMainThread(() => {
DisplayAlert("Error!", Response.message, "(X)");
});
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
finally
{
IsBusy = false;
}
// Navigation.PushAsync(new ElectricityAndGasListing());
}
/// <summary>
/// Use registration data and
/// save new user to db.
/// </summary>
/// <param name="registrationData"></param>
/// <returns></returns>
public async Task <UserRegistrationResponse> RegisterUser(RegistrationDto registrationData)
{
var user = _mapper.Map <ApplicationUser>(registrationData);
try
{
var creationResult = await _userManager.CreateAsync(user, registrationData.Password);
if (!creationResult.Succeeded)
{
return(UserRegistrationResponse.Unsuccessful(creationResult));
}
await _userManager.AddToRoleAsync(user, Roles.User);
}
catch (Exception ex)
{
_logsManager.SaveLog(registrationData, ex.Message);
}
var token = await _authManager.GenerateJwtToken(user);
return(UserRegistrationResponse.Successfull(token));
}
private async void BtnSignup_Clicked(object sender, EventArgs e)
{
try
{
if (!CrossConnectivity.Current.IsConnected)
{
DependencyService.Get <IToast>().Show("No Network Connection!!");
}
else
{
_objUserRegistrationRequest.CountryId = Settings.CountryCode;
if (string.IsNullOrEmpty(_objUserRegistrationRequest.FirstName) ||
string.IsNullOrEmpty(_objUserRegistrationRequest.LastName) ||
string.IsNullOrEmpty(_objUserRegistrationRequest.Email) ||
string.IsNullOrEmpty(_objUserRegistrationRequest.Password) ||
string.IsNullOrEmpty(_objUserRegistrationRequest.MobileNumber) ||
_objUserRegistrationRequest.CountryId < 0)
{
DependencyService.Get <IToast>().Show("All fields are Required!!");
}
else
{
if (!IsValid)
{
DependencyService.Get <IToast>().Show("Not a valid Email");
}
else
{
if (_objUserRegistrationRequest.Password.Length < 6 || _objUserRegistrationRequest.Password.Length > 20)
{
DependencyService.Get <IToast>().Show("password Should be in between 6 to 20 character long!");
}
else
{
if (_objUserRegistrationRequest.MobileNumber.Length < 10 || _objUserRegistrationRequest.MobileNumber.Length > 11)
{
DependencyService.Get <IToast>().Show("Mobile Number Should be 10 character long!");
}
else
{
await Navigation.PushPopupAsync(new LoadingPopPage());
_objUserRegistrationResponse = await _apiServices.UserRegistrationAsync(new Get_API_Url().CommonBaseApi(_baseUrlSubmitRecord), false, new HeaderModel(), _objUserRegistrationRequest);
var Response = _objUserRegistrationResponse.Response;
if (Response.StatusCode == 200)
{
DependencyService.Get <IToast>().Show(Response.Message);
await App.NavigationPage.Navigation.PushAsync(new LoginPage());
await Navigation.PopAllPopupAsync();
}
else
{
await Navigation.PopAllPopupAsync();
DependencyService.Get <IToast>().Show(Response.Message);
}
}
}
}
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
}
private static void Main(string[] args)
{
Task.Run(() =>
{
try
{
// initialize settings
Init();
Console.WriteLine($"Take it easy, the console will display important messages, actually, it's running!! :)");
ConnectionFactory factory = new ConnectionFactory();
factory.UserName = ApplicationSettings.RabbitMQUsername;
factory.Password = ApplicationSettings.RabbitMQPassword;
factory.HostName = ApplicationSettings.RabbitMQHostname;
factory.Port = ApplicationSettings.RabbitMQPort;
factory.RequestedHeartbeat = 60;
factory.DispatchConsumersAsync = true;
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(queue: ApplicationSettings.UserRegistrationQueueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
UserRegistrationResponse response = new UserRegistrationResponse
{
IsSucceded = true,
ResultId = (int)UserRegistrationResponseEnum.Success
};
// forced-to-disposal
WalletRegistrationInfo walletInfo = null;
NBitcoin.Wordlist nwordlist = null;
Nethereum.HdWallet.Wallet wallet = null;
Nethereum.Web3.Accounts.Account account = null;
string jsonDecrypted = string.Empty;
string jsonEncrypted = string.Empty;
User user = null;
UserActivationDataHelper userActivationDataHelper = null;
MailHelper mailHelper = null;
try
{
byte[] body = ea.Body;
var message = Encoding.UTF8.GetString(body);
var decrypted = string.Empty;
decrypted = NETCore.Encrypt.EncryptProvider.AESDecrypt(message, secret);
var obj_decrypted = JsonConvert.DeserializeObject <UserRegistrationMessage>(decrypted);
var aeskey_wallet = NETCore.Encrypt.EncryptProvider.CreateAesKey();
var key_wallet = aeskey_wallet.Key;
nwordlist = new NBitcoin.Wordlist(wordlist.ToArray(), ' ', "english");
wallet = new Nethereum.HdWallet.Wallet(nwordlist, NBitcoin.WordCount.Eighteen, key_wallet);
account = wallet.GetAccount(0);
walletInfo = new WalletRegistrationInfo();
walletInfo.address = account.Address;
walletInfo.privateKey = account.PrivateKey;
walletInfo.password = key_wallet;
walletInfo.mnemonic = string.Join(" ", wallet.Words);
jsonDecrypted = JsonConvert.SerializeObject(walletInfo);
var aeskey_data = NETCore.Encrypt.EncryptProvider.CreateAesKey();
var key_data = aeskey_data.Key;
jsonEncrypted = NETCore.Encrypt.EncryptProvider.AESEncrypt(jsonDecrypted, key_data);
string identicon = string.Empty;
try
{
Identicon.FromValue($"{account.Address}", size: 160).SaveAsPng($"{account.Address}.png");
byte[] binary = System.IO.File.ReadAllBytes($"{account.Address}.png");
identicon = Convert.ToBase64String(binary);
System.IO.File.Delete($"{account.Address}.png");
Console.WriteLine($">> Identicon deleted from local storage");
}
catch (Exception ex)
{
Console.WriteLine($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
Console.WriteLine($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
try
{
System.IO.File.Delete($"{account.Address}.png");
Console.WriteLine($">> Identicon deleted from local storage");
}
catch { }
}
userActivationDataHelper = new UserActivationDataHelper(mongoDBConnectionInfo);
// get user by email
user = userActivationDataHelper.GetUser(obj_decrypted.email);
if (user != null)
{
throw new BusinessException((int)UserRegistrationResponseEnum.FailedEmailAlreadyExists);
}
user = new User();
user.fullname = obj_decrypted.fullname;
user.email = obj_decrypted.email;
user.address = account.Address;
user.dataenc = jsonEncrypted;
user.datakey = key_data;
user.identicon = identicon;
// register user
await userActivationDataHelper.RegisterUserAsync(user);
mailHelper = new MailHelper();
// send email
await mailHelper.SendRegistrationEmailAsync(user.email, user.fullname);
Console.WriteLine($">> Email: {user.email} activated successfully");
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine($">> Acknowledgement completed, delivery tag: {ea.DeliveryTag}");
}
catch (Exception ex)
{
if (ex is BusinessException)
{
response.IsSucceded = false;
response.ResultId = ((BusinessException)ex).ResultId;
string message = EnumDescription.GetEnumDescription((UserRegistrationResponseEnum)response.ResultId);
Console.WriteLine($">> Message information: {message}");
}
else
{
Console.WriteLine($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
Console.WriteLine($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
}
}
finally
{
nwordlist = null;
wallet = null;
account = null;
walletInfo = null;
jsonDecrypted = null;
jsonEncrypted = null;
user = null;
userActivationDataHelper.Dispose();
mailHelper.Dispose();
}
};
String consumerTag = channel.BasicConsume(ApplicationSettings.UserRegistrationQueueName, false, consumer);
}
catch (Exception ex)
{
Console.WriteLine($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
Console.WriteLine($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
}
});
// handle Control+C or Control+Break
Console.CancelKeyPress += (o, e) =>
{
Console.WriteLine("Exit");
// allow the manin thread to continue and exit...
waitHandle.Set();
};
// wait
waitHandle.WaitOne();
}
/// <summary>
/// Create new Registration
/// </summary>
public object Post(UserRegistrationRequest request)
{
if (HostContext.GlobalRequestFilters == null ||
!HostContext.GlobalRequestFilters.Contains(ValidationFilters.RequestFilter)) //Already gets run
{
if (UserRegistrationRequestValidator != null)
{
UserRegistrationRequestValidator.ValidateAndThrow(request, ApplyTo.Post);
}
}
var userAuthRepo = AuthRepo.AsUserAuthRepository(GetResolver());
if (ValidateFn != null)
{
var validateResponse = ValidateFn(this, HttpMethods.Post, request);
if (validateResponse != null)
{
return(validateResponse);
}
}
if (string.IsNullOrEmpty(request.DisplayName))
{
request.DisplayName = request.Email;
}
UserRegistrationResponse response = null;
var session = this.GetSession();
var newUserAuth = ToUserAuth(request);
var existingUser = userAuthRepo.GetUserAuth(session, null);
var registerNewUser = existingUser == null;
var user = registerNewUser
? userAuthRepo.CreateUserAuth(newUserAuth, request.Password)
: userAuthRepo.UpdateUserAuth(existingUser, newUserAuth, request.Password);
if (request.AutoLogin.GetValueOrDefault())
{
using (var authService = base.ResolveService <AuthenticateService>())
{
var authResponse = authService.Post(
new Authenticate
{
provider = "credentials",
UserName = request.UserName ?? request.Email,
Password = request.Password,
Continue = request.Continue
});
if (authResponse is IHttpError)
{
throw (Exception)authResponse;
}
var typedResponse = authResponse as AuthenticateResponse;
if (typedResponse != null)
{
response = new UserRegistrationResponse
{
SessionId = typedResponse.SessionId,
DisplayName = typedResponse.DisplayName,
ReferrerUrl = typedResponse.ReferrerUrl,
UserId = user.Id.ToString(CultureInfo.InvariantCulture),
};
}
}
}
if (registerNewUser)
{
session = this.GetSession();
session.OnRegistered(this);
}
if (response == null)
{
response = new UserRegistrationResponse
{
UserId = user.Id.ToString(CultureInfo.InvariantCulture),
ReferrerUrl = request.Continue
};
}
var isHtml = Request.ResponseContentType.MatchesContentType(MimeTypes.Html);
if (isHtml)
{
if (string.IsNullOrEmpty(request.Continue))
{
return(response);
}
return(new HttpResult(response)
{
Location = request.Continue
});
}
return(response);
}
private async void XFBtnRegisterUser_Clicked(object sender, EventArgs e)
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
if (_objUserRegistrationRequest.isMedEdAccountat)
{
if (string.IsNullOrEmpty(_objUserRegistrationRequest.medEdAccountatthisAddress))
{
await DisplayAlert("", "Please provide Account Number!", "(X)");
}
else
{
_objHeaderModel.TokenCode = Settings.TokenCode;
_objUserRegistrationResponse = await _apiService.UserRegistrationAsync(new Get_API_Url().CommonBaseApi(_baseUrl), true, _objHeaderModel, _objUserRegistrationRequest);
var Response = _objUserRegistrationResponse.response;
if (Response.statusCode == 200)
{
Device.BeginInvokeOnMainThread(() => {
DisplayAlert("", Response.message, "(X)");
});
await App.NavigationPage.Navigation.PushAsync(new CongratulationPage());
}
else
{
Device.BeginInvokeOnMainThread(() => {
DisplayAlert("", Response.message, "(X)");
});
}
}
}
else
{
_objHeaderModel.TokenCode = Settings.TokenCode;
_objUserRegistrationResponse = await _apiService.UserRegistrationAsync(new Get_API_Url().CommonBaseApi(_baseUrl), true, _objHeaderModel, _objUserRegistrationRequest);
var Response = _objUserRegistrationResponse.response;
if (Response.statusCode == 200)
{
await DisplayAlert("", "Registeration Successful without MedEdAccount!", "(X)");
await App.NavigationPage.Navigation.PushAsync(new LoginPage());
}
else
{
Device.BeginInvokeOnMainThread(() => {
DisplayAlert("", Response.message, "(X)");
});
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
finally
{
IsBusy = false;
}
// Navigation.PushAsync(new ElectricityAndGasListing());
}
public UserResponse(UserRegistrationResponse userRegistrationResponse)
{
UserRegistrationResponse = userRegistrationResponse;
}
private void AssertResponseIsNotNull(UserRegistrationResponse response)
{
Assert.NotNull(response);
}
public async Task <IActionResult> Post()
{
// non-forced-to-disposal
UserRegistrationResponse response = new UserRegistrationResponse
{
IsSucceded = true,
ResultId = (int)UserRegistrationResponseEnum.Success
};
// forced-to-disposal
UserRegistrationRequest userRegistrationRequest = null;
MongoDBConnectionInfo mongoDBConnectionInfo = null;
KeyVaultConnectionInfo keyVaultConnectionInfo = null;
User user = null;
try
{
userRegistrationRequest = new UserRegistrationRequest();
userRegistrationRequest.Email = HttpContext.User.FindFirst("preferred_username").Value;
userRegistrationRequest.Fullname = ((HttpContext.User.FindFirst("name") != null) ? HttpContext.User.FindFirst("name").Value : string.Empty);
if (string.IsNullOrEmpty(userRegistrationRequest.Fullname))
{
throw new BusinessException((int)UserRegistrationResponseEnum.FailedEmptyFullname);
}
mongoDBConnectionInfo = new MongoDBConnectionInfo()
{
ConnectionString = ApplicationSettings.ConnectionString,
DatabaseId = ApplicationSettings.DatabaseId,
UserCollection = ApplicationSettings.UserCollection
};
using (UserRegistrationDataHelper userRegistrationDataHelper = new UserRegistrationDataHelper(mongoDBConnectionInfo))
{
user = userRegistrationDataHelper.GetUser(userRegistrationRequest.Email);
}
if (user == null)
{
keyVaultConnectionInfo = new KeyVaultConnectionInfo()
{
CertificateName = ApplicationSettings.KeyVaultCertificateName,
ClientId = ApplicationSettings.KeyVaultClientId,
ClientSecret = ApplicationSettings.KeyVaultClientSecret,
KeyVaultIdentifier = ApplicationSettings.KeyVaultIdentifier
};
using (MessageQueueHelper messageQueueHelper = new MessageQueueHelper())
{
UserRegistrationMessage userRegistrationMessage = new UserRegistrationMessage()
{
fullname = userRegistrationRequest.Fullname,
email = userRegistrationRequest.Email
};
await messageQueueHelper.QueueMessageAsync(userRegistrationMessage, ApplicationSettings.UserRegistrationQueueName, keyVaultConnectionInfo);
}
}
else
{
response.ResultId = (int)UserRegistrationResponseEnum.SuccessAlreadyExists;
}
}
catch (Exception ex)
{
response.IsSucceded = false;
if (ex is BusinessException)
{
response.ResultId = ((BusinessException)ex).ResultId;
}
else
{
response.ResultId = (int)UserRegistrationResponseEnum.Failed;
this.logger.LogError($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
this.logger.LogError($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
}
}
finally
{
userRegistrationRequest = null;
mongoDBConnectionInfo = null;
keyVaultConnectionInfo = null;
user = null;
GC.Collect();
}
string message = EnumDescription.GetEnumDescription((UserRegistrationResponseEnum)response.ResultId);
this.logger.LogInformation($">> Message information: {message}");
return((response.IsSucceded) ? (ActionResult) new OkObjectResult(new { message = message }) : (ActionResult) new BadRequestObjectResult(new { message = message }));
}
