public void IPAddressDAO_Update_SuccessfulUpdate(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange UnitTestIPAddressDAO ipDAO = new UnitTestIPAddressDAO(); // Create an IP. IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); ipDAO.Create(ipRecord); // Prepare a new data to update. IPAddressRecord updatedRecord = new IPAddressRecord(ip, 1, 1, 1); // Act // Update the data of the IP. ipDAO.Update(updatedRecord); // Read the IP. IPAddressObject ipObject = (IPAddressObject)ipDAO.ReadById(ip); // Check if the IP was updated correctly and set the result to true. bool result = DataEquals(ipRecord, ipObject); // Assert // The result should be true. Assert.IsTrue(result); }
public async Task IPAddressDAO_ReadByIdAsync_SuccessfulRead(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange // Create an IP. IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); await ipDAO.CreateAsync(ipRecord).ConfigureAwait(false); // Act // Read the IP. IPAddressObject ipObject = (IPAddressObject)await ipDAO.ReadByIdAsync(ip).ConfigureAwait(false); // Check if the read IP is correct and set the result accordingly. bool result = DataEquals(ipRecord, ipObject); // Assert // The result should be true. Assert.IsTrue(result); // Clean up // Delete the IP. await ipDAO.DeleteByIdsAsync(new List <string>() { ip }).ConfigureAwait(false); }
public void IPAddressDAO_ReadById_UnsuccessfulRead(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange UnitTestIPAddressDAO ipDAO = new UnitTestIPAddressDAO(); // Create an IP. IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); ipDAO.Create(ipRecord); bool result = false; // Act try { // Read a non-existing IP. IPAddressObject ipObject = (IPAddressObject)ipDAO.ReadById(NonExistingIP); } catch (ArgumentException) { // Catch the exception and set the result to true. result = true; } // Assert // The result should be true. Assert.IsTrue(result); }
public async Task IPAddressDAO_CreateAsync_SuccessfulCreation(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); // Act // Create IP Address. await ipDAO.CreateAsync(ipRecord); IPAddressObject ipObject = (IPAddressObject)await ipDAO.ReadByIdAsync(ip).ConfigureAwait(false); // Check if the data created is correct. bool correctDataResult = DataEquals(ipRecord, ipObject); // Assert // The data should be correct. Assert.IsTrue(correctDataResult); // Clean up // Delete the IP. await ipDAO.DeleteByIdsAsync(new List <string>() { ip }).ConfigureAwait(false); }
/// <summary> /// Deletes the entry in the data store pointed to by the <paramref name="ipAddress"/>. /// </summary> /// <param name="ipAddress">The ip address to delete from the data store.</param> /// <returns>Task (bool) whether the function completed without exception</returns> public async Task <bool> DeleteIPAsync(string ipAddress) { // Check for ip existence. if (!await CheckIPExistenceAsync(ipAddress).ConfigureAwait(false)) { throw new ArgumentException(Constants.DeleteIPDNE); } // If the column is masked, mask the ip. string id = ipAddress; if (Constants.AnonymousUserDAOIsColumnMasked[Constants.AnonymousUserDAOIPColumn]) { id = _maskingService.MaskString(ipAddress); } // Get the masked object from the ipDAO and decrement its mapping before deleteing. IPAddressObject maskedObj = await _anonymousUserDAO.ReadByIdAsync(id).ConfigureAwait(false) as IPAddressObject; await _maskingService.DecrementMappingForDeleteAsync(maskedObj).ConfigureAwait(false); await _anonymousUserDAO.DeleteByIdsAsync(new List <string>() { id }).ConfigureAwait(false); return(true); }
public async Task IPAddressDAO_UpdateAsync_SuccessfulUpdate(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange // Create an IP. IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); await ipDAO.CreateAsync(ipRecord).ConfigureAwait(false); // Prepare a new data to update. IPAddressRecord updatedRecord = new IPAddressRecord(ip, 1, 1, 1); // Act // Update the data of the IP. await ipDAO.UpdateAsync(updatedRecord); // Read the IP. IPAddressObject ipObject = (IPAddressObject)await ipDAO.ReadByIdAsync(ip); // Check if the IP was updated correctly and set the result to true. bool result = DataEquals(updatedRecord, ipObject); // Assert // The result should be true. Assert.IsTrue(result); // Clean up // Delete the IP. await ipDAO.DeleteByIdsAsync(new List <string>() { ip }).ConfigureAwait(false); }
public async Task IPAddressDAO_ReadByIdAsync_UnsuccessfulRead(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange // Create an IP. IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); await ipDAO.CreateAsync(ipRecord).ConfigureAwait(false); bool result = false; // Act try { // Read a non-existing IP. IPAddressObject ipObject = (IPAddressObject)await ipDAO.ReadByIdAsync(NonExistingIP).ConfigureAwait(false); } catch (ArgumentException) { // Catch the exception and set the result to true. result = true; } // Assert // The result should be true. Assert.IsTrue(result); // Clean up await ipDAO.DeleteByIdsAsync(new List <string>() { ip }).ConfigureAwait(false); }
/// <summary> /// Updates an entry in the IP Address data store using the <paramref name="ipRecord"/>. /// </summary> /// <param name="ipRecord">The unmasked record conveying the data to update.</param> /// <returns>Task (bool) whether the function completed without exception</returns> public async Task <bool> UpdateIPAsync(IPAddressRecord ipRecord) { // Record must be unmasked. if (ipRecord.IsMasked()) { throw new ArgumentException(Constants.UpdateIPRecordMasked); } // If the column is masked, mask the ip. string id = ipRecord.GetData()[Constants.AnonymousUserDAOIPColumn] as string; if (Constants.AnonymousUserDAOIsColumnMasked[Constants.AnonymousUserDAOIPColumn]) { id = _maskingService.MaskString(id); } IPAddressRecord maskedRecord = await _maskingService.MaskAsync(ipRecord, false).ConfigureAwait(false) as IPAddressRecord; // Get the masked object from the ipDAO and decrement its mapping before updating. IPAddressObject maskedObj = await _anonymousUserDAO.ReadByIdAsync(id).ConfigureAwait(false) as IPAddressObject; await _maskingService.DecrementMappingForUpdateAsync(maskedRecord, maskedObj).ConfigureAwait(false); return(await _anonymousUserDAO.UpdateAsync(maskedRecord).ConfigureAwait(false)); }
private bool DataEquals(IPAddressRecord ipRecord, IPAddressObject ipObject) { IDictionary <string, object> recordData = ipRecord.GetData(); Console.WriteLine(recordData[Constants.AnonymousUserDAOIPColumn]); Console.WriteLine(recordData[Constants.AnonymousUserDAOtimestampLockedColumn]); Console.WriteLine(recordData[Constants.AnonymousUserDAOregistrationFailuresColumn]); Console.WriteLine(recordData[Constants.AnonymousUserDAOlastRegFailTimestampColumn]); Console.WriteLine(ipObject.IP); Console.WriteLine(ipObject.TimestampLocked); Console.WriteLine(ipObject.RegistrationFailures); Console.WriteLine(ipObject.LastRegFailTimestamp); if (((string)recordData[Constants.AnonymousUserDAOIPColumn]).Equals(ipObject.IP) && ((long)recordData[Constants.AnonymousUserDAOtimestampLockedColumn]).Equals(ipObject.TimestampLocked) && ((int)recordData[Constants.AnonymousUserDAOregistrationFailuresColumn]).Equals(ipObject.RegistrationFailures) && ((long)recordData[Constants.AnonymousUserDAOlastRegFailTimestampColumn]).Equals(ipObject.LastRegFailTimestamp)) { return(true); } else { return(false); } }
/// <summary> /// Asynchronously check if the <paramref name="ipAddress"/> is locked in the data store. /// </summary> /// <param name="ipAddress">The ip address to check (string)</param> /// <returns>Task (bool) whether the ip is locked</returns> public async Task <bool> CheckIfIPLockedAsync(string ipAddress) { // Asynchronously gets the info of the ipAddress. IPAddressObject ip = await GetIPAddressInfoAsync(ipAddress).ConfigureAwait(false); // The ip is locked if the timetamp locked has a value. return(ip.TimestampLocked != Constants.NoValueLong); }
/// <summary> /// Check if the <paramref name="ipAddress"/> is locked in the data store. /// </summary> /// <param name="ipAddress">The ip address to check (string)</param> /// <returns>Task (bool) whether the ip is locked</returns> public static bool CheckIfIPLocked(string ipAddress) { // Gets the info of the ipAddress. IPAddressObject ip = GetIPAddressInfo(ipAddress); // The ip is locked if the timetamp locked has a value. return(ip.TimestampLocked != Constants.NoValueLong); }
/// <summary> /// Asynchronously gets the <paramref name="ipAddress"/> info and return as an object. /// </summary> /// <param name="ipAddress">The ip address of the record in the data store (string)</param> /// <returns>Task (IPAddressObject) the object representing the ip info</returns> public async Task <IPAddressObject> GetIPAddressInfoAsync(string ipAddress) { string id = ipAddress; if (Constants.AnonymousUserDAOIsColumnMasked[Constants.AnonymousUserDAOIPColumn]) { id = _maskingService.MaskString(ipAddress); } // Cast the return result of asynchronously reading by the ip address into the IP object. IPAddressObject ip = await _anonymousUserDAO.ReadByIdAsync(id).ConfigureAwait(false) as IPAddressObject; return(await _maskingService.UnMaskAsync(ip).ConfigureAwait(false) as IPAddressObject); }
/// <summary> /// Increment the registration failures of the anonymous user defined by the <paramref name="ipAddress"/>. /// </summary> /// <param name="ipAddress">The ip address to increment the registration failures of (string)</param> /// <param name="maxTimeBeforeFailureReset">The time before their failures reset (TimeSpan)</param> /// <param name="maxNumberOfTries">The max number of registration tries before they get locked (int)</param> /// <returns>Task (bool) whether the funciton executed without exception</returns> public async Task <bool> IncrementRegistrationFailuresAsync(string ipAddress, TimeSpan maxTimeBeforeFailureReset, int maxNumberOfTries) { IPAddressObject ip = await GetIPAddressInfoAsync(ipAddress).ConfigureAwait(false); IPAddressRecord record; // Need to check if the maxtime + lastTime is less than now. // if it is then reset the failure long lastRegFailTimestamp = ip.LastRegFailTimestamp; long maxSeconds = TimeUtilityService.TimespanToSeconds(maxTimeBeforeFailureReset); long currentUnix = TimeUtilityService.CurrentUnixTime(); bool reset = false; // If the time has passed their max time before reset, reset their failures. Don't reset // if they have no last registration fail timestamp. if (lastRegFailTimestamp + maxSeconds < currentUnix && lastRegFailTimestamp != Constants.NoValueLong) { reset = true; record = new IPAddressRecord(ipAddress, registrationFailures: 0); await UpdateIPAsync(record).ConfigureAwait(false); } // Increment the user's login Failure count. int updatedRegistrationFailures = reset ? 1 : ip.RegistrationFailures + 1; // Lock the ip if they have reached the max number of tries. // Update the last reg fail time. if (updatedRegistrationFailures >= maxNumberOfTries) { record = new IPAddressRecord(ipAddress, timestampLocked: currentUnix, registrationFailures: updatedRegistrationFailures, lastRegFailTimestamp: currentUnix); // Asynchronously notify the system admin if an ip address was locked during registration. await SystemUtilityService.NotifySystemAdminAsync($"{ipAddress} was locked at {currentUnix}", Constants.SystemAdminEmailAddress).ConfigureAwait(false); } else { record = new IPAddressRecord(ipAddress, registrationFailures: updatedRegistrationFailures, lastRegFailTimestamp: currentUnix); } return(await UpdateIPAsync(record).ConfigureAwait(false)); }
/// <summary> /// Read the information in the data store pointed to by the <paramref name="id"/>. /// </summary> /// <param name="id">The id of the row to read (string)</param> /// <returns>Task (IDataObject) the information represented as an object</returns> public async Task <IDataObject> ReadByIdAsync(string id) { // Check if the id exists in the table, and throw an argument exception if it doesn't. if (!await CheckIPExistenceAsync(id).ConfigureAwait(false)) { throw new ArgumentException(Constants.IPReadDNE); } // Object to return -- IPAddressObject. IPAddressObject result; // Get the connection inside of a using statement to properly dispose/close. using (MySqlConnection connection = new MySqlConnection(SQLConnection)) { // Open the connection. connection.Open(); // Construct the sql string to get the record where the id column equals the id parameter. string sqlString = $"SELECT * FROM {Constants.AnonymousUserDAOTableName} WHERE {Constants.AnonymousUserDAOIPColumn} = @ID;"; // Get the command and data table objects inside using statements to properly dispose/close. using (MySqlCommand command = new MySqlCommand(sqlString, connection)) using (DataTable dataTable = new DataTable()) { // Add the value to the id parameter, execute the reader asynchronously, load the reader into // the data table, and get the first row (the result). command.Parameters.AddWithValue("@ID", id); var reader = await command.ExecuteReaderAsync().ConfigureAwait(false); dataTable.Load(reader); DataRow row = dataTable.Rows[0]; // Construct the IPAddressObject by casting the values of the columns to their proper data types. result = new IPAddressObject((string)row[Constants.AnonymousUserDAOIPColumn], (long)row[Constants.AnonymousUserDAOtimestampLockedColumn], (int)row[Constants.AnonymousUserDAOregistrationFailuresColumn], (long)row[Constants.AnonymousUserDAOlastRegFailTimestampColumn]); } } return(result); }
public void IPAddressDAO_Create_SuccessfulCreation(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange UnitTestIPAddressDAO ipDAO = new UnitTestIPAddressDAO(); IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); // Act // Create IP Address. ipDAO.Create(ipRecord); IPAddressObject ipObject = (IPAddressObject)ipDAO.ReadById(ip); // Check if the data created is correct. bool correctDataResult = DataEquals(ipRecord, ipObject); // Assert // The data should be correct. Assert.IsTrue(correctDataResult); }
public async Task MaskingService_UnMaskAsync_WorksWithDifferentObjects(bool isTemp, string username, string name, string email, string phoneNumber, string password, string userType, string salt, string ipAddress) { await _userManagementService.CreateIPAsync(ipAddress).ConfigureAwait(false); UserRecord userRecord = new UserRecord(username, name, email, phoneNumber, password, Constants.EnabledStatus, userType, salt, Constants.NoValueLong, Constants.NoValueString, Constants.NoValueLong, Constants.NoValueInt, Constants.NoValueLong, Constants.NoValueInt, Constants.NoValueInt); await _userManagementService.CreateUserAsync(isTemp, userRecord).ConfigureAwait(false); string id = username; if (Constants.UserDAOIsColumnMasked[Constants.UserDAOusernameColumn]) { id = _maskingService.MaskString(username); } UserObject rawUser = (UserObject)await _userDAO.ReadByIdAsync(id).ConfigureAwait(false); id = ipAddress; if (Constants.AnonymousUserDAOIsColumnMasked[Constants.AnonymousUserDAOIPColumn]) { id = _maskingService.MaskString(ipAddress); } // Cast the return result of asynchronously reading by the ip address into the IP object. IPAddressObject rawIP = (IPAddressObject)await _ipDAO.ReadByIdAsync(id).ConfigureAwait(false); IPAddressObject ip = (IPAddressObject)await _maskingService.UnMaskAsync(rawIP).ConfigureAwait(false); UserObject user = (UserObject)await _maskingService.UnMaskAsync(rawUser).ConfigureAwait(false); Assert.IsTrue(ip.IsUnMasked()); Assert.IsTrue(user.IsUnMasked()); await _userManagementService.DeleteIPAsync(ipAddress).ConfigureAwait(false); await _userManagementService.DeleteUserAsync(username).ConfigureAwait(false); }
public void IPAddressDAO_ReadById_SuccessfulRead(string ip, long timestampLocked, int registrationFailures, long lastRegFailTimestamp) { // Arrange UnitTestIPAddressDAO ipDAO = new UnitTestIPAddressDAO(); // Create an IP. IPAddressRecord ipRecord = new IPAddressRecord(ip, timestampLocked, registrationFailures, lastRegFailTimestamp); ipDAO.Create(ipRecord); // Act // Read the IP. IPAddressObject ipObject = (IPAddressObject)ipDAO.ReadById(ip); // Check if the read IP is correct and set the result accordingly. bool result = DataEquals(ipRecord, ipObject); // Assert // The result should be true. Assert.IsTrue(result); }
// Time out after X seconds will be conducted in Controllers with Task.Wait // Re-trying after exceptions occur will be conducted in Controllers, who will check if an exception occurred and how // many exceptions have currently occured after a manager has returned. // Encrypted password, encrypted AES key, and AES IV are all in hex string format. public async Task <Result <bool> > RegisterAsync(string firstName, string lastName, string email, string username, string phoneNumber, string ipAddress, string hashedPassword, string salt, string proxyPassword, int currentNumExceptions) { try { bool registrationSuccess = false; // If the ip address is not in our system. Insert into datastore if (!await _userManagementService.CheckIPExistenceAsync(ipAddress).ConfigureAwait(false)) { await _userManagementService.CreateIPAsync(ipAddress).ConfigureAwait(false); } // Grab the user ip object. IPAddressObject ip = await _userManagementService.GetIPAddressInfoAsync(ipAddress).ConfigureAwait(false); // Set fields for repeated fails to lock them out. long timeLocked = ip.TimestampLocked; long maxSeconds = TimeUtilityService.TimespanToSeconds(Constants.MaxIPLockTime); long currentUnix = TimeUtilityService.CurrentUnixTime(); // If the time has passed their max time before unlock, unlock them if (timeLocked + maxSeconds < currentUnix && timeLocked != Constants.NoValueLong) { await _userManagementService.UnlockIPAsync(ipAddress).ConfigureAwait(false); } if (await _userManagementService.CheckIfIPLockedAsync(ipAddress).ConfigureAwait(false)) { _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.IPLockedLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.IPLockedUserMessage, registrationSuccess, false)); } // Check the length of their first name. if (!StringUtilityService.CheckLength(firstName, Constants.MaximumFirstNameCharacters, Constants.MinimumFirstNameCharacters)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidFirstNameLengthLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidFirstNameLengthUserMessage, registrationSuccess, false)); } // Check the character requirements of their first name. if (!StringUtilityService.CheckCharacters(firstName, Constants.CharSetsData[Constants.FirstNameCharacterType])) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidFirstNameCharactersLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidFirstNameCharactersUserMessage, registrationSuccess, false)); } // Check the length of their last name. if (!StringUtilityService.CheckLength(lastName, Constants.MaximumLastNameCharacters, Constants.MinimumLastNameCharacters)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidLastNameLengthLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidLastNameLengthUserMessage, registrationSuccess, false)); } // Check the character requirements of their last name. if (!StringUtilityService.CheckCharacters(lastName, Constants.CharSetsData[Constants.LastNameCharacterType])) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidLastNameCharactersLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidLastNameCharactersUserMessage, registrationSuccess, false)); } // Check the length of their email. if (!StringUtilityService.CheckLength(email, Constants.MaximumEmailCharacters, Constants.MinimumEmailCharacters)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidEmailLengthLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidEmailLengthUserMessage, registrationSuccess, false)); } // Check the character requirements of their email. if (!StringUtilityService.CheckCharacters(email, Constants.CharSetsData[Constants.EmailCharacterType])) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidEmailCharactersLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidEmailCharactersUserMessage, registrationSuccess, false)); } // Check the format of their email. if (!StringUtilityService.CheckEmailFormatValidity(email)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidEmailFormatMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidEmailFormatMessage, registrationSuccess, false)); } // Email must be unique after canonicalization. string canonicalizedEmail = StringUtilityService.CanonicalizeEmail(email); if (await _userManagementService.CheckEmailExistenceAsync(canonicalizedEmail).ConfigureAwait(false)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.EmailExistsLogMessage).ConfigureAwait(false); Console.WriteLine("Email"); return(SystemUtilityService.CreateResult(Constants.UniqueIdExistsRegistrationUserMessage, registrationSuccess, false)); } // Check the length of their username. if (!StringUtilityService.CheckLength(username, Constants.MaximumUsernameCharacters, Constants.MinimumUsernameCharacters)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidUsernameLengthLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidUsernameLengthUserMessage, registrationSuccess, false)); } // Check the character requirements of their username. if (!StringUtilityService.CheckCharacters(email, Constants.CharSetsData[Constants.UsernameCharacterType])) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidUsernameCharactersLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidUsernameCharactersUserMessage, registrationSuccess, false)); } // Check username uniqueness. if (await _userManagementService.CheckUserExistenceAsync(username).ConfigureAwait(false)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.UsernameExistsLogMessage).ConfigureAwait(false); Console.WriteLine("username"); return(SystemUtilityService.CreateResult(Constants.UniqueIdExistsRegistrationUserMessage, registrationSuccess, false)); } // Check the length of their phone number. if (!StringUtilityService.CheckLength(phoneNumber, Constants.PhoneNumberCharacterLength)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidPhoneNumberLengthLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidPhoneNumberLengthUserMessage, registrationSuccess, false)); } // Check the character requirements of their phone number. if (!StringUtilityService.CheckCharacters(phoneNumber, Constants.CharSetsData[Constants.PhoneNumberCharacterType])) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidPhoneNumberCharactersLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidPhoneNumberCharactersUserMessage, registrationSuccess, false)); } // Check phone number uniqueness. if (await _userManagementService.CheckPhoneNumberExistenceAsync(phoneNumber).ConfigureAwait(false)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.PhoneNumberExistsLogMessage).ConfigureAwait(false); Console.WriteLine("phone"); return(SystemUtilityService.CreateResult(Constants.UniqueIdExistsRegistrationUserMessage, registrationSuccess, false)); } // Check the length of their password. if (!StringUtilityService.CheckLength(proxyPassword, Constants.MaximumPasswordCharacters, Constants.MinimumPasswordCharacters)) { await _userManagementService.IncrementRegistrationFailuresAsync(ipAddress, Constants.RegistrationTriesResetTime, Constants.MaxRegistrationAttempts).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, Constants.InvalidPasswordLengthLogMessage).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.InvalidPasswordLengthUserMessage, registrationSuccess, false)); } // Successful registration! registrationSuccess = true; // Create user record object to represent a user. // Email code, email code timestamp, login failures, last login failure timestamp, email code failures, and phone code failures initialized to have no value. UserRecord user = new UserRecord(username, firstName + " " + lastName, canonicalizedEmail, phoneNumber, hashedPassword, Constants.EnabledStatus, Constants.CustomerUserType, salt, Constants.NoValueLong, Constants.NoValueString, Constants.NoValueLong, Constants.NoValueInt, Constants.NoValueLong, Constants.NoValueInt, Constants.NoValueInt); // Create that user. await _userManagementService.CreateUserAsync(true, user).ConfigureAwait(false); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress).ConfigureAwait(false); return(SystemUtilityService.CreateResult(Constants.RegistrationSuccessUserMessage, registrationSuccess, false)); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); _ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString), Constants.RegistrationOperation, Constants.AnonymousUserIdentifier, ipAddress, e.Message).ConfigureAwait(false); if (currentNumExceptions + 1 >= Constants.MaximumOperationRetries) { await SystemUtilityService.NotifySystemAdminAsync($"{Constants.RegistrationOperation} failed a maximum number of times for {ipAddress}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false); } return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, false, true)); } }