public async Task DeleteFileInfo(int serviceId, File file)
{
try
{
var service = Context.Services.FirstOrDefault(s => s.Id == serviceId);
if (service == null)
{
LoggingHandler.LogError("The specified service does not exist");
throw new UseCaseException()
{
UserErrorMessage = "The specified service does not exist"
};
}
service.ImageId = null;
Context.Services.Attach(service);
await Context.SaveChangesAsync().ConfigureAwait(false);
Context.Files.Remove(file);
await Context.SaveChangesAsync().ConfigureAwait(false);
LoggingHandler.LogInfo("Image deleted successfully.");
}
catch (Exception e)
{
LoggingHandler.LogError("Error deleting image");
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
throw;
}
}
public SynonymGroupResponseList ExecuteGet(SynonymGroupSearchRequest requestParams)
{
LoggingHandler.LogInfo("Call synonyms gateway.");
var gatewayResponse = _synonymGroupsGateway.SearchSynonymGroups(requestParams);
return(gatewayResponse == null ? null : gatewayResponse.ToResponse());
}
public LoginUserQueryParam ChangePassword(ResetPasswordQueryParams changePasswordParams)
{
var userPool = new CognitoUserPool(_connectionInfo.UserPoolId, _connectionInfo.ClientId, _provider);
var cognitoUser = new CognitoUser(changePasswordParams.Email, _connectionInfo.ClientId, userPool, _provider);
try
{
AuthFlowResponse authResponse = null;
authResponse = cognitoUser.StartWithSrpAuthAsync(new InitiateSrpAuthRequest()
{
Password = changePasswordParams.Password
}).Result;
while (authResponse.AuthenticationResult == null)
{
if (authResponse.ChallengeName == ChallengeNameType.NEW_PASSWORD_REQUIRED)
{
authResponse =
cognitoUser.RespondToNewPasswordRequiredAsync(new RespondToNewPasswordRequiredRequest()
{
SessionID = authResponse.SessionID,
NewPassword = changePasswordParams.NewPassword,
}).Result;
}
}
if (authResponse.AuthenticationResult != null)
{
LoggingHandler.LogInfo("User successfully authenticated.");
var loginParams = new LoginUserQueryParam();
loginParams.Email = changePasswordParams.Email;
loginParams.Password = changePasswordParams.NewPassword;
return(loginParams);
}
else
{
LoggingHandler.LogError("Error in authentication process.");
}
}
catch (AggregateException e)
{
e.Handle((x) =>
{
if (x is NotAuthorizedException) // This we know how to handle.
{
LoggingHandler.LogInfo("Authentication Gateway: Invalid credentials provided.");
return(true);
}
if (x is UserNotFoundException) // This we know how to handle.
{
LoggingHandler.LogInfo("Authentication Gateway: User not found.");
return(true);
}
return(false); // Let anything else stop the application.
});
}
return(null);
}
public async Task <SynonymsResponse> ExecuteUpdate(string accessToken, SynonymUpdateRequest requestParams)
{
LoggingHandler.LogInfo("Initiating update process.");
SynonymsResponse response = new SynonymsResponse();
await UpdateSynonymChanges(accessToken, requestParams.GoogleFileId, requestParams.SheetName,
requestParams.SheetRange, requestParams.GoogleApiKey).ConfigureAwait(false);
response.Success = true;
return(response);
}
public async Task <IList <IList <object> > > ReadSheetToObjectRowListAsync(string spreadSheetId, string sheetName, string sheetRange)
{
SpreadsheetsResource.ValuesResource.GetRequest getter =
_sheetsService.Spreadsheets.Values.Get(spreadSheetId, $"{sheetName}!{sheetRange}");
LoggingHandler.LogInfo("Executing client API call");
ValueRange response = await getter.ExecuteAsync().ConfigureAwait(false);
LoggingHandler.LogInfo("Execution completed");
IList <IList <object> > values = response.Values;
return(values);
}
public async Task <IDictionary <string, string[]> > ReadSpreadsheetAsync(string spreadSheetId, string sheetName, string sheetRange, string googleApiKey)
{
LoggingHandler.LogInfo("Initialise Google API.");
await _googleClient.InitialiseWithGoogleApiKey(googleApiKey).ConfigureAwait(false);
LoggingHandler.LogInfo("Initialisation complete. Getting spreadsheet rows.");
IList <IList <object> > values =
await _googleClient.ReadSheetToObjectRowListAsync(spreadSheetId, sheetName, sheetRange).ConfigureAwait(false);
if (values == null || !values.Any())
{
LoggingHandler.LogError("No data found. Unresolved issue, so just return without making any updates.");
return(null);
}
LoggingHandler.LogInfo("Spreadsheet rows received. Parsing data.");
//Start Synonyms
IDictionary <string, string[]> synonymGroups = new Dictionary <string, string[]>();
foreach (IList <object> row in values.Skip(2))
{
if (row.Count > 1)
{
try
{
string synonymGroupName = row[0].ToString().Trim();
if (synonymGroupName.Length > 0)
{
List <string> words = new List <string>();
foreach (object cell in row) //Include group name.
{
if (cell != null)
{
string word = cell.ToString().Trim();
if (word.Length > 0)
{
words.Add(word);
}
}
}
synonymGroups.Add(synonymGroupName, words.ToArray());
}
}
catch (NullReferenceException e)
{
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
Debugger.Break();
}
}
}
return(synonymGroups);
}
public async Task UpdateSynonyms()
{
var updateRequest = new SynonymUpdateRequest
{
GoogleFileId = Environment.GetEnvironmentVariable("SYNONYMS_GOOGLE_FILE_ID"),
SheetName = Environment.GetEnvironmentVariable("SYNONYMS_SHEET_NAME"),
SheetRange = Environment.GetEnvironmentVariable("SYNONYMS_SHEET_RANGE"),
GoogleApiKey = Environment.GetEnvironmentVariable("GOOGLE_API_KEY")
};
LoggingHandler.LogInfo("Starting process of updating synonyms.");
await _synonymsUseCase.ExecuteUpdate(null, updateRequest).ConfigureAwait(false);
}
public AuthenticationResult LoginUser(LoginUserQueryParam loginUserQueryParam)
{
InitiateAuthRequest iaRequest = new InitiateAuthRequest
{
ClientId = _connectionInfo.ClientId,
AuthFlow = AuthFlowType.USER_PASSWORD_AUTH
};
iaRequest.AuthParameters.Add("USERNAME", loginUserQueryParam.Email);
iaRequest.AuthParameters.Add("PASSWORD", loginUserQueryParam.Password);
InitiateAuthResponse authResp = new InitiateAuthResponse();
var authResult = new AuthenticationResult();
try
{
authResp = _provider.InitiateAuthAsync(iaRequest).Result;
authResult.AccessToken = authResp.AuthenticationResult.AccessToken;
authResult.IdToken = authResp.AuthenticationResult.IdToken;
authResult.RefreshToken = authResp.AuthenticationResult.RefreshToken;
authResult.TokenType = authResp.AuthenticationResult.TokenType;
authResult.ExpiresIn = authResp.AuthenticationResult.ExpiresIn;
authResult.Success = true;
}
catch (AggregateException e)
{
e.Handle((x) =>
{
if (x is UserNotConfirmedException) // This we know how to handle.
{
LoggingHandler.LogInfo("User not confirmed.");
authResult.Success = false;
authResult.ResponseMessage = "User not confirmed";
return(true);
}
if (x is NotAuthorizedException) // This we know how to handle.
{
LoggingHandler.LogInfo("Invalid credentials provided.");
authResult.Success = false;
authResult.ResponseMessage = "Invalid credentials provided.";
return(true);
}
return(false); // Let anything else stop the application.
});
}
return(authResult);
}
public async Task DeleteImage(string request)
{
var deleteObjectRequest = new DeleteObjectRequest();
deleteObjectRequest.BucketName = _repositoryBucket;
deleteObjectRequest.Key = _imagesFolder + "/" + request;
try
{
await _s3Client.DeleteObjectAsync(deleteObjectRequest).ConfigureAwait(false);
LoggingHandler.LogInfo($"File {request} deleted successfully.");
}
catch (Exception e)
{
LoggingHandler.LogError($"Error deleting file {request}.");
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
throw;
}
}
/// <summary>
/// Reads the given spreadsheet and updates database changes asynchronous.
/// </summary>
/// <param name="accessToken">Access token..</param>
/// <param name="spreadSheetId">The spread sheet identifier.</param>
/// <param name="sheetName">Name of the sheet to read.</param>
/// <param name="sheetRange">The sheet range to read.</param>
/// <param name="googleApiKey">The Google Api Key.</param>
public async Task UpdateSynonymChanges(string accessToken, string spreadSheetId, string sheetName,
string sheetRange, string googleApiKey)
{
LoggingHandler.LogInfo("Get data from source.");
IDictionary <string, string[]> synonymGroups =
await ReadSpreadsheetAsync(spreadSheetId, sheetName, sheetRange, googleApiKey).ConfigureAwait(false);
if (synonymGroups == null || synonymGroups.Count == 0)
{
LoggingHandler.LogInfo("There is no synonym data from the google spreadsheet.");
return;
}
//compare groups with database results and delete anything that has been removed.
SynonymGroupSearchRequest requestParams = new SynonymGroupSearchRequest()
{
Direction = "asc",
Search = string.Empty,
Sort = "name"
};
LoggingHandler.LogInfo("Received synonyms from source. Getting current data to update.");
SynonymGroupResponseList synonymGroupsResponseList = ExecuteGet(requestParams);
try
{
LoggingHandler.LogInfo("Deleting any items removed.");
await LoopDatabaseAndDeleteAnythingRemovedFromSpreadsheet(accessToken, synonymGroupsResponseList, synonymGroups).ConfigureAwait(false);
LoggingHandler.LogInfo("Updating any changed items.");
await LoopSpreadsheetAndUpdateDatabaseWithChanges(accessToken, synonymGroupsResponseList, synonymGroups).ConfigureAwait(false);
}
catch (Exception e)
{
LoggingHandler.LogError("Error updating data.");
LoggingHandler.LogError(e.Message);
Debugger.Break();
}
LoggingHandler.LogInfo("Synonyms sync process complete.");
}
public UserOrganisationDomain LinkUserToOrganisation(int organisationId, int userId)
{
LoggingHandler.LogInfo($"Linking userId {userId} to organisation {organisationId}");
var userOrganisation = new UserOrganisation {
UserId = userId, OrganisationId = organisationId, CreatedAt = DateTime.Now
};
try
{
Context.UserOrganisations.Add(userOrganisation);
Context.SaveChanges();
}
catch (DbUpdateException dbex)
{
LoggingHandler.LogError("Error linking user to organisation");
LoggingHandler.LogError(dbex.Message);
LoggingHandler.LogError(dbex.StackTrace);
var deverror = dbex.Message;
if (dbex.InnerException != null)
{
deverror += "-" + dbex.InnerException.Message;
}
throw new UseCaseException()
{
UserErrorMessage = "Error linking user to organisation",
DevErrorMessage = deverror
};
}
catch (Exception e)
{
LoggingHandler.LogError("Error linking user to organisation");
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
throw;
}
userOrganisation = GetUserOrganisationById(userOrganisation.Id);
return(_mapper.ToDomain(userOrganisation));
}
public void DeleteUserOrganisationLink(int userId)
{
try
{
var userOrganisationLink = Context.UserOrganisations
.FirstOrDefault(o => o.UserId == userId);
if (userOrganisationLink == null)
{
LoggingHandler.LogWarning("User Organisation Link does not exist");
}
else
{
Context.UserOrganisations.Remove(userOrganisationLink);
Context.SaveChanges();
LoggingHandler.LogInfo("User organisation link removed successfully");
}
}
catch (Exception e)
{
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
throw;
}
}
public LoginUserResponse ExecuteFirstLogin(ResetPasswordQueryParams loginParams, string ipAddress)
{
if (string.IsNullOrWhiteSpace(loginParams.Email))
{
throw new UseCaseException()
{
UserErrorMessage = "Could not login as the email address was invalid"
}
}
;
if (string.IsNullOrWhiteSpace(loginParams.Password))
{
throw new UseCaseException()
{
UserErrorMessage = "Could not login as the password was invalid"
}
}
;
var loginResult = _authenticateGateway.ChangePassword(loginParams);
if (loginResult == null)
{
throw new UseCaseException()
{
UserErrorMessage = "Could not login as the email and/or password was invalid"
}
}
;
loginResult.IpAddress = ipAddress;
var user = _usersGateway.GetUserByEmail(loginParams.Email, UserStatus.Invited);
_usersGateway.SetUserStatus(user, UserStatus.Active);
var loginResponse = CreateLoginSession(loginResult, user);
return(loginResponse);
}
LoginUserResponse CreateLoginSession(LoginUserQueryParam loginParams, UserDomain user)
{
var timestamp = DateTime.UtcNow;
var sessionId = Guid.NewGuid().ToString();
LoggingHandler.LogInfo(loginParams.IpAddress);
LoggingHandler.LogInfo(user.Id.ToString());
Session session = new Session()
{
IpAddress = loginParams.IpAddress,
CreatedAt = timestamp,
LastAccessAt = timestamp,
UserId = user.Id,
Payload = sessionId,
};
_sessionsGateway.AddSession(session);
return(new LoginUserResponse()
{
AccessToken = sessionId
});
}
public List <SynonymGroupDomain> SearchSynonymGroups(SynonymGroupSearchRequest requestParams)
{
// Search search term to use (searches on [name] column for the MVP)
// Sort the column name by which to sort
// Direction sort order; asc, desc
List <SynonymGroupDomain> response = new List <SynonymGroupDomain>();
var direction = ConvertToEnum(requestParams.Direction);
if (direction == SortDirection.None)
{
throw new UseCaseException()
{
UserErrorMessage = "The sort direction was not valid (must be one of asc, desc)"
}
}
;
LoggingHandler.LogInfo("Getting existing synonyms from the db.");
var matchingSynonymGroups = Context.SynonymGroups.AsQueryable();
// handle search
if (!string.IsNullOrWhiteSpace(requestParams.Search))
{
matchingSynonymGroups = matchingSynonymGroups.Where(o => EF.Functions.ILike(o.Name, $"%{requestParams.Search}%"));
}
// handle sort by column name and sort direction
var entityPropName = GetEntityPropertyForColumnName(typeof(SynonymGroup), requestParams.Sort);
if (entityPropName == null)
{
throw new UseCaseException()
{
UserErrorMessage = $"The 'Sort' parameter contained the value '{requestParams.Sort}' " +
"which is not a valid column name"
}
}
;
matchingSynonymGroups = (direction == SortDirection.Asc) ?
matchingSynonymGroups.OrderBy(u => EF.Property <SynonymGroup>(u, entityPropName)) :
matchingSynonymGroups.OrderByDescending(u => EF.Property <SynonymGroup>(u, entityPropName));
try
{
var synonymGroupList = matchingSynonymGroups
.Include(o => o.SynonymWords)
.AsNoTracking()
.ToList();
response = _mapper.ToDomain(synonymGroupList);
}
catch (InvalidOperationException e)
{
throw new UseCaseException()
{
UserErrorMessage = "Could not run the synonym group search query with the supplied input parameters",
DevErrorMessage = e.Message
};
}
return(response);
}
}
}
