public async Task <bool> SendResetPasswordLinkAsync(string username, string ipAddress)
{
try
{
if (!await _userManagementService.CheckUserExistenceAsync(username).ConfigureAwait(false))
{
return(false);
}
var userInfo = await _userManagementService.GetUserInfoAsync(username).ConfigureAwait(false);
var email = userInfo.Email;
await _verificationService.SendResetPasswordLinkAsync(username, email).ConfigureAwait(false);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.UpdatePasswordOperation, username, ipAddress).ConfigureAwait(false);
return(true);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.UpdatePasswordOperation, username, ipAddress, e.Message).ConfigureAwait(false);
throw e;
}
}
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));
}
}
/// <summary>
/// Method to read one snapshot.
/// There are 3 retries, after the retries fail it will notify system admin.
/// </summary>
/// <param name="year">The year to get the snapshot/</param>
/// <param name="month">The month to get the snapshot.</param>
/// <returns>A snapshot object with data just for that month.</returns>
public async Task <SnapShotResult> ReadOneSnapshotAsync(int year, int month)
{
int currentNumExceptions = 0;
var snapshot = new SnapShotResult(null, null, null, null, null, null, null, null, null, null, null);
while (currentNumExceptions < 4)
{
currentNumExceptions++;
try
{
snapshot = await _snapshotService.ReadOneSnapshotAsync(year, month).ConfigureAwait(false);
}
catch (Exception e)
{
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.ReadOneSnapshotOperation,
Constants.SystemIdentifier,
Constants.LocalHost, e.Message).ConfigureAwait(false);
// Increment the amount of tries and then check if the 3 retries are up.
// If it is, notify system admin.
if (currentNumExceptions >= Constants.MaximumOperationRetries)
{
await SystemUtilityService.NotifySystemAdminAsync($"{Constants.ReadOneSnapshotOperation} failed a maximum number of times for {Constants.LocalHost}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
}
}
return(snapshot);
}
/// <summary>
/// Returns the number of total stores that are associated with
/// searchTerm, latitude, longitude, radius, and searchBy.
/// </summary>
/// <param name="searchTerm">Term to search for</param>
/// <param name="latitude">Latitdue of the center of search</param>
/// <param name="longitude">Longitude of the center of search</param>
/// <param name="radius">The radius from the center of search</param>
/// <param name="searchBy">Method of search. It must be either "ingredient" or "store"</param>
/// <param name="failureCount">Number of failures</param>
/// <param name="username">Username who invoked this action</param>
/// <param name="ipAddress">IP Address of the user</param>
/// <returns>The number of retrieved stores</returns>
public async Task <int> GetTotalStoreResultsNumberAsync(string searchTerm,
double latitude, double longitude, double radius, string searchBy,
int failureCount, string username, string ipAddress)
{
try
{
if (radius == Constants.EmptyRadius)
{
radius = Constants.DefaultRadius;
}
var normalizedTerm = searchBy == Constants.searchByIngredient ?
StringUtilityService.NormalizeTerm(searchTerm, this._enUSDicPath, this._enUSAffPath) : searchTerm;
var num = await _searchService.GetTotalStoreResultsNumberAsync
(normalizedTerm, latitude, longitude, radius, searchBy).ConfigureAwait(false);
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.GetTotalStoreResultsNumberOperation, username, ipAddress).ConfigureAwait(false);
return(num);
}
catch (Exception e)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.GetTotalStoreResultsNumberOperation, username, ipAddress, e.Message).ConfigureAwait(false);
failureCount += 1;
if (failureCount >= Constants.MaxSearchRelatedAttempts)
{
throw e;
}
else
{
return(await GetTotalStoreResultsNumberAsync(searchTerm, latitude, longitude,
radius, searchBy, failureCount, username, ipAddress).ConfigureAwait(false));
}
}
}
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));
}
}
/// <summary>
/// Method to create a snapshot with given year and month.
/// </summary>
/// <param name="currentNumExceptions"></param>
/// <param name="year"></param>
/// <param name="month"></param>
/// <returns></returns>
public async Task <bool> CreateSnapshotAsync(int currentNumExceptions, int year, int month)
{
bool createSnapshotSuccess = false;
try
{
// Get the amount of days in the specific month.
var amountOfDays = _snapshotService.GetDaysInMonth(year, month);
// Get all the logs pertaining to the specific month.
var logResults = await _snapshotService.GetLogsInMonthAsync(year, month, amountOfDays).ConfigureAwait(false);
var snapshot = new List <string>();
// Calling the snapshot service methods to format the data in logresults to dictionaries.
var operationsDict = _snapshotService.GetOperationDict(logResults, amountOfDays);
var usersDict = await _snapshotService.GetUsersDictAsync().ConfigureAwait(false);
var cityDict = await _snapshotService.GetCityDictAsync(logResults).ConfigureAwait(false);
var userUploadedDict = _snapshotService.GetUserUploadedDict(logResults);
var uploadedIngredientDict = _snapshotService.GetUploadedIngredientDict(logResults);
var uploadedStoreDict = _snapshotService.GetUploadedStoreDict(logResults);
var searchedIngredientDict = _snapshotService.GetSearchedIngredientDict(logResults);
var searchedStoreDict = _snapshotService.GetSearchedStoreDict(logResults);
var upvotedUserDict = await _snapshotService.GetUpvotedUserDictAsync(logResults).ConfigureAwait(false);
var downvotedUserDict = await _snapshotService.GetDownvotedUserDictAsync(logResults).ConfigureAwait(false);
// Finalizing the data and then adding it to the snapshot List.
snapshot.Add(_snapshotService.FormatOperationsDict(operationsDict));
snapshot.Add(_snapshotService.FormatStringIntDict(usersDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(cityDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(userUploadedDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(uploadedIngredientDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(uploadedStoreDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(searchedIngredientDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(searchedStoreDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(upvotedUserDict));
snapshot.Add(_snapshotService.FinalizeStringIntDictForSnap(downvotedUserDict));
// Call the method to create the snapshot in the snapshot service.
createSnapshotSuccess = await _snapshotService.CreateSnapShotAsync(year, month, snapshot).ConfigureAwait(false);
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateSnapshotOperation,
Constants.SystemIdentifier,
Constants.LocalHost).ConfigureAwait(false);
}
catch (Exception e)
{
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.CreateSnapshotOperation,
Constants.SystemIdentifier,
Constants.LocalHost, e.Message).ConfigureAwait(false);
if (currentNumExceptions >= Constants.MaximumOperationRetries)
{
await SystemUtilityService.NotifySystemAdminAsync($"{Constants.CreateSnapshotOperation} failed a maximum number of times for {Constants.LocalHost}.", Constants.SystemAdminEmailAddress).ConfigureAwait(false);
}
}
return(createSnapshotSuccess);
}
/// <summary>
/// Retrieve the profile score for a username and perform business logic to check existence.
/// Retries operation when there is an exception and logs all actions.
/// </summary>
/// <param name="username">Username of profile score to fetch.</param>
/// <param name="ipAddress">Ipaddress for logging.</param>
/// <param name="failureCount">Current failure count of the operation.</param>
/// <param name="ex">Exception that is thrown.</param>
/// <returns>List of profileScoreResults.</returns>
public async Task <List <ProfileScoreResult> > GetProfileScoreAsync(string username, string ipAddress, int failureCount, Exception ex)
{
// Escape condition for recursive call if exception is thrown.
if (failureCount >= Constants.OperationRetry)
{
throw ex;
}
// List of profile scores to return.
var profileScores = new List <ProfileScoreResult>();
try
{
// Check that the user exists.
var userExists = await _userManagementService.CheckUserExistenceAsync(username).ConfigureAwait(false);
if (!userExists)
{
throw new ArgumentException(Constants.UsernameDNE);
}
// Perform operation.
profileScores = await _uploadService.getUploadVotesAsync(username).ConfigureAwait(false);
}
catch (Exception e)
{
// Log everytime we catch an exception.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.GetProfileScoreOperation, username, ipAddress, e.ToString()).ConfigureAwait(false);
// Retry operation Constant.OperationRetry amount of times when there is exception.
await GetProfileScoreAsync(username, ipAddress, ++failureCount, e).ConfigureAwait(false);
}
// Operation successfull, log that operation.
await _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.GetProfileScoreOperation, username, ipAddress).ConfigureAwait(false);
return(profileScores);
}
// 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));
}
/// <summary>
/// Retrieve a list of uploads based off an ingredient's name and store id.
/// </summary>
/// <param name="ingredientName"> The name of the ingredient used for searching uploads</param>
/// <param name="storeId"> The id of store used for searching uploads.</param>
/// <param name="pagination">Pagination for the operation. starts at 0. </param>
/// <param name="failurecount">Count of how many times current operation has failed. </param>
/// <param name="username">username of person doing operation used for logging. </param>
/// <param name="ipAddress">ip address of system requesting operation for logging. </param>
/// <returns> A list of uploadsresults </returns>
public async Task <List <UploadResult> > GetUploadsByIngredientNameandStoreId(string ingredientName, int storeId, int pagination, int failurecount, string username, string ipAddress)
{
try
{
var uploads = await _uploadService.ReadUploadsByIngredientNameandStoreId(ingredientName, storeId, pagination).ConfigureAwait(false);
return(uploads);
}
catch (Exception e)
{
_ = _loggingManager.LogAsync(DateTime.UtcNow.ToString(Constants.LoggingFormatString),
Constants.GetUploadsByIngredientNameandStoreIdOperation, username, ipAddress).ConfigureAwait(false);
failurecount += 1;
if (failurecount >= Constants.LoggingRetriesAmount)
{
throw e;
}
else
{
return(await GetUploadsByIngredientNameandStoreId(ingredientName, storeId, pagination, failurecount, username, ipAddress).ConfigureAwait(false));
}
}
}