public void MaxLength_LessThan()
            {
                ControlList controls = new ControlList
                                       {
                                           new TextControl
                                           {
                                               Id = 1,
                                               MaxLength = 5,
                                               Name = "MaxLengthField"
                                           }
                                       };

                ApplicationData applicationData = new ApplicationData { { "MaxLengthField", "1234" } };

                ApplicationValidator localValidator = new ApplicationValidator(controls, validatorList: this.validatorList);
                ValidationResults results = localValidator.Validate(new Application(applicationData));
                Assert.IsTrue(results.IsValid);
            }
            public void NestedControlIsValidated()
            {
                var data = new ApplicationData();
                var validator = new ApplicationValidator(this.nestedControlList, validatorList: this.validatorList);
                var row1 = data.AddRepeaterRow("OuterRepeater");
                var innerRow1 = row1.AddRepeaterRow("InnerRepeater");
                innerRow1.Add("InnerRepeaterText", string.Empty);

                var results = validator.Validate(new Application(data));
                Assert.IsFalse(results.IsValid);
            }
Exemple #3
0
        private async Task <UserPasswordInfo> GetInfoOperations(ITurnContext <IMessageActivity> turnContext, PwdResetConversationStates conversationState, UserPasswordInfo userState)
        {
            UserPasswordInfo userStateFromAdaptiveCard = JsonConvert.DeserializeObject <UserPasswordInfo>(turnContext.Activity.Value.ToString());

            // Kullanıcı adı validasyonu
            if (!UserNameValidator.Validate(userStateFromAdaptiveCard.UserName))
            {
                await turnContext.SendActivityAsync("Kullanıcı adınızı hatalı girdiniz. Lütfen bilgileri tekrar giriniz");

                userStateFromAdaptiveCard.Counter++;
                if (userStateFromAdaptiveCard.Counter < 3)
                {
                    Activity t = new Activity();
                    t.Type        = ActivityTypes.Message;
                    t.Attachments = new List <Attachment>()
                    {
                        CreateAdaptiveCardUsingJson()
                    };
                    await turnContext.SendActivityAsync(t);
                }
                else
                {
                    await turnContext.SendActivityAsync("3 kez hatalı giriş yaptınız.");

                    conversationState.CurrentState = PdwResetStates.Completed;
                }
            }
            else if (!EmailValidator.Validate(userStateFromAdaptiveCard.Email))
            {
                await turnContext.SendActivityAsync("Email bilgisini hatalı girdiniz. Lütfen bilgileri tekrar giriniz");

                userStateFromAdaptiveCard.Counter++;
                if (userStateFromAdaptiveCard.Counter < 3)
                {
                    Activity t = new Activity();
                    t.Type        = ActivityTypes.Message;
                    t.Attachments = new List <Attachment>()
                    {
                        CreateAdaptiveCardUsingJson()
                    };
                    await turnContext.SendActivityAsync(t);
                }
                else
                {
                    await turnContext.SendActivityAsync("3 kez hatalı giriş yaptınız.");

                    conversationState.CurrentState = PdwResetStates.Completed;
                }
            }
            else if (!ApplicationValidator.Validate(userStateFromAdaptiveCard.Application))
            {
                await turnContext.SendActivityAsync("Application bilgisini hatalı girdiniz. Lütfen bilgileri tekrar giriniz");

                userStateFromAdaptiveCard.Counter++;
                if (userStateFromAdaptiveCard.Counter < 3)
                {
                    Activity t = new Activity();
                    t.Type        = ActivityTypes.Message;
                    t.Attachments = new List <Attachment>()
                    {
                        CreateAdaptiveCardUsingJson()
                    };
                    await turnContext.SendActivityAsync(t);
                }
                else
                {
                    await turnContext.SendActivityAsync("3 kez hatalı giriş yaptınız.");

                    conversationState.CurrentState = PdwResetStates.Completed;
                }
            }
            else
            {
                await turnContext.SendActivityAsync($"{userStateFromAdaptiveCard.UserName} için şifreniz resetlenecektir. Onaylıyor musunuz?");

                conversationState.CurrentState = PdwResetStates.GetApproval;
            }
            return(userStateFromAdaptiveCard);
        }
            public void VisibleMandatoryRepeaterField()
            {
                var app = this.GetTestDataBaseline();
                app.ApplicationData.SetValue("Repeater[0].Repeater_child_4", string.Empty);
                app.ApplicationData.SetValue("Repeater[0].Show_radio", "Yes");
                var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
                var results = validator.Validate(app);
                Assert.IsFalse(results.IsValid);

                app.ApplicationData.SetValue("Repeater[0].Repeater_child_4", "Some value");
                results = validator.Validate(app);
                Assert.IsTrue(results.IsValid);
            }
            public void MoreThanMaximumCount()
            {
                var app = this.GetTestDataBaseline();
                List<Dictionary<string, object>> repeaterArr = new List<Dictionary<string, object>>();
                for (int i = 0; i <= 3; i++)
                {
                    repeaterArr.Add(new Dictionary<string, object>());
                    repeaterArr[i].Add("Repeater_child_1", string.Format("Item{0} Child1", i + 1));
                    repeaterArr[i].Add("Repeater_child_2", string.Empty);
                    repeaterArr[i].Add("Repeater_child_3", string.Format("Item{0} Child3", i + 1));
                }

                app.ApplicationData["Repeater"] = repeaterArr.ToArray();

                var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
                var results = validator.Validate(app);
                Assert.IsFalse(results.IsValid);
            }
            public void ValidationMessage()
            {
                ControlList list = new ControlList();
                RepeaterControl control = new RepeaterControl
                {
                    Controls = new ControlList(),
                    Id = 1,
                    Label = "Test Repeater",
                    MinimumCount = 1,
                    MaximumCount = 3,
                    Name = "Test_repeater"
                };
                list.Add(control);

                ApplicationData applicationData = new ApplicationData();
                applicationData["Test_repeater"] = new List<Dictionary<string, object>>().ToArray();

                ApplicationValidator localValidator = new ApplicationValidator(list);
                ValidationResults results = localValidator.Validate(new Application(applicationData));
                Assert.IsFalse(results.IsValid);
                Assert.AreEqual(
                    "Please add between 1 and 3 rows for 'Test Repeater'",
                    results.ToList().First().Message);
            }
            public void MandatoryRepeaterNoRows()
            {
                var app = this.GetTestDataBaseline();
                app.ApplicationData.SetValue("Repeater2", new Dictionary<string, object>[0]);

                var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
                var results = validator.Validate(app);
                Assert.IsTrue(results.IsValid);
            }
 public void LessThanMinimumCount()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["Repeater"] = new Dictionary<string, object>[0];
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
 }
 public void NullForNonMandatoryField()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["OptionalComboField"] = null;
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsTrue(results.IsValid);
 }
 public void EmptyStringForMandatoryTextField()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["MandatoryTextField"] = string.Empty;
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
     Assert.AreEqual(1, results.Count);
 }
 public void InvalidOption()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["OptionalComboField"] = "InvalidOption";
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
     Assert.AreEqual(1, results.Count);
 }
 public void NestedControlIsValidated()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData.SetValue("DateRangeField", "1999/12/31");
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
 }
 public void Baseline()
 {
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(this.GetTestDataBaseline());
     Assert.IsTrue(results.IsValid);
 }
 public void EmptyStringForOptionalRegexField()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["Telephone"] = string.Empty;
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsTrue(results.IsValid);
 }
 public void NotSubmittedForMandatoryField()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData.Remove("MandatoryTextField");
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
     Assert.AreEqual(1, results.Count);
 }
 public void InvalidValueForRegexField()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["Telephone"] = "(ab) 9999 8888";
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
     Assert.AreEqual(1, results.Count);
 }
 public void OneOptionForMandatoryCheckboxGroup()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["MandatoryCheckboxGroup"] = new[] { "Opt2" };
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsTrue(results.IsValid);
 }
            public void MaximumOnlyValidationMessage()
            {
                ControlList list = new ControlList();
                RepeaterControl control = new RepeaterControl
                {
                    Controls = new ControlList(),
                    Id = 1,
                    Label = "Test Repeater",
                    MinimumCount = null,
                    MaximumCount = 2,
                    Name = "Test_repeater"
                };
                list.Add(control);

                ApplicationData applicationData = new ApplicationData();
                List<Dictionary<string, object>> repeaterArr = new List<Dictionary<string, object>>();
                for (int i = 0; i <= 2; i++)
                {
                    repeaterArr.Add(new Dictionary<string, object>());
                }

                applicationData["Test_repeater"] = repeaterArr.ToArray();

                ApplicationValidator localValidator = new ApplicationValidator(list, validatorList: this.validatorList);
                ValidationResults results = localValidator.Validate(new Application(applicationData));
                Assert.IsFalse(results.IsValid);
                Assert.AreEqual(
                    "Please add no more than 2 rows for 'Test Repeater'",
                    results.ToList().First().Message);
            }
 public void ReadOnlyMandatoryField()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["MandatoryTextField"] = string.Empty;
     List<ControlAccess> controlsAccess = this.defaultControlsAccess;
     controlsAccess.FirstOrDefault(c => c.ControlId == 3).AccessLevel = AccessLevel.Read;
     var validator = new ApplicationValidator(this.controlList, controlsAccess: controlsAccess, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsTrue(results.IsValid);
 }
 public void NoItems()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["Repeater2"] = new object[0];
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsTrue(results.IsValid);
 }
 public void TestNullForMandatoryCheckboxGroup()
 {
     var app = this.GetTestDataBaseline();
     app.ApplicationData["MandatoryCheckboxGroup"] = null;
     var validator = new ApplicationValidator(this.controlList, validatorList: this.validatorList);
     var results = validator.Validate(app);
     Assert.IsFalse(results.IsValid);
     Assert.AreEqual(1, results.Count);
 }
            public void CurrentSubpageValidationFail()
            {
                ApplicationData data = new ApplicationData
                                           {
                                               { "User_name", string.Empty },
                                               { "Staff_name", "ABC" }
                                           };

                var subGroup = this.subpageControlList.FindRecursive<GroupControl>(x => x.Id == 1);
                var subControlList = new ControlList { subGroup };

                var validator = new ApplicationValidator(subControlList, validatorList: this.validatorList);
                var results = validator.Validate(new Application(data));

                Assert.IsFalse(results.IsValid);

                // Test other group
                data.SetValue("User_name", "ABC");
                data.SetValue("Staff_name", string.Empty);

                subGroup = this.subpageControlList.FindRecursive<GroupControl>(x => x.Id == 2);
                subControlList = new ControlList { subGroup };

                validator = new ApplicationValidator(subControlList, validatorList: this.validatorList);
                results = validator.Validate(new Application(data));

                Assert.IsFalse(results.IsValid);
            }
        /// <summary>
        /// Validates an application.
        /// </summary>
        /// <param name="application">The application to validate.</param>
        /// <param name="pagesToValidate">The pagesToValidate to validate.</param>
        /// <param name="controls">A list of all controls.</param>
        /// <param name="controlsAccess">The control access list for the current user.</param>
        /// <param name="subpageControlId">The id of the control acting as the current subpage. If <see langword="null" />, then all controls are validated.</param>
        /// <param name="product">The product object.</param>
        /// <returns>
        /// The <see cref="ValidationResults" />.
        /// </returns>
        private ValidationResults ValidateApplication(Application application, PageList pagesToValidate, ControlList controls, List<ControlAccess> controlsAccess, int? subpageControlId = null, ProductDefinition product = null)
        {
            List<ControlWithOptions> controlsWithOptions = controls.FindAllRecursive<ControlWithOptions>();

            if (controlsWithOptions.Any())
            {
                this.RegisterOptionControls(application.FormOrganisationId, true, controlsWithOptions, application.ApplicationData);
            }

            var controlList = pagesToValidate.AllControls;
            var ruleList = pagesToValidate.AllRules;

            if (subpageControlId != null)
            {
                var subpageControl = controlList.FindRecursive<GroupControl>(x => x.Id == subpageControlId);
                if (subpageControl != null)
                {
                    controlList = new ControlList { subpageControl };

                    TruthConditionList validRules = new TruthConditionList();
                    validRules.AddRange(ruleList.Where(rule => controlList.FindRecursive(x => x.Id.ToString().Equals(((ValidateTruthCondition)rule).Error.Position)) != null));

                    ruleList = validRules;
                }
            }

            ServiceEndpointList endpointList = pagesToValidate.AllExternalRuleHandlers.Count > 0 ?
                     this.DataAccess.GetServiceEndpointList() :
                     new ServiceEndpointList();

            RegexValidatorList regexValidators = this.DataAccess.GetValidatorList();

            if (product != null)
            {
                this.FillControlReferences(pagesToValidate, product.FormDefinition.Pages.AllControls);
                foreach (var referencedControls in pagesToValidate.Select(p => p.ReferencedControls))
                {
                    foreach (var control in referencedControls)
                    {
                        var exists = controls.FindRecursive(control.Name) != null;
                        if (exists)
                        {
                            continue;
                        }

                        controls.AddRange(referencedControls);
                    }
                }
            }

            ApplicationValidator validator = new ApplicationValidator(controls, controlList, controlsAccess, ruleList, pagesToValidate.AllExternalRuleHandlers, endpointList, this.endpointCommunicator, regexValidators);
            return validator.Validate(application);
        }