Beispiel #1
0
 public void ShouldGenerateKeyForAllSchema()
 {
     var form = new FormSchema("F",
                 new TableSchema(),
                 new TableSchema { Name = "Bảng biểu quý 1" },
                 new FieldSchema(),
                 new FieldSchema { Name = "FullName" },
                 new FieldSchema { Key = "GTGT01_PL01" }
     );
     Assert.AreEqual("table_1", form[1].Key);
     Assert.AreEqual("Bng_biu_qu_1", form[2].Key);
     Assert.AreEqual("field_3", form[3].Key);
     Assert.AreEqual("FullName", form[4].Key);
     Assert.AreEqual("GTGT01_PL01", form[5].Key);
 }
Beispiel #2
0
        public void CanQueryItemByPathInContainer()
        {
            var form = new FormSchema("F",
                new GroupSchema("G1", new GroupSchema("G2", new GroupSchema("G3", new GroupSchema("G4", new GroupSchema("G5", new TableSchema("T1", new FieldSchema("F1"))))))),
                new GroupSchema("X1", new FieldSchema("F2"))
            );

            var f = form["G1", "G2", "G3", "G4", "G5", "T1", "F1"];
            Assert.IsNotNull(f);
            Assert.AreEqual("F1", f.Key);

            var fa = form["G1", "G2", "G3", "G4", "G10", "T1", "F1"];
            Assert.IsNull(fa);

            var fb = form["G1", "G2", "G3", "G4", "G5", "T1", "F10"];
            Assert.IsNull(fb);

            var x = form["X1", "F2"];
            Assert.IsNotNull(x);
            Assert.AreEqual("F2", x.Key);
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Type.Equals(EElementType.Address) || (element.Type.Equals(EElementType.Address) && !viewModel.IsInitial()))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (!element.Properties.StockportPostcode.GetValueOrDefault())
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if ((!element.Properties.StockportPostcode.HasValue || !element.Properties.StockportPostcode.Value) || !viewModel.ContainsKey($"{element.Properties.QuestionId}{AddressConstants.SEARCH_SUFFIX}"))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (string.IsNullOrEmpty(viewModel[$"{element.Properties.QuestionId}{AddressConstants.SEARCH_SUFFIX}"]) && element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var value   = viewModel[$"{element.Properties.QuestionId}{AddressConstants.SEARCH_SUFFIX}"];
            var isValid = true;

            if (!AddressConstants.STOCKPORT_POSTCODE_REGEX.Match(value).Success)
            {
                isValid = false;
            }

            return(new ValidationResult
            {
                IsValid = isValid,
                Message = isValid ? string.Empty : ValidationConstants.POSTCODE_INCORRECT_FORMAT
            });
        }
    }
}
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Properties.RestrictFutureDate || element.Type == EElementType.DatePicker)
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            var valueDay = viewModel.ContainsKey($"{element.Properties.QuestionId}-day")
                ? viewModel[$"{element.Properties.QuestionId}-day"]
                : null;

            var valueMonth = viewModel.ContainsKey($"{element.Properties.QuestionId}-month")
                ? viewModel[$"{element.Properties.QuestionId}-month"]
                : null;

            var valueYear = viewModel.ContainsKey($"{element.Properties.QuestionId}-year")
                ? viewModel[$"{element.Properties.QuestionId}-year"]
                : null;

            if (element.Properties.Optional && string.IsNullOrEmpty(valueDay) && string.IsNullOrEmpty(valueMonth) && string.IsNullOrEmpty(valueYear))
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            var isValidDate = DateTime.TryParse($"{valueDay}/{valueMonth}/{valueYear}", out _);

            if (!isValidDate)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.CustomValidationMessage) ? element.Properties.CustomValidationMessage : "Check the date and try again"
                });
            }

            var date       = DateTime.Today;
            var dateOutput = DateTime.Parse($"{valueDay}/{valueMonth}/{valueYear}");

            if (dateOutput > date)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.ValidationMessageRestrictFutureDate)
                        ? element.Properties.ValidationMessageRestrictFutureDate
                        : "Check the date and try again"
                });
            }

            return(new ValidationResult
            {
                IsValid = true,
                Message = string.Empty
            });
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Properties.RestrictPastDate || !element.Type.Equals(EElementType.DatePicker) || element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var value       = viewModel.ContainsKey(element.Properties.QuestionId) ? viewModel[element.Properties.QuestionId] : null;
            var outDate     = DateTime.Now;
            var isValidDate = DateTime.TryParse(value, out outDate);

            if (!isValidDate)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.CustomValidationMessage)
                        ? element.Properties.CustomValidationMessage
                        : "Check the date and try again"
                });
            }

            var date       = DateTime.Today;
            var dateOutput = DateTime.Parse(value);

            if (dateOutput < date && element.Properties.RestrictPastDate)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.ValidationMessageRestrictPastDate)
                        ? element.Properties.ValidationMessageRestrictPastDate
                        : "Check the date and try again"
                });
            }

            return(new ValidationResult
            {
                IsValid = true,
                Message = string.Empty
            });
        }
    }
        private async Task <string> ProcessGenuineSubmission(MappingEntity mappingEntity, string form, string sessionGuid, FormSchema baseForm, string reference)
        {
            var currentPage = mappingEntity.BaseForm.GetPage(_pageHelper, mappingEntity.FormAnswers.Path);
            var submitSlug  = currentPage.GetSubmitFormEndpoint(mappingEntity.FormAnswers, _environment.EnvironmentName.ToS3EnvPrefix());
            HttpResponseMessage response = await _submitProviders.Get(submitSlug.Type).PostAsync(mappingEntity, submitSlug);

            if (!response.IsSuccessStatusCode)
            {
                throw new ApplicationException($"SubmitService::ProcessSubmission, An exception has occurred while attempting to call {submitSlug.URL}, Gateway responded with {response.StatusCode} status code, Message: {JsonConvert.SerializeObject(response)}");
            }

            if (!baseForm.GenerateReferenceNumber && response.Content is not null)
            {
                var content = await response.Content.ReadAsStringAsync() ?? string.Empty;

                reference = JsonConvert.DeserializeObject <string>(content);
                _pageHelper.SaveCaseReference(sessionGuid, reference);
            }

            return(reference);
        }
Beispiel #7
0
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (element.Type != EElementType.Textbox)
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            if (string.IsNullOrEmpty(viewModel[element.Properties.QuestionId]) && element.Properties.Optional)
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            if ((!element.Properties.StockportPostcode.HasValue || !element.Properties.StockportPostcode.Value) || !viewModel.ContainsKey(element.Properties.QuestionId))
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            var value   = viewModel[element.Properties.QuestionId];
            var isValid = true;

            if (!AddressConstants.STOCKPORT_POSTCODE_REGEX.Match(value).Success)
            {
                isValid = false;
            }

            return(new ValidationResult
            {
                IsValid = isValid,
                Message = isValid ? string.Empty : ValidationConstants.POSTCODE_INCORRECT_FORMAT
            });
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            ValidationResult successResult = new() { IsValid = true };

            if ((!element.Type.Equals(EElementType.DatePicker) &&
                 !element.Type.Equals(EElementType.DateInput)) ||
                string.IsNullOrEmpty(element.Properties.IsDateAfterAbsolute))
            {
                return(successResult);
            }

            DateTime?dateValue = new DateTime();

            if (element.Type.Equals(EElementType.DatePicker))
            {
                dateValue = DatePicker.GetDate(viewModel, element.Properties.QuestionId);
            }

            if (element.Type.Equals(EElementType.DateInput))
            {
                dateValue = DateInput.GetDate(viewModel, element.Properties.QuestionId);
            }

            if (!dateValue.HasValue)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (!DateTime.TryParse(element.Properties.IsDateAfterAbsolute, out DateTime comparisonDateValue))
            {
                throw new FormatException("IsDateAfterAbsoluteValidator: The comparison date format was incorrect");
            }

            if (dateValue > comparisonDateValue)
            {
                return(successResult);
            }

            return(new ValidationResult {
                IsValid = false,
                Message = !string.IsNullOrEmpty(element.Properties.IsDateAfterValidationMessage)
                    ? element.Properties.IsDateAfterValidationMessage
                    : string.Format(ValidationConstants.IS_DATE_AFTER_VALIDATOR_DEFAULT, element.Properties.IsDateAfterAbsolute)
            });
        }
    }
}
Beispiel #9
0
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Type.Equals(EElementType.TimeInput))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var valueHours = viewModel.ContainsKey($"{element.Properties.QuestionId}{TimeConstants.HOURS_SUFFIX}")
                ? viewModel[$"{element.Properties.QuestionId}{TimeConstants.HOURS_SUFFIX}"]
                : null;

            var valueMinutes = viewModel.ContainsKey($"{element.Properties.QuestionId}{TimeConstants.MINUTES_SUFFIX}")
                ? viewModel[$"{element.Properties.QuestionId}{TimeConstants.MINUTES_SUFFIX}"]
                : null;

            var valueAmPm = viewModel.ContainsKey($"{element.Properties.QuestionId}{TimeConstants.AM_PM_SUFFIX}")
                ? viewModel[$"{element.Properties.QuestionId}{TimeConstants.AM_PM_SUFFIX}"]
                : null;


            if (string.IsNullOrEmpty(valueHours) && string.IsNullOrEmpty(valueMinutes) && string.IsNullOrEmpty(valueAmPm) && element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var isValid = !string.IsNullOrEmpty(valueHours) && !string.IsNullOrEmpty(valueMinutes);

            if (!isValid)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.CustomValidationMessage)
                        ? element.Properties.CustomValidationMessage
                        : "Check the time and try again"
                });
            }

            var isSelected = !string.IsNullOrEmpty(valueAmPm);

            if (!isSelected)
            {
                return(new ValidationResult
                {
                    IsValid = isSelected,
                    Message = isSelected
                        ? string.Empty
                        : !string.IsNullOrEmpty(element.Properties.CustomValidationMessageAmPm) ? element.Properties.CustomValidationMessageAmPm : "Choose AM or PM"
                });
            }

            int.TryParse(valueHours, out int hours);
            int.TryParse(valueMinutes, out int minutes);
            var isValidTime = (hours < 13 && hours > 0) && (minutes < 60 && minutes >= 0);

            return(new ValidationResult
            {
                IsValid = isValidTime,
                Message = isValidTime
                    ? string.Empty
                    : !string.IsNullOrEmpty(element.Properties.ValidationMessageInvalidTime) ? element.Properties.ValidationMessageInvalidTime : "Check the time and try again"
            });
        }
    }
}
Beispiel #10
0
        public void ContainerShouldEnsureItemKeysAreUniqueWithinAForm()
        {
            var form = new FormSchema("F",
                new GroupSchema(null,
                    new GroupSchema(null,
                        new GroupSchema(null,
                            new GroupSchema(null,
                                new TableSchema(null,
                                    new FieldSchema()
                                ),
                                new FileSchema(),
                                new FieldSchema(),
                                new ListSchema()
                            )
                        )
                    )
                ),
                new TableSchema(null,
                    new FieldSchema(),
                    new FieldSchema()
                ),
                new FieldSchema(),
                new FileSchema(),
                new ListSchema()
            );

            var nodes = form.Descendants().ToList();

            var keys = nodes.Select(x => x.Key);
            Assert.AreEqual(16, nodes.Count);
            CollectionAssert.AllItemsAreNotNull(nodes);
            CollectionAssert.AllItemsAreUnique(keys);
        }
Beispiel #11
0
        private List <dynamic> GenerateSubmissionData(string alias, out string fieldNames)
        {
            List <dynamic> resultList = new List <dynamic>();

            fieldNames = "";

            int formID = FormSchema.GetFormIDFromAlias(alias, false);

            if (formID > -1)
            {
                List <FormStorageSubmissionModel> fetchedSubmissionRecords = new List <FormStorageSubmissionModel>();
                string querySQL = "SELECT * FROM FormStorageSubmissions WHERE formID = @formID";

                string   filterValue = Request.Params["period"];
                DateTime filterDate  = DateTime.Now.Date;
                if (!string.IsNullOrEmpty(filterValue))
                {
                    int filterDays = 0;
                    int.TryParse(filterValue, out filterDays);
                    filterDate = filterDate.AddDays(filterDays * -1);
                }

                try
                {
                    if (!string.IsNullOrEmpty(filterValue))
                    {
                        querySQL += " AND datetime >= @datetime";
                        fetchedSubmissionRecords = DatabaseConnection.Query <FormStorageSubmissionModel>(querySQL, new { formID = formID, datetime = filterDate }).ToList();
                    }
                    else
                    {
                        fetchedSubmissionRecords = DatabaseConnection.Query <FormStorageSubmissionModel>(querySQL, new { formID = formID }).ToList();
                    }
                }
                catch (Exception ex)
                {
                    Log.Error("Unable to query FormStorageSubmissions table : " + ex.Message);
                    return(resultList);
                }

                // Set-up filters
                List <string> fieldList       = null;
                List <string> filterFieldList = new List <string>();
                fieldNames = WebConfigurationManager.AppSettings["FormStorage:" + alias];
                if (!string.IsNullOrEmpty(fieldNames))
                {
                    fieldList = new List <string>(fieldNames.Split(','));
                    fieldList.Add("IP");
                    fieldList.Add("datetime");
                }
                bool filterApplied = false;
                if (fieldList != null)
                {
                    foreach (string fieldName in fieldList)
                    {
                        if (Request.Params[fieldName] != null)
                        {
                            filterFieldList.Add(fieldName);
                            filterApplied = true;
                        }
                    }
                }

                foreach (FormStorageSubmissionModel currentSubmissionRecord in fetchedSubmissionRecords)
                {
                    List <FormStorageEntryModel> fetchedEntryRecords = new List <FormStorageEntryModel>();
                    querySQL = "SELECT * FROM FormStorageEntries WHERE submissionID = @submissionID";
                    try
                    {
                        fetchedEntryRecords = DatabaseConnection.Query <FormStorageEntryModel>(querySQL, new { submissionID = currentSubmissionRecord.SubmissionID }).ToList();
                    }
                    catch (Exception ex)
                    {
                        Log.Error("Unable to query FormStorageEntries table : " + ex.Message);
                        return(resultList);
                    }

                    var currentRecord = new ExpandoObject() as IDictionary <string, Object>;
                    currentRecord.Add("submissionID", currentSubmissionRecord.SubmissionID);
                    currentRecord.Add("datetime", currentSubmissionRecord.Datetime);
                    currentRecord.Add("IP", currentSubmissionRecord.IP);
                    foreach (FormStorageEntryModel formStorageEntry in fetchedEntryRecords)
                    {
                        currentRecord.Add(formStorageEntry.FieldAlias, formStorageEntry.Value);
                    }

                    // Apply filters...
                    bool filteredOut = false;
                    if (filterApplied)
                    {
                        foreach (string fieldName in filterFieldList)
                        {
                            if (((IDictionary <string, Object>)currentRecord).ContainsKey(fieldName))
                            {
                                filterValue = Request.Params[fieldName];
                                if (!currentRecord[fieldName].ToString().ToUpper().Contains(filterValue.ToUpper()))
                                {
                                    filteredOut = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (!filteredOut)
                    {
                        resultList.Add(currentRecord);
                    }
                }
                resultList = HandleListSorting(resultList);
            }
            return(resultList);
        }
Beispiel #12
0
 public void Validate(Dictionary <string, dynamic> viewModel, IEnumerable <IElementValidator> validators, FormSchema baseForm)
 {
     foreach (var validator in validators)
     {
         var result = validator.Validate(this, viewModel, baseForm);
         if (!result.IsValid)
         {
             validationResult = result;
             return;
         }
     }
 }
        private async Task <ProcessRequestEntity> ProccessInitialOrganisation(
            Dictionary <string, dynamic> viewModel,
            Page currentPage,
            FormSchema baseForm,
            string guid,
            string path)
        {
            var cachedAnswers       = _distributedCache.GetString(guid);
            var organisationElement = currentPage.Elements.FirstOrDefault(_ => _.Type.Equals(EElementType.Organisation));

            var convertedAnswers = cachedAnswers is null
                        ? new FormAnswers {
                Pages = new List <PageAnswers>()
            }
                        : JsonConvert.DeserializeObject <FormAnswers>(cachedAnswers);

            var organisation = (string)viewModel[$"{organisationElement.Properties.QuestionId}"];

            if (currentPage.IsValid && organisationElement.Properties.Optional && string.IsNullOrEmpty(organisation))
            {
                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);

                return(new ProcessRequestEntity
                {
                    Page = currentPage
                });
            }

            if (!currentPage.IsValid)
            {
                var formModel = await _pageFactory.Build(currentPage, viewModel, baseForm, guid, convertedAnswers);

                formModel.Path           = currentPage.PageSlug;
                formModel.FormName       = baseForm.FormName;
                formModel.PageTitle      = currentPage.Title;
                formModel.HideBackButton = currentPage.HideBackButton;

                return(new ProcessRequestEntity
                {
                    Page = currentPage,
                    ViewModel = formModel
                });
            }

            var foundOrganisationSearchTerm = convertedAnswers
                                              .Pages.FirstOrDefault(_ => _.PageSlug.Equals(path))?
                                              .Answers?.FirstOrDefault(_ => _.QuestionId.Equals(organisationElement.Properties.QuestionId))?
                                              .Response;

            List <object> searchResults;

            if (organisation.Equals(foundOrganisationSearchTerm))
            {
                searchResults = (convertedAnswers.FormData[$"{path}{LookUpConstants.SearchResultsKeyPostFix}"] as IEnumerable <object>).ToList();
            }
            else
            {
                try
                {
                    searchResults = (await _organisationProviders.Get(organisationElement.Properties.OrganisationProvider).SearchAsync(organisation)).ToList <object>();
                }
                catch (Exception e)
                {
                    throw new ApplicationException($"OrganisationService.ProcessInitialOrganisation:: An exception has occurred while attempting to perform organisation lookup, Exception: {e.Message}");
                }

                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);
                _pageHelper.SaveFormData($"{path}{LookUpConstants.SearchResultsKeyPostFix}", searchResults, guid, baseForm.BaseURL);
            }

            return(new ProcessRequestEntity
            {
                RedirectToAction = true,
                RedirectAction = "Index",
                RouteValues = new
                {
                    form = baseForm.BaseURL,
                    path,
                    subPath = LookUpConstants.Automatic
                }
            });
        }
        public async Task <ProcessRequestEntity> ProcessOrganisation(Dictionary <string, dynamic> viewModel, Page currentPage, FormSchema baseForm, string guid, string path)
        {
            viewModel.TryGetValue(LookUpConstants.SubPathViewModelKey, out var subPath);

            switch (subPath as string)
            {
            case LookUpConstants.Automatic:
                return(await ProccessAutomaticOrganisation(viewModel, currentPage, baseForm, guid, path));

            default:
                return(await ProccessInitialOrganisation(viewModel, currentPage, baseForm, guid, path));
            }
        }
Beispiel #15
0
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (element.Type != EElementType.Street || (element.Type == EElementType.Street && !viewModel.IsInitial()))
            {
                return(new ValidationResult {
                    IsValid = true
                });
            }

            var streetElement = (Street)element;

            if (!viewModel.ContainsKey(streetElement.StreetSearchQuestionId))
            {
                return(new ValidationResult {
                    IsValid = true
                });
            }

            if (string.IsNullOrEmpty(viewModel[streetElement.StreetSearchQuestionId]) && element.Properties.Optional)
            {
                return(new ValidationResult {
                    IsValid = true
                });
            }

            var value   = viewModel[streetElement.StreetSearchQuestionId];
            var isValid = true;

            if (!StreetConstants.STREET_REGEX.Match(value).Success)
            {
                isValid = false;
            }

            return(new ValidationResult {
                IsValid = isValid,
                Message = isValid ? string.Empty : ValidationConstants.STREET_INCORRECT_FORMAT
            });
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (element.Type != Enum.EElementType.Address)
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            var addressElement = (Address)element;

            if (!viewModel.ContainsKey(addressElement.AddressSelectQuestionId))
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            var value = viewModel[addressElement.AddressSelectQuestionId];

            if (addressElement.Properties.Optional && string.IsNullOrEmpty(value))
            {
                return(new ValidationResult
                {
                    IsValid = true
                });
            }

            var isValid = AddressConstants.UPRN_REGEX.IsMatch(value);

            return(new ValidationResult
            {
                IsValid = isValid,
                Message = isValid ? string.Empty : $"please select an address"
            });
        }
Beispiel #17
0
        private async Task <ProcessRequestEntity> ProcessSearchAddress(
            Dictionary <string, dynamic> viewModel,
            Page currentPage,
            FormSchema baseForm,
            string guid,
            string path)
        {
            var cachedAnswers = _distributedCache.GetString(guid);

            var convertedAnswers = cachedAnswers == null
                ? new FormAnswers {
                Pages = new List <PageAnswers>()
            }
                : JsonConvert.DeserializeObject <FormAnswers>(cachedAnswers);

            var addressElement = currentPage.Elements.Where(_ => _.Type == EElementType.Address).FirstOrDefault();

            if (!currentPage.IsValid)
            {
                var formModel = await _pageFactory.Build(currentPage, viewModel, baseForm, guid, convertedAnswers, null);

                return(new ProcessRequestEntity
                {
                    Page = currentPage,
                    ViewModel = formModel
                });
            }

            var postcode = (string)viewModel[$"{addressElement.Properties.QuestionId}{AddressConstants.SEARCH_SUFFIX}"];

            if (addressElement.Properties.Optional && string.IsNullOrEmpty(postcode))
            {
                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);
                return(new ProcessRequestEntity
                {
                    Page = currentPage
                });
            }

            var foundPostCode = convertedAnswers
                                .Pages.FirstOrDefault(_ => _.PageSlug.Equals(path))?
                                .Answers?.FirstOrDefault(_ => _.QuestionId == $"{addressElement.Properties.QuestionId}{AddressConstants.SEARCH_SUFFIX}")?
                                .Response;

            var addressResults = new List <object>();

            if (postcode.Equals(foundPostCode))
            {
                addressResults = (convertedAnswers.FormData[$"{path}{LookUpConstants.SearchResultsKeyPostFix}"] as IEnumerable <object>).ToList();
            }
            else
            {
                try
                {
                    addressResults = (await _addressProviders.Get(addressElement.Properties.AddressProvider).SearchAsync(postcode)).ToList <object>();
                }
                catch (Exception e)
                {
                    throw new ApplicationException($"AddressService::ProcessSearchAddress, An exception has occured while attempting to perform postcode lookup on Provider '{addressElement.Properties.AddressProvider}' with searchterm '{postcode}' Exception:", e);
                }

                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);
                _pageHelper.SaveFormData($"{path}{LookUpConstants.SearchResultsKeyPostFix}", addressResults, guid, baseForm.BaseURL);
            }

            if (!addressResults.Any() && !addressElement.Properties.DisableManualAddress)
            {
                return(new ProcessRequestEntity
                {
                    RedirectToAction = true,
                    RedirectAction = "Index",
                    RouteValues = new
                    {
                        form = baseForm.BaseURL,
                        path,
                        subPath = LookUpConstants.Manual
                    }
                });
            }

            return(new ProcessRequestEntity
            {
                RedirectToAction = true,
                RedirectAction = "Index",
                RouteValues = new
                {
                    form = baseForm.BaseURL,
                    path,
                    subPath = LookUpConstants.Automatic
                }
            });
        }
Beispiel #18
0
        public void ListsItemSchemaReflectsTheListItself()
        {
            var form = new FormSchema("F1", new ListSchema("abc", DataType.Guid) {ItemFormat = "N"});

            var list = form["abc"] as ListSchema;

            var itemSchema = list.GetItemSchema();

            Assert.AreEqual("abc", itemSchema.Key);
            Assert.AreEqual(DataType.Guid, itemSchema.DataType);
            Assert.AreEqual("N", itemSchema.DataFormat);
            Assert.AreEqual(form, itemSchema.Parent);
        }
Beispiel #19
0
        private async Task <ProcessRequestEntity> ProcessAutomaticAddress(
            Dictionary <string, dynamic> viewModel,
            Page currentPage,
            FormSchema baseForm,
            string guid,
            string path)
        {
            var cachedAnswers = _distributedCache.GetString(guid);

            var convertedAnswers = cachedAnswers == null
                ? new FormAnswers {
                Pages = new List <PageAnswers>()
            }
                : JsonConvert.DeserializeObject <FormAnswers>(cachedAnswers);

            var addressElement = currentPage.Elements.FirstOrDefault(_ => _.Type == EElementType.Address);

            var postcode = (string)convertedAnswers
                           .Pages
                           .FirstOrDefault(_ => _.PageSlug == path)
                           .Answers
                           .FirstOrDefault(_ => _.QuestionId == $"{addressElement.Properties.QuestionId}{AddressConstants.SEARCH_SUFFIX}")
                           .Response;

            var address = (string)viewModel[$"{addressElement.Properties.QuestionId}{AddressConstants.SELECT_SUFFIX}"];

            if (currentPage.IsValid && addressElement.Properties.Optional && string.IsNullOrEmpty(postcode))
            {
                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);
                return(new ProcessRequestEntity
                {
                    Page = currentPage
                });
            }

            if (currentPage.IsValid && addressElement.Properties.Optional && string.IsNullOrEmpty(address) && !string.IsNullOrEmpty(postcode))
            {
                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);
                return(new ProcessRequestEntity
                {
                    Page = currentPage
                });
            }

            if (!currentPage.IsValid)
            {
                var cachedSearchResults = convertedAnswers.FormData[$"{path}{LookUpConstants.SearchResultsKeyPostFix}"] as IEnumerable <object>;

                var model = await _pageFactory.Build(currentPage, viewModel, baseForm, guid, convertedAnswers, cachedSearchResults.ToList());

                return(new ProcessRequestEntity
                {
                    Page = currentPage,
                    ViewModel = model
                });
            }

            _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, null, currentPage.IsValid);

            return(new ProcessRequestEntity
            {
                Page = currentPage
            });
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Type.Equals(EElementType.Booking) ||
                (element.Type.Equals(EElementType.Booking) && viewModel.IsCheckYourBooking()))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var bookingElement = (Booking)element;

            var containsBookingDate      = viewModel.ContainsKey(bookingElement.DateQuestionId);
            var containsBookingStartTime = viewModel.ContainsKey(bookingElement.StartTimeQuestionId);

            if (!containsBookingDate && !containsBookingStartTime && element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (!containsBookingDate)
            {
                return(new ValidationResult
                {
                    Message = ValidationMessage(containsBookingDate, containsBookingStartTime, element.Properties.CustomValidationMessage),
                    IsValid = false
                });
            }

            var date        = viewModel[bookingElement.DateQuestionId];
            var isValidDate = DateTime.TryParse(date, out DateTime dateValue);

            if (!isValidDate)
            {
                return(new ValidationResult
                {
                    Message = ValidationMessage(isValidDate, containsBookingStartTime, element.Properties.CustomValidationMessage),
                    IsValid = false
                });
            }

            return(VerifyStartAndEndTime(bookingElement, viewModel, (containsBookingDate && isValidDate)));
        }
Beispiel #21
0
        public string GetFormData(string json)
        {
            dynamic jsonObj = Newtonsoft.Json.JsonConvert.DeserializeObject(json);

            var formId = Convert.ToInt32(jsonObj["FormId"]);

            FormSchema  formSchema  = DataService.GetFormSchema(formId);
            TableSchema tableSchema = DataService.GetTableSchema(formSchema.AppDatabaseId, formSchema.TableName);

            // generate sql statement
            List <SqlParameter> sqlParameters = new List <SqlParameter>();

            StringBuilder sb = new StringBuilder();

            sb.Append("FROM " + formSchema.TableName + " WHERE ");

            // primary keys
            var isNewRecord = false;

            foreach (var key in tableSchema.PrimaryKeys)
            {
                if (jsonObj[key.ColumnName] != null)
                {
                    var keyValue = jsonObj[key.ColumnName].ToString();
                    if (keyValue == "" || keyValue == "0")
                    {
                        isNewRecord = true;
                        break;
                    }

                    sb.Append(key.ColumnName + "= @" + key.ColumnName + " AND ");

                    sqlParameters.Add(new SqlParameter("@" + key.ColumnName, keyValue));
                }
                else
                {
                    isNewRecord = true;
                }
            }

            if (isNewRecord)  // get empty template with defaults
            {
                var defaultValue = "";
                sb.Clear();
                sb.Append("[ { ");
                foreach (var column in tableSchema.Columns)
                {
                    defaultValue = column.DefaultValue;
                    if (defaultValue == "getdate")
                    {
                        defaultValue = DateTime.Now.ToString();
                    }
                    sb.Append("\"" + column.ColumnName + "\":\"" + defaultValue + "\", ");
                }
                json = sb.ToString() + " \"IsNewRecord\": \"" + isNewRecord + "\" } ]";
            }
            else
            {
                var sql = sb.ToString();
                sql = "SELECT 'False' AS IsNewRecord, * " + sql.Substring(0, sql.Length - 4);

                json = HelperService.GetJsonData(formSchema.AppDatabaseId, sql, sqlParameters.ToArray());
            }


            return(json);
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Properties.Numeric || !viewModel.ContainsKey(element.Properties.QuestionId))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var value = viewModel[element.Properties.QuestionId];

            if (string.IsNullOrEmpty(value) && element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var isValid = int.TryParse(value, out int output);

            if (!isValid)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.NotAnIntegerValidationMessage) ? element.Properties.NotAnIntegerValidationMessage : $"{element.Properties.Label} must be a whole number"
                });
            }

            if (value.Length > element.Properties.MaxLength)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = $"{element.Properties.Label} must be {element.Properties.MaxLength} digits or less"
                });
            }

            if (!string.IsNullOrEmpty(element.Properties.Max) && !string.IsNullOrEmpty(element.Properties.Min))
            {
                var max = int.Parse(element.Properties.Max);
                var min = int.Parse(element.Properties.Min);

                if (output > max || output < min)
                {
                    return(new ValidationResult
                    {
                        IsValid = false,
                        Message = !string.IsNullOrEmpty(element.Properties.UpperLimitValidationMessage)
                            ? element.Properties.UpperLimitValidationMessage
                            : $"{ element.Properties.Label} must be between {min} and {max} inclusive"
                    });
                }
            }

            if (!string.IsNullOrEmpty(element.Properties.Max))
            {
                var max = int.Parse(element.Properties.Max);

                if (output > max)
                {
                    return(new ValidationResult
                    {
                        IsValid = false,
                        Message = $"{element.Properties.Label} must be less than or equal to {max}"
                    });
                }
            }

            if (!string.IsNullOrEmpty(element.Properties.Min))
            {
                var min = int.Parse(element.Properties.Min);
                if (output < min)
                {
                    return(new ValidationResult
                    {
                        IsValid = false,
                        Message = $"{element.Properties.Label} must be greater than or equal to {min}"
                    });
                }
            }

            return(new ValidationResult {
                IsValid = true
            });
        }
    }
}
Beispiel #23
0
        public MappingEntityBuilder WithBaseForm(FormSchema baseForm)
        {
            _baseForm = baseForm;

            return(this);
        }
Beispiel #24
0
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Type.Equals(EElementType.DatePicker) || !viewModel.ContainsKey(element.Properties.QuestionId))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var date = viewModel[element.Properties.QuestionId];

            var isValid = !string.IsNullOrEmpty(date);

            if (!isValid && element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (!isValid && !element.Properties.Optional)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.CustomValidationMessage) ? element.Properties.CustomValidationMessage : ValidationConstants.DatePickerDefault
                });
            }

            var isValidDate = DateTime.TryParse(date, out DateTime dateValue);
            var todaysDate  = DateTime.Now;
            var maxDate     = string.IsNullOrEmpty(element.Properties.Max) ? todaysDate.AddYears(100) : new DateTime(int.Parse(element.Properties.Max), todaysDate.Month, todaysDate.Day);

            if (dateValue > maxDate)
            {
                return(new ValidationResult
                {
                    IsValid = false,
                    Message = !string.IsNullOrEmpty(element.Properties.UpperLimitValidationMessage) ? element.Properties.UpperLimitValidationMessage : ValidationConstants.DatePickerDefault
                });
            }

            return(new ValidationResult
            {
                IsValid = isValidDate,
                Message = isValidDate ? string.Empty : !string.IsNullOrEmpty(element.Properties.ValidationMessageInvalidDate) ? element.Properties.ValidationMessageInvalidDate : ValidationConstants.DatePickerDefault
            });
        }
    }
}
        private async Task <ProcessRequestEntity> ProcessSelectedFiles(
            Dictionary <string, dynamic> viewModel,
            Page currentPage,
            FormSchema baseForm,
            string guid,
            string path,
            IEnumerable <CustomFormFile> files,
            bool modelStateIsValid)
        {
            if (!currentPage.IsValid)
            {
                var formModel = await _pageFactory.Build(currentPage, new Dictionary <string, dynamic>(), baseForm, guid);

                return(new ProcessRequestEntity
                {
                    Page = currentPage,
                    ViewModel = formModel
                });
            }

            if (currentPage.IsValid && viewModel.ContainsKey(ButtonConstants.SUBMIT) && (files == null || !files.Any()) && modelStateIsValid)
            {
                if (currentPage.Elements.Where(_ => _.Type.Equals(EElementType.MultipleFileUpload)).Any(_ => _.Properties.Optional))
                {
                    _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, files, currentPage.IsValid, true);
                }

                return(new ProcessRequestEntity
                {
                    Page = currentPage
                });
            }

            if (!viewModel.ContainsKey(ButtonConstants.SUBMIT) && (files == null || !files.Any()))
            {
                return(new ProcessRequestEntity
                {
                    RedirectToAction = true,
                    RedirectAction = "Index",
                    RouteValues = new
                    {
                        form = baseForm.BaseURL,
                        path
                    }
                });
            }

            if (files != null && files.Any())
            {
                _pageHelper.SaveAnswers(viewModel, guid, baseForm.BaseURL, files, currentPage.IsValid, true);
            }

            if (viewModel.ContainsKey(ButtonConstants.SUBMIT) && modelStateIsValid)
            {
                return(new ProcessRequestEntity
                {
                    Page = currentPage
                });
            }

            if (!modelStateIsValid)
            {
                var newViewModel = new Dictionary <string, dynamic>();
                newViewModel.Add("modelStateInvalid", null);

                var formModel = await _pageFactory.Build(currentPage, newViewModel, baseForm, guid);

                return(new ProcessRequestEntity
                {
                    Page = currentPage,
                    ViewModel = formModel,
                    UseGeneratedViewModel = true
                });
            }

            return(new ProcessRequestEntity
            {
                RedirectToAction = true,
                RedirectAction = "Index",
                RouteValues = new
                {
                    form = baseForm.BaseURL,
                    path
                }
            });
        }
Beispiel #26
0
        public IntegrityCheckResult Validate(FormSchema schema)
        {
            IntegrityCheckResult result = new();

            List <IElement> elements = schema.Pages
                                       .SelectMany(page => page.Elements)
                                       .Where(element => !string.IsNullOrEmpty(element.Lookup) &&
                                              element.Lookup.Equals(LookUpConstants.Dynamic))
                                       .ToList();

            if (elements.Count.Equals(0))
            {
                return(result);
            }

            foreach (var element in elements)
            {
                if (element.Properties.LookupSources is null || !element.Properties.LookupSources.Any())
                {
                    result.AddFailureMessage($"Dynamic Lookup Check, dynamic lookup with questionId {element.Properties.QuestionId} requires a LookupSource");
                    return(result);
                }

                if (!element.Properties.LookupSources
                    .Any(lookup => lookup.EnvironmentName
                         .Equals(_environment.EnvironmentName, StringComparison.OrdinalIgnoreCase)))
                {
                    result.AddFailureMessage($"The provided json has no Environment details for this:({_environment.EnvironmentName}) Environment");
                }

                foreach (var env in element.Properties.LookupSources)
                {
                    if (string.IsNullOrEmpty(env.EnvironmentName))
                    {
                        result.AddFailureMessage($"The provided json has no Environment Name");
                    }

                    if (string.IsNullOrEmpty(env.Provider))
                    {
                        result.AddFailureMessage($"The provided json has no Provider Name");
                    }

                    try
                    {
                        _lookupProviders.Get(env.Provider);
                    }
                    catch (Exception e)
                    {
                        result.AddFailureMessage($"No specified Providers in form. Error Message {e.Message}");
                    }

                    if (string.IsNullOrEmpty(env.URL))
                    {
                        result.AddFailureMessage($"The provided json has no API URL to submit to");
                    }

                    if (string.IsNullOrEmpty(env.AuthToken))
                    {
                        result.AddFailureMessage($"The provided json has no auth token for the API");
                    }

                    if (!_environment.IsEnvironment("local") &&
                        !env.EnvironmentName.Equals("local", StringComparison.OrdinalIgnoreCase) &&
                        !env.URL.StartsWith("https://"))
                    {
                        result.AddFailureMessage($"SubmitUrl must start with https, in form.");
                    }
                }
            }

            return(result);
        }
Beispiel #27
0
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Type.Equals(EElementType.FileUpload) && !element.Type.Equals(EElementType.MultipleFileUpload))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var key = $"{element.Properties.QuestionId}{FileUploadConstants.SUFFIX}";

            if (!viewModel.ContainsKey(key))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            List <DocumentModel> documentModel = viewModel[key];

            if (documentModel is null)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var allowedFileTypes = element.Properties.AllowedFileTypes ?? SystemConstants.AcceptedMimeTypes;

            var fileTypes = documentModel.Select(_ => new MimeTypeFile {
                FileType = Convert.FromBase64String(_.Content).GetFileType(), File = _
            });
            var invalidFiles = new List <MimeTypeFile>();

            if (fileTypes is not null)
            {
                var availableFileTypes = fileTypes.Where(_ => _ is not null && _.FileType is not null);

                var unknownFileTypes = fileTypes.Where(_ => _ is not null && _.FileType is null);

                if (unknownFileTypes.Any())
                {
                    invalidFiles.AddRange(unknownFileTypes.ToList());
                }

                invalidFiles.AddRange(availableFileTypes.Where(_ => !allowedFileTypes.Contains($".{_.FileType.Extension}")).ToList());
                if (!invalidFiles.Any())
                {
                    return new ValidationResult {
                               IsValid = true
                    }
                }
                ;
            }

            return(element.Type.Equals(EElementType.FileUpload)
               ? SingleFileUpload(allowedFileTypes, documentModel)
               : MultiFileUpload(allowedFileTypes, invalidFiles, documentModel));
        }
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Type.Equals(EElementType.MultipleFileUpload))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (element.Properties.Optional && viewModel.ContainsKey(ButtonConstants.SUBMIT))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var key     = $"{ element.Properties.QuestionId}{FileUploadConstants.SUFFIX}";
            var isValid = false;

            List <DocumentModel> value = viewModel.ContainsKey(key)
                ? viewModel[key]
                : null;

            isValid = !(value is null);

            if (value is null)
            {
                var sessionGuid = _sessionHelper.GetSessionGuid();

                var cachedAnswers = _distributedCache.GetString(sessionGuid);

                var convertedAnswers = cachedAnswers is null
                    ? new FormAnswers {
                    Pages = new List <PageAnswers>()
                }
                    : JsonConvert.DeserializeObject <FormAnswers>(cachedAnswers);

                var path = viewModel.FirstOrDefault(_ => _.Key.Equals("Path")).Value;

                var pageAnswersString = convertedAnswers.Pages.FirstOrDefault(_ => _.PageSlug.Equals(path))?.Answers.FirstOrDefault(_ => _.QuestionId.Equals(key));
                var response          = new List <FileUploadModel>();
                if (pageAnswersString is not null)
                {
                    response = JsonConvert.DeserializeObject <List <FileUploadModel> >(pageAnswersString.Response.ToString());

                    if (response.Any())
                    {
                        isValid = true;
                    }
                }
            }

            return(new ValidationResult
            {
                IsValid = isValid,
                Message = ValidationConstants.FILEUPLOAD_EMPTY
            });
        }
    }
}
        public void GetReducedAnswers_ShouldRemoveUnusedPage()
        {
            // Arrange
            var formAnswers = new FormAnswers
            {
                Pages = new List <PageAnswers>
                {
                    new PageAnswers
                    {
                        Answers  = new List <Answers>(),
                        PageSlug = "page-1"
                    },
                    new PageAnswers
                    {
                        Answers  = new List <Answers>(),
                        PageSlug = "page-2"
                    },
                    new PageAnswers
                    {
                        Answers  = new List <Answers>(),
                        PageSlug = "page-3"
                    }
                }
            };

            var formSchema = new FormSchema
            {
                Pages = new List <Page>
                {
                    new Page
                    {
                        PageSlug   = "page-1",
                        Behaviours = new List <Behaviour>
                        {
                            new Behaviour
                            {
                                BehaviourType = EBehaviourType.GoToPage,
                                PageSlug      = "page-3"
                            }
                        }
                    },
                    new Page
                    {
                        PageSlug   = "page-2",
                        Behaviours = new List <Behaviour>
                        {
                            new Behaviour
                            {
                                BehaviourType = EBehaviourType.GoToPage,
                                PageSlug      = "page-3"
                            }
                        }
                    },
                    new Page
                    {
                        PageSlug   = "page-3",
                        Behaviours = new List <Behaviour>
                        {
                            new Behaviour
                            {
                                BehaviourType = EBehaviourType.SubmitForm
                            }
                        }
                    }
                },
                FirstPageSlug = "page-1"
            };

            // Act
            var result = formAnswers.GetReducedAnswers(formSchema);

            // Assert
            Assert.Equal(2, result.Count);
        }
Beispiel #30
0
 public async Task <IntegrityCheckResult> ValidateAsync(FormSchema schema) => await Task.Run(() => Validate(schema));
Beispiel #31
0
        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 == null)
            {
                throw new ApplicationException("PageService::FinalisePageJourney: Session data is null");
            }

            var formAnswers = JsonConvert.DeserializeObject <FormAnswers>(formData);

            var formFileUploadElements = baseForm.Pages.SelectMany(_ => _.Elements)
                                         .Where(_ => _.Type == EElementType.FileUpload || _.Type == EElementType.MultipleFileUpload)
                                         .ToList();

            if (formFileUploadElements.Any())
            {
                formFileUploadElements.ForEach(fileElement =>
                {
                    var formFileAnswerData = formAnswers.Pages.SelectMany(_ => _.Answers).FirstOrDefault(_ => _.QuestionId == $"{fileElement.Properties.QuestionId}{FileUploadConstants.SUFFIX}")?.Response ?? string.Empty;
                    List <FileUploadModel> convertedFileUploadAnswer = JsonConvert.DeserializeObject <List <FileUploadModel> >(formFileAnswerData.ToString());

                    if (convertedFileUploadAnswer != null && convertedFileUploadAnswer.Any())
                    {
                        convertedFileUploadAnswer.ForEach((_) =>
                        {
                            _distributedCache.Remove(_.Key);
                        });
                    }
                });
            }

            if (baseForm.DocumentDownload)
            {
                await _distributedCache.SetStringAsync($"document-{sessionGuid}", JsonConvert.SerializeObject(formAnswers), _distributedCacheExpirationConfiguration.Document);
            }

            return(await _successPageContentFactory.Build(form, baseForm, sessionGuid, formAnswers, behaviourType));
        }
        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);
        }
Beispiel #33
0
        public ValidationResult Validate(Element element, Dictionary <string, dynamic> viewModel, FormSchema baseForm)
        {
            if (!element.Properties.Email.GetValueOrDefault())
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (string.IsNullOrEmpty(viewModel[element.Properties.QuestionId]) && element.Properties.Optional)
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            if (!element.Properties.Email.HasValue || !element.Properties.Email.Value || !viewModel.ContainsKey(element.Properties.QuestionId))
            {
                return new ValidationResult {
                           IsValid = true
                }
            }
            ;

            var   value   = viewModel[element.Properties.QuestionId];
            var   isValid = true;
            var   regex   = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w)+)+)$");
            Match match   = regex.Match(value);

            if (!match.Success)
            {
                isValid = false;
            }

            return(new ValidationResult
            {
                IsValid = isValid,
                Message = ValidationConstants.EMAIL_INCORRECT_FORMAT
            });
        }
    }
}
Beispiel #34
0
 public void FormSchemaCanAcceptOnlyCertainNodeType(Type nodeType, int expectedCount)
 {
     var schema = new FormSchema("X", Activator.CreateInstance(nodeType) as NodeSchema);
     Assert.AreEqual(expectedCount, schema.Count);
 }
Beispiel #35
0
        public async Task <ProcessRequestEntity> ProcessRequest(
            string form,
            string path,
            Dictionary <string, dynamic> viewModel,
            IEnumerable <CustomFormFile> files,
            bool modelStateIsValid)
        {
            FormSchema baseForm = await _schemaFactory.Build(form);

            if (!baseForm.IsAvailable(_environment.EnvironmentName))
            {
                throw new ApplicationException($"Form: {form} is not available in this Environment: {_environment.EnvironmentName.ToS3EnvPrefix()}");
            }

            var currentPage = baseForm.GetPage(_pageHelper, path);

            var sessionGuid = _sessionHelper.GetSessionGuid();

            if (sessionGuid == null)
            {
                throw new NullReferenceException($"Session guid null.");
            }

            if (currentPage == null)
            {
                throw new NullReferenceException($"Current page '{path}' object could not be found.");
            }

            if (currentPage.HasIncomingPostValues)
            {
                viewModel = _incomingDataHelper.AddIncomingFormDataValues(currentPage, viewModel);
            }

            currentPage.Validate(viewModel, _validators, baseForm);

            if (currentPage.Elements.Any(_ => _.Type == EElementType.Address))
            {
                return(await _addressService.ProcessAddress(viewModel, currentPage, baseForm, sessionGuid, path));
            }

            if (currentPage.Elements.Any(_ => _.Type == EElementType.Street))
            {
                return(await _streetService.ProcessStreet(viewModel, currentPage, baseForm, sessionGuid, path));
            }

            if (currentPage.Elements.Any(_ => _.Type == EElementType.Organisation))
            {
                return(await _organisationService.ProcessOrganisation(viewModel, currentPage, baseForm, sessionGuid, path));
            }

            if (currentPage.Elements.Any(_ => _.Type == EElementType.MultipleFileUpload))
            {
                return(await _fileUploadService.ProcessFile(viewModel, currentPage, baseForm, sessionGuid, path, files, modelStateIsValid));
            }

            if (currentPage.Elements.Any(_ => _.Type == EElementType.Booking))
            {
                return(await _bookingService.ProcessBooking(viewModel, currentPage, baseForm, sessionGuid, path));
            }

            _pageHelper.SaveAnswers(viewModel, sessionGuid, baseForm.BaseURL, files, currentPage.IsValid);

            if (!currentPage.IsValid)
            {
                var formModel = await _pageContentFactory.Build(currentPage, viewModel, baseForm, sessionGuid);

                return(new ProcessRequestEntity
                {
                    Page = currentPage,
                    ViewModel = formModel
                });
            }

            return(new ProcessRequestEntity
            {
                Page = currentPage
            });
        }