public void SaveAnswers(Dictionary <string, dynamic> viewModel, string guid, string form, IEnumerable <CustomFormFile> files, bool isPageValid, bool appendMultipleFileUploadParts = false)
{
var formData = _distributedCache.GetString(guid);
var convertedAnswers = new FormAnswers {
Pages = new List <PageAnswers>()
};
var currentPageAnswers = new PageAnswers();
if (!string.IsNullOrEmpty(formData))
{
convertedAnswers = JsonConvert.DeserializeObject <FormAnswers>(formData);
}
if (convertedAnswers.Pages != null && convertedAnswers.Pages.Any(_ => _.PageSlug == viewModel["Path"].ToLower()))
{
currentPageAnswers = convertedAnswers.Pages.Where(_ => _.PageSlug == viewModel["Path"].ToLower()).ToList().FirstOrDefault();
convertedAnswers.Pages = convertedAnswers.Pages.Where(_ => _.PageSlug != viewModel["Path"].ToLower()).ToList();
}
var answers = new List <Answers>();
foreach (var item in viewModel)
{
if (!_disallowedKeys.DisallowedAnswerKeys.Any(key => item.Key.Contains(key)))
{
answers.Add(new Answers {
QuestionId = item.Key, Response = item.Value
});
}
}
if ((files == null || !files.Any()) && currentPageAnswers.Answers != null && currentPageAnswers.Answers.Any() && isPageValid && appendMultipleFileUploadParts)
{
answers = currentPageAnswers.Answers;
}
if (files != null && files.Any() && isPageValid)
{
answers = SaveFormFileAnswers(answers, files, appendMultipleFileUploadParts, currentPageAnswers);
}
convertedAnswers.Pages?.Add(new PageAnswers
{
PageSlug = viewModel["Path"].ToLower(),
Answers = answers
});
convertedAnswers.Path = viewModel["Path"];
convertedAnswers.FormName = form;
_distributedCache.SetStringAsync(guid, JsonConvert.SerializeObject(convertedAnswers));
}
public async Task <List <string> > IndexSchema()
{
if (!_distributedCacheConfiguration.UseDistributedCache)
{
_logger.LogWarning($"S3FileSchemaProvider::IndexSchema, A request to index form schema was made but UseDistributedCache is disabled");
return(new List <string>());
}
var result = new ListObjectsV2Response();
try
{
result = await _s3Gateway.ListObjectsV2(_configuration["S3BucketKey"], $"{_environment.EnvironmentName.ToS3EnvPrefix()}/{_configuration["ApplicationVersion"]}");
}
catch (Exception e)
{
_logger.LogWarning($"S3FileSchemaProvider::IndexSchema, Failed to retrieve list of forms from s3 bucket {_environment.EnvironmentName.ToS3EnvPrefix()}/{_configuration["ApplicationVersion"]}, Exception: {e.Message}");
return(new List <string>());
}
var indexKeys = result.S3Objects.Select(_ => _.Key).ToList();
_ = _distributedCacheWrapper.SetStringAsync(CacheConstants.INDEX_SCHEMA, JsonConvert.SerializeObject(indexKeys), _distributedCacheExpirationConfiguration.Index);
return(indexKeys);
}
public async Task <T> GetFromCacheOrDirectlyFromSchemaAsync <T>(string cacheKey, int minutes, ESchemaType type)
{
T result;
var prefix = type == ESchemaType.PaymentConfiguration ? "payment-config/" : string.Empty;
if (_distributedCacheConfiguration.Value.UseDistributedCache && minutes > 0)
{
var data = _distributedCache.GetString($"{type.ToESchemaTypePrefix(_configuration["ApplicationVersion"])}{cacheKey}");
if (data == null)
{
result = await _schemaProvider.Get <T>($"{prefix}{cacheKey}");
if (result != null)
{
await _distributedCache.SetStringAsync($"{type.ToESchemaTypePrefix(_configuration["ApplicationVersion"])}{cacheKey}", JsonConvert.SerializeObject(result), minutes);
}
return(result);
}
return(JsonConvert.DeserializeObject <T>(data));
}
return(await _schemaProvider.Get <T>($"{prefix}{cacheKey}"));
}
public async Task <FormSchema> Build(string formKey)
{
if (!_schemaProvider.ValidateSchemaName(formKey).Result)
{
return(null);
}
if (_distributedCacheConfiguration.UseDistributedCache && _distributedCacheExpirationConfiguration.FormJson > 0)
{
var data = _distributedCache.GetString($"{ESchemaType.FormJson.ToESchemaTypePrefix(_configuration["ApplicationVersion"])}{formKey}");
if (data != null)
{
return(JsonConvert.DeserializeObject <FormSchema>(data));
}
}
var formSchema = await _schemaProvider.Get <FormSchema>(formKey);
formSchema = await _reusableElementSchemaFactory.Transform(formSchema);
formSchema = _lookupSchemaFactory.Transform(formSchema);
if (_distributedCacheConfiguration.UseDistributedCache && _distributedCacheExpirationConfiguration.FormJson > 0)
{
await _distributedCache.SetStringAsync($"{ESchemaType.FormJson.ToESchemaTypePrefix(_configuration["ApplicationVersion"])}{formKey}", JsonConvert.SerializeObject(formSchema), _distributedCacheExpirationConfiguration.FormJson);
}
return(formSchema);
}
private async Task <BoookingNextAvailabilityEntity> RetrieveNextAvailability(IElement bookingElement, IBookingProvider bookingProvider, AppointmentType appointmentType)
{
var bookingNextAvailabilityCachedKey = $"{bookingElement.Properties.BookingProvider}-{appointmentType.AppointmentId}{appointmentType.OptionalResources.CreateKeyFromResources()}";
var bookingNextAvailabilityCachedResponse = _distributedCache.GetString(bookingNextAvailabilityCachedKey);
if (bookingNextAvailabilityCachedResponse is not null)
{
return(JsonConvert.DeserializeObject <BoookingNextAvailabilityEntity>(bookingNextAvailabilityCachedResponse));
}
AvailabilityDayResponse nextAvailability;
BoookingNextAvailabilityEntity result;
try
{
nextAvailability = await bookingProvider
.NextAvailability(new AvailabilityRequest
{
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddMonths(bookingElement.Properties.SearchPeriod),
AppointmentId = appointmentType.AppointmentId,
OptionalResources = appointmentType.OptionalResources
});
}
catch (BookingNoAvailabilityException)
{
result = new BoookingNextAvailabilityEntity {
BookingHasNoAvailableAppointments = true
};
await _distributedCache.SetStringAsync(bookingNextAvailabilityCachedKey, JsonConvert.SerializeObject(result), _distributedCacheExpirationConfiguration.BookingNoAppointmentsAvailable);
return(result);
}
result = new BoookingNextAvailabilityEntity {
DayResponse = nextAvailability
};
await _distributedCache.SetStringAsync(bookingNextAvailabilityCachedKey, JsonConvert.SerializeObject(result), _distributedCacheExpirationConfiguration.Booking);
return(result);
}
public async Task <SuccessPageEntity> FinalisePageJourney(string form, EBehaviourType behaviourType, FormSchema baseForm)
{
var sessionGuid = _sessionHelper.GetSessionGuid();
if (string.IsNullOrEmpty(sessionGuid))
{
throw new ApplicationException("PageService::FinalisePageJourney: Session has expired");
}
var formData = _distributedCache.GetString(sessionGuid);
if (formData is null)
{
throw new ApplicationException("PageService::FinalisePageJourney: Session data is null");
}
var formAnswers = JsonConvert.DeserializeObject <FormAnswers>(formData);
var formFileUploadElements = baseForm.Pages.SelectMany(_ => _.Elements)
.Where(_ => _.Type.Equals(EElementType.FileUpload) || _.Type.Equals(EElementType.MultipleFileUpload))
.ToList();
if (formFileUploadElements.Any())
{
formFileUploadElements.ForEach(fileElement =>
{
var formFileAnswerData = formAnswers.Pages.SelectMany(_ => _.Answers).FirstOrDefault(_ => _.QuestionId.Equals($"{fileElement.Properties.QuestionId}{FileUploadConstants.SUFFIX}"))?.Response ?? string.Empty;
List <FileUploadModel> convertedFileUploadAnswer = JsonConvert.DeserializeObject <List <FileUploadModel> >(formFileAnswerData.ToString());
var fileStorageType = _configuration["FileStorageProvider:Type"];
var fileStorageProvider = _fileStorageProviders.Get(fileStorageType);
if (convertedFileUploadAnswer is not null && convertedFileUploadAnswer.Any())
{
convertedFileUploadAnswer.ForEach((_) =>
{
fileStorageProvider.Remove(_.Key);
});
}
});
}
if (baseForm.DocumentDownload)
{
await _distributedCache.SetStringAsync($"document-{sessionGuid}", JsonConvert.SerializeObject(formAnswers), _distributedCacheExpirationConfiguration.Document);
}
return(await _successPageContentFactory.Build(form, baseForm, sessionGuid, formAnswers, behaviourType));
}
private ProcessRequestEntity RemoveFile(
Dictionary <string, dynamic> viewModel,
FormSchema baseForm,
string path,
string sessionGuid)
{
var cachedAnswers = _distributedCache.GetString(sessionGuid);
var convertedAnswers = cachedAnswers is null
? new FormAnswers {
Pages = new List <PageAnswers>()
}
: JsonConvert.DeserializeObject <FormAnswers>(cachedAnswers);
var currentPageAnswers = convertedAnswers.Pages.FirstOrDefault(_ => _.PageSlug.Equals(path))?.Answers.FirstOrDefault();
List <FileUploadModel> response = JsonConvert.DeserializeObject <List <FileUploadModel> >(currentPageAnswers.Response.ToString());
var fileToRemove = response.FirstOrDefault(_ => _.TrustedOriginalFileName.Equals(viewModel[FileUploadConstants.FILE_TO_DELETE]));
response.Remove(fileToRemove);
convertedAnswers.Pages.FirstOrDefault(_ => _.PageSlug.Equals(path)).Answers.FirstOrDefault().Response = response;
_distributedCache.SetStringAsync(sessionGuid, JsonConvert.SerializeObject(convertedAnswers), CancellationToken.None);
var fileStorageType = _configuration["FileStorageProvider:Type"];
var fileStorageProvider = _fileStorageProviders.Get(fileStorageType);
fileStorageProvider.Remove(fileToRemove.Key);
return(new ProcessRequestEntity
{
RedirectToAction = true,
RedirectAction = "Index",
RouteValues = new
{
form = baseForm.BaseURL,
path
}
});
}
public async Task Process(List <IAction> actions, FormSchema formSchema, string formName)
{
var answers = new List <Answers>();
var sessionGuid = _sessionHelper.GetSessionGuid();
var mappingData = await _mappingService.Map(sessionGuid, formName);
foreach (var action in actions)
{
var response = new HttpResponseMessage();
var submitSlug = action.Properties.PageActionSlugs.FirstOrDefault(_ =>
_.Environment.ToLower().Equals(_environment.EnvironmentName.ToS3EnvPrefix().ToLower()));
if (submitSlug == null)
{
throw new ApplicationException("RetrieveExternalDataService::Process, there is no PageActionSlug defined for this environment");
}
var entity = _actionHelper.GenerateUrl(submitSlug.URL, mappingData.FormAnswers);
if (!string.IsNullOrEmpty(submitSlug.AuthToken))
{
_gateway.ChangeAuthenticationHeader(submitSlug.AuthToken);
}
if (entity.IsPost)
{
response = await _gateway.PostAsync(entity.Url, mappingData.Data);
}
else
{
response = await _gateway.GetAsync(entity.Url);
}
if (!response.IsSuccessStatusCode)
{
throw new ApplicationException($"RetrieveExternalDataService::Process, http request to {entity.Url} returned an unsuccessful status code, Response: {JsonConvert.SerializeObject(response)}");
}
if (response.Content == null)
{
throw new ApplicationException($"RetrieveExternalDataService::Process, response content from {entity.Url} is null.");
}
var content = await response.Content.ReadAsStringAsync();
if (string.IsNullOrWhiteSpace(content))
{
throw new ApplicationException($"RetrieveExternalDataService::Process, Gateway {entity.Url} responded with empty reference");
}
answers.Add(new Answers
{
QuestionId = action.Properties.TargetQuestionId,
Response = JsonConvert.DeserializeObject <string>(content)
});
}
mappingData.FormAnswers.Pages.FirstOrDefault(_ => _.PageSlug.ToLower().Equals(mappingData.FormAnswers.Path.ToLower())).Answers.AddRange(answers);
await _distributedCache.SetStringAsync(sessionGuid, JsonConvert.SerializeObject(mappingData.FormAnswers), CancellationToken.None);
}
