public async Task <Result <bool> > DeleteUploadAsync(string username, int id, string ipAddress, int failureCount)
{
var result = false;
// Escape condition for recursive call if exception is thrown.
if (failureCount >= Constants.OperationRetry)
{
return(SystemUtilityService.CreateResult(Constants.UploadDeletionFailedMessage, result, true));
}
try
{
result = await _uploadService.DeleteUploadsAsync(new List <int>() { id }).ConfigureAwait(false);
}
catch (Exception ex)
{
// Log exception.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.DeleteUploadOperation, username, ipAddress, ex.ToString()).ConfigureAwait(false);
// Recursively retry the operation until the maximum amount of retries is reached.
await ContinueUploadProgressAsync(username, id, ipAddress, ++failureCount).ConfigureAwait(false);
}
// Log the fact that the operation was successful.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.DeleteUploadOperation, username, ipAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.UploadDeletionSuccessMessage, result, false));
}
public Result <bool> ValidateToken(string token, string username)
{
try
{
if (_sessionService.TokenIsExpired(token))
{
return(SystemUtilityService.CreateResult(Constants.ResetLinkExpired, false, false));
}
var tokenUsername = _authorizationService.DecryptJWT(token)[Constants.IdKey];
if (username != tokenUsername)
{
return(SystemUtilityService.CreateResult(Constants.UsernameNotMatchResetLink, false, false));
}
return(SystemUtilityService.CreateResult(null, true, false));
}
catch (Exception e)
{
Console.WriteLine("ValidateToken:" + e.Message);
Console.WriteLine("ValidateToken:" + e.StackTrace);
return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, false, true));
}
}
public async Task <Result <bool> > SendPhoneCodeAsync(string username, string phoneNumber, string ipAddress,
int currentNumExceptions)
{
try
{
await _verificationService.SendCallVerificationAsync(username, phoneNumber).ConfigureAwait(false);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.SendPhoneCodeOperation, username, ipAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.SendPhoneCodeSuccessUserMessage, true, false));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.SendPhoneCodeOperation, username, ipAddress, e.Message).ConfigureAwait(false);
if (currentNumExceptions + 1 >= Constants.MaximumOperationRetries)
{
await SystemUtilityService.NotifySystemAdminAsync($"{Constants.SendPhoneCodeOperation} failed a maximum number of times for {username}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, false, true));
}
}
public async Task <Result <UploadObject> > ContinueUploadProgressAsync(string username, int id, string ipAddress, int failureCount)
{
var result = new UploadObject(Constants.NoValueDatetime, Constants.NoValueString, Constants.NoValueInt, Constants.NoValueString,
Constants.NoValueInt, Constants.NoValueString, Constants.NoValueDouble, Constants.NoValueString,
Constants.NoValueString, Constants.NoValueInt, Constants.NoValueInt, Constants.NoValueBool,
Constants.NoValueString);
// Escape condition for recursive call if exception is thrown.
if (failureCount >= Constants.OperationRetry)
{
return(SystemUtilityService.CreateResult(Constants.UploadRetrievalFailedMessage, result, true));
}
try
{
result = await _uploadService.ContinueUploadProgressAsync(id).ConfigureAwait(false);
}
catch (Exception ex)
{
// Log exception.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.ContinueDraftOperation, username, ipAddress, ex.ToString()).ConfigureAwait(false);
// Recursively retry the operation until the maximum amount of retries is reached.
await ContinueUploadProgressAsync(username, id, ipAddress, ++failureCount).ConfigureAwait(false);
}
// Log the fact that the operation was successful.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.ContinueDraftOperation, username, ipAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.UploadRetrievalSuccessMessage, result, false));
}
public async Task <Result <AnalysisResult> > AnalyzeImageAsync(Image image, string username, string ipAddress, int failureCount)
{
var result = new AnalysisResult(new List <string>(), Constants.NoValueString, Constants.NoValueString);
// Escape condition for recursive call if exception is thrown.
if (failureCount >= Constants.OperationRetry)
{
return(SystemUtilityService.CreateResult(Constants.AnalyzationFailedMessage, result, true));
}
try
{
result = await _googleImageAnalysisService.AnalyzeAsync(image, Constants.ExogredientCategories).ConfigureAwait(false);
}
catch (Exception ex)
{
// Log exception.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.AnalyzeImageOperation, username, ipAddress, ex.ToString()).ConfigureAwait(false);
// Recursively retry the operation until the maximum amount of retries is reached.
await AnalyzeImageAsync(image, username, ipAddress, ++failureCount).ConfigureAwait(false);
}
// Log the fact that the operation was successful.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.AnalyzeImageOperation, username, ipAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.AnalyzationSuccessMessage, result, false));
}
public async Task <Result <bool> > UpdatePasswordAsync(string username, string ipAddress,
string hashedPassword, string proxyPassword,
string salt, int currentNumExceptions)
{
try
{
bool updateSuccess = false;
// Check the length of their password.
if (!StringUtilityService.CheckLength(proxyPassword, Constants.MaximumPasswordCharacters,
Constants.MinimumPasswordCharacters))
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.UpdatePasswordOperation, username, ipAddress,
Constants.InvalidPasswordLengthLogMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.InvalidPasswordLengthUserMessage,
updateSuccess, false));
}
updateSuccess = true;
await _userManagementService.ChangePasswordAsync(username, hashedPassword, salt).ConfigureAwait(false);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.UpdatePasswordOperation, username, ipAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.UpdatePasswordSuccessUserMessage, updateSuccess, false));
}
catch (Exception e)
{
Console.WriteLine("UpdatePassword:"******"UpdatePassword:"******"{Constants.UpdatePasswordOperation} failed a maximum number of times for {username}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, false, true));
}
}
public void SystemUtilityService_CreateResult_CreateAccurateResult(string message, string data, bool exceptionOccured)
{
// Act
Result <string> resultObject = SystemUtilityService.CreateResult <string>(message, data, exceptionOccured);
// Assert: Check that the result we created matches the inputs.
bool result;
if (resultObject.Message == message && resultObject.Data == data &&
resultObject.ExceptionOccurred == exceptionOccured)
{
result = true;
}
else
{
result = false;
}
Assert.IsTrue(result);
}
public async Task <Result <bool> > VerifyEmailCodeAsync(string username, string inputCode, string ipAddress,
int currentNumExceptions)
{
try
{
bool emailVerificationSuccess = false;
UserObject user = await _userManagementService.GetUserInfoAsync(username).ConfigureAwait(false);
if (user.EmailCodeFailures >= Constants.MaxEmailCodeAttempts)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyEmailOperation, username, ipAddress,
Constants.MaxEmailTriesReachedLogMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.MaxEmailTriesReachedUserMessage, emailVerificationSuccess, false));
}
long maxValidTimeSeconds = TimeUtilityService.TimespanToSeconds(Constants.EmailCodeMaxValidTime);
long currentUnix = TimeUtilityService.CurrentUnixTime();
if (user.EmailCodeTimestamp + maxValidTimeSeconds < currentUnix)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyEmailOperation, username, ipAddress,
Constants.EmailCodeExpiredLogMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.EmailCodeExpiredUserMessage, emailVerificationSuccess, false));
}
if (user.EmailCode.Equals(inputCode))
{
emailVerificationSuccess = true;
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyEmailOperation, username, ipAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.VerifyEmailSuccessUserMessage, emailVerificationSuccess, false));
}
else
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyEmailOperation, username, ipAddress,
Constants.WrongEmailCodeMessage).ConfigureAwait(false);
await _userManagementService.IncrementEmailCodeFailuresAsync(username).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.WrongEmailCodeMessage, emailVerificationSuccess, false));
}
}
catch (Exception e)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyEmailOperation, username, ipAddress, e.Message).ConfigureAwait(false);
if (currentNumExceptions + 1 >= Constants.MaximumOperationRetries)
{
await SystemUtilityService.NotifySystemAdminAsync($"{Constants.VerifyEmailOperation} failed a maximum number of times for {username}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, false, true));
}
}
// 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));
}
}
// Encrypted password, encrypted AES key, and aesIV are all in hex string format.
public async Task <Result <AuthenticationResult> > LogInAsync(string username, string ipAddress,
string password, int currentNumExceptions)
{
bool authenticationSuccessful = false;
bool userExist = false;
try
{
// If the username doesn't exist.
if (!await _userManagementService.CheckUserExistenceAsync(username).ConfigureAwait(false))
{
// Log the action.
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.LogInOperation, Constants.AnonymousUserIdentifier, ipAddress,
Constants.UsernameDNELogMessage).ConfigureAwait(false);
// Return the result of the login failure.
AuthenticationResult authenResult = new AuthenticationResult(authenticationSuccessful, userExist);
return(SystemUtilityService.CreateResult(Constants.InvalidLogInUserMessage, authenResult, false));
}
userExist = true;
// Get the information of the usernmae.
UserObject user = await _userManagementService.GetUserInfoAsync(username).ConfigureAwait(false);
// If the username is disabled.
if (user.Disabled == 1)
{
// Log the action.
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.LogInOperation, Constants.AnonymousUserIdentifier, ipAddress,
Constants.UserDisableLogMessage).ConfigureAwait(false);
// Return the result of the disabled username's login try.
AuthenticationResult authenResult = new AuthenticationResult(authenticationSuccessful, userExist);
return(SystemUtilityService.CreateResult(Constants.UserDisableUserMessage, authenResult, false));
}
AuthenticationDTO existing = new AuthenticationDTO(username, user.Password);
AuthenticationDTO credentials = new AuthenticationDTO(username, password);
// If the username's stored password matches the hashed password.
if (_authenticationService.Authenticate(existing, credentials))
{
authenticationSuccessful = true;
// Create a token for the username.
string token = await _sessionService.CreateTokenAsync(username).ConfigureAwait(false);
// Get user type.
string userType = await _userManagementService.GetUserTypeAsync(username).ConfigureAwait(false);
Console.WriteLine(userType);
// Get the path to store the token.
string path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
path = path + $"{path.Substring(0, 1)}" + Constants.TokenFile;
// Save the token the the path.
using (StreamWriter sw = File.CreateText(path))
{
sw.WriteLine(token);
}
// Log the action.
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.LogInOperation, username, ipAddress).ConfigureAwait(false);
// Return the result of the successful login.
AuthenticationResult authenResult = new AuthenticationResult(authenticationSuccessful, userExist, token, userType);
return(SystemUtilityService.CreateResult(Constants.LogInSuccessUserMessage, authenResult, false));
}
// If the password doesn't match.
else
{
// Increment the number of login failure.
await _userManagementService.IncrementLoginFailuresAsync(username,
Constants.LogInTriesResetTime,
Constants.MaxLogInAttempts).ConfigureAwait(false);
// Log the action.
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.LogInOperation, Constants.AnonymousUserIdentifier, ipAddress,
Constants.InvalidPasswordLogMessage).ConfigureAwait(false);
// Return the result of the unsuccessful login.
AuthenticationResult authenResult = new AuthenticationResult(authenticationSuccessful, userExist);
return(SystemUtilityService.CreateResult(Constants.InvalidLogInUserMessage, authenResult, false));
}
}
// Catch exceptions.
catch (Exception e)
{
// Log the exception.
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.LogInOperation, Constants.AnonymousUserIdentifier, ipAddress, e.Message).ConfigureAwait(false);
// If the current number of consecutive exceptions has reached the maximum number of retries.
if (currentNumExceptions + 1 >= Constants.MaximumOperationRetries)
{
// Notify the system admin.
await SystemUtilityService.NotifySystemAdminAsync($"{Constants.LogInOperation} failed a maximum number of times for {username}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
// Return the result of the exception occured.
AuthenticationResult authenResult = new AuthenticationResult(authenticationSuccessful, userExist);
return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, authenResult, true));
}
}
public async Task <Result <bool> > VerifyPhoneCodeAsync(string username, string inputCode, string ipAddress,
string phoneNumber, bool duringRegistration,
int currentNumExceptions)
{
try
{
bool phoneVerificationSuccess = false;
UserObject user = await _userManagementService.GetUserInfoAsync(username).ConfigureAwait(false);
if (user.PhoneCodeFailures >= Constants.MaxPhoneCodeAttempts)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyPhoneOperation, username, ipAddress,
Constants.MaxPhoneTriesReachedLogMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.MaxPhoneTriesReachedUserMessage, phoneVerificationSuccess, false));
}
string verificationStatus = await _verificationService.VerifyPhoneCodeAsync(phoneNumber, inputCode).ConfigureAwait(false);
if (verificationStatus.Equals(Constants.TwilioAuthenticationApprovedString))
{
phoneVerificationSuccess = true;
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyPhoneOperation, username, ipAddress).ConfigureAwait(false);
if (duringRegistration)
{
await _userManagementService.MakeTempPermAsync(username).ConfigureAwait(false);
}
return(SystemUtilityService.CreateResult(Constants.VerifyPhoneSuccessUserMessage, phoneVerificationSuccess, false));
}
else if (verificationStatus.Equals(Constants.TwilioAuthenticationPendingString))
{
await _userManagementService.IncrementPhoneCodeFailuresAsync(username).ConfigureAwait(false);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyPhoneOperation, username, ipAddress,
Constants.WrongPhoneCodeMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.WrongPhoneCodeMessage, phoneVerificationSuccess, false));
}
else
{
// Failed
await _userManagementService.IncrementPhoneCodeFailuresAsync(username).ConfigureAwait(false);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyPhoneOperation, username, ipAddress,
Constants.PhoneCodeExpiredLogMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.PhoneCodeExpiredUserMessage, phoneVerificationSuccess, false));
}
}
catch (Exception e)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.VerifyPhoneOperation, username, ipAddress, e.Message).ConfigureAwait(false);
if (currentNumExceptions + 1 >= Constants.MaximumOperationRetries)
{
await SystemUtilityService.NotifySystemAdminAsync($"{Constants.VerifyPhoneOperation} failed a maximum number of times for {username}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
return(SystemUtilityService.CreateResult(Constants.SystemErrorUserMessage, false, true));
}
}
public async Task <Result <bool> > CreateUploadAsync(UploadPost post, int failureCount)
{
var result = false;
// Escape condition for recursive call if exception is thrown.
if (failureCount >= Constants.OperationRetry)
{
return(SystemUtilityService.CreateResult(Constants.UploadCreationErrorMessage, result, true));
}
try
{
if (!await _userManagementService.CheckUserExistenceAsync(post.Username).ConfigureAwait(false))
{
// Log the fact user was invalid.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateUploadOperation, post.Username, post.IPAddress, Constants.UploadUserDNESystemMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.UploadUserDNEUserMessage, result, false));
}
var latLong = LocationUtilityService.GetImageLatitudeAndLongitude(post.Image);
var latitude = latLong.Item1;
var longitude = latLong.Item2;
var withinScope = LocationUtilityService.CheckLocationWithinPolygon(latitude, longitude, Constants.CurrentScopePolygon);
if (!withinScope)
{
// Log the fact that scope was violated.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateUploadOperation, post.Username, post.IPAddress, Constants.ImageNotWithinScopeSystemMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.ImageNotWithinScopeUserMessage, result, false));
}
var storeID = await _storeService.FindStoreAsync(latitude, longitude).ConfigureAwait(false);
if (storeID == Constants.NoStoreFoundCode)
{
// Log the fact that scope was violated.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateUploadOperation, post.Username, post.IPAddress, Constants.NoStoreFoundSystemMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.NoStoreFoundUserMessage, result, false));
}
var imagePath = Constants.PhotoFolder + "\\" + post.Username + "_" + TimeUtilityService.CurrentUnixTime() + post.FileExtension;
var uploadDTO = new UploadDTO(imagePath, post.Image, post.Category, post.Name, (DateTime)post.PostTime, post.Username, post.Description,
post.Rating, post.Price, post.PriceUnit, post.ImageSize);
var verification = _uploadService.VerifyUpload(uploadDTO, Constants.MaximumPhotoCharacters, Constants.MinimumPhotoCharacters, Constants.MinimumImageSizeMB, Constants.MaximumImageSizeMB, Constants.ValidImageExtensions,
Constants.IngredientNameMaximumCharacters, Constants.IngredientNameMinimumCharacters, Constants.MaximumIngredientPrice,
Constants.DescriptionMaximumCharacters, Constants.DescriptionMinimumCharacters, Constants.ExogredientCategories,
Constants.ExogredientPriceUnits, Constants.ValidTimeBufferMinutes, Constants.MaximumRating, Constants.MinimumRating);
if (!verification.VerificationStatus)
{
// Log the fact that scope was violated.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateUploadOperation, post.Username, post.IPAddress, Constants.UploadNotValidSystemMessage).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(verification.Message, result, false));
}
Directory.CreateDirectory(Constants.PhotoFolder);
post.Image.Save(imagePath);
var uploadRecord = new UploadRecord(post.PostTime, post.Username, storeID, post.Description, post.Rating.ToString(), imagePath,
post.Price, post.PriceUnit, post.Name, Constants.NoValueInt, Constants.NoValueInt, Constants.NotInProgressStatus, post.Category);
await _uploadService.CreateUploadAsync(uploadRecord).ConfigureAwait(false);
result = true;
}
catch (Exception ex)
{
// Log exception.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateUploadOperation, post.Username, post.IPAddress, ex.ToString()).ConfigureAwait(false);
// Recursively retry the operation until the maximum amount of retries is reached.
await CreateUploadAsync(post, ++failureCount).ConfigureAwait(false);
}
// Log the fact that the operation was successful.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateUploadOperation, post.Username, post.IPAddress).ConfigureAwait(false);
return(SystemUtilityService.CreateResult(Constants.UploadCreationSuccessMessage, result, false));
}