public async Task <string> CheckEligibleAddress(string yourAddress)
        {
            EligibleStreet eligibleStreet = await GetAddressDetails(yourAddress);

            if (eligibleStreet == null)
            {
                return(null);
            }

            if (eligibleStreet.Area.Equals(PermitConstants.DUPLICATE))
            {
                List <Option> duplicationList = new List <Option>
                {
                    new Option
                    {
                        Text  = "Duplication",
                        Value = "Duplication",
                        ConditionalElementId = "Duplication"
                    }
                };

                return(JsonSerializer.Serialize(duplicationList));
            }

            var permitList = GetPermitTypeForEligibleStreet(eligibleStreet);

            return(JsonSerializer.Serialize(permitList));
        }
        private string GetPermitText(EligibleStreet eligibleStreets, string applicationType)
        {
            if (eligibleStreets == null || eligibleStreets.Area.Equals(PermitConstants.DUPLICATE))
            {
                return(string.Empty);
            }

            StringBuilder permitText = new StringBuilder();

            if (!string.IsNullOrEmpty(applicationType))
            {
                var numberPermits = applicationType.ToLower().Contains("vis")
                ? eligibleStreets.Visitors.ToString().Replace("+", " or more")
                : eligibleStreets.Residents.Replace("+", " or more");

                var content = applicationType switch
                {
                    PermitConstants.NEW_RESIDENT_PERMIT_VALUE => $"You're allowed a total of {numberPermits} resident permits at your address.</p>",
                    PermitConstants.NEW_VISITOR_PERMIT_VALUE => $"You're allowed a total of {numberPermits} visitor permits at your address.</p>",
                    _ => string.Empty
                };

                permitText.Append(content);
                permitText.Append($"<p class='smbc-body'>When you have this permit, you can park {eligibleStreets.AmendedEntitlement}</p>");
                return(permitText.ToString());
            }

            permitText.Append($"You're allowed a total of {eligibleStreets.Residents.Replace("+", " or more")} resident permits at your address.</p><p class='smbc-body'>When you have this permit, you can park {eligibleStreets.AmendedEntitlement}</p>");

            return(permitText.ToString());
        }
        public void GetPermitTypeForEligibleStreet_ShouldReturnOneOption_NotCharageable_NoEntitlement()
        {
            //Arrange
            var eligibleStreet = new EligibleStreet
            {
                Visitors   = 1,
                Chargeable = string.Empty,
            };

            //Act
            var options = _helper.GetPermitTypeForEligibleStreet(eligibleStreet);

            var jsonOptions = JsonSerializer.Serialize(options);

            // Assert
            Assert.True(options.Count.Equals(1));
        }
        public void GetPermitTypeForEligibleStreet_ShouldReturnAllOptionForChargeableAddressWithVistorsAndResidents()
        {
            //Arrange
            var eligibleStreet = new EligibleStreet
            {
                Chargeable = "y",
                Visitors   = 1,
                Residents  = "1"
            };

            //Act
            var options = _helper.GetPermitTypeForEligibleStreet(eligibleStreet);

            var jsonOptions = JsonSerializer.Serialize(options);

            // Assert
            Assert.True(options.Count.Equals(4));
        }
        public void GetPermitTypeForEligibleStreet_ShouldReturnOptionForChargeableVisitorAddress()
        {
            //Arrange
            var eligibleStreet = new EligibleStreet
            {
                Chargeable = "y",
                Visitors   = 1
            };

            //Act
            var options = _helper.GetPermitTypeForEligibleStreet(eligibleStreet);

            var jsonOptions = JsonSerializer.Serialize(options);

            // Assert
            Assert.Contains(PermitConstants.NEW_RESIDENT_PERMIT_TEXT, jsonOptions);
            Assert.Contains(PermitConstants.NEW_RESIDENT_PERMIT_VALUE, jsonOptions);
            Assert.Contains(PermitConstants.RENEW_VISITOR_PERMIT_TEXT, jsonOptions);
            Assert.Contains(PermitConstants.RENEW_VISITOR_PERMIT_VALUE, jsonOptions);
            Assert.Contains(PermitConstants.NEW_VISITOR_PERMIT_TEXT, jsonOptions);
            Assert.Contains(PermitConstants.NEW_VISITOR_PERMIT_VALUE, jsonOptions);
        }
        public List <Option> GetPermitTypeForEligibleStreet(EligibleStreet eligibleStreet)
        {
            var options = new List <Option> {
                new Option {
                    Text = PermitConstants.NEW_RESIDENT_PERMIT_TEXT, Value = PermitConstants.NEW_RESIDENT_PERMIT_VALUE
                }
            };

            if (eligibleStreet.Chargeable.ToLower().Equals("y"))
            {
                if (eligibleStreet.Visitors > 0)
                {
                    options.AddRange(new List <Option>
                    {
                        new Option
                        {
                            Text       = PermitConstants.RENEW_VISITOR_PERMIT_TEXT,
                            Value      = PermitConstants.RENEW_VISITOR_PERMIT_VALUE,
                            Chargeable = true
                        },
                        new Option
                        {
                            Text       = PermitConstants.NEW_VISITOR_PERMIT_TEXT,
                            Value      = PermitConstants.NEW_VISITOR_PERMIT_VALUE,
                            Chargeable = true
                        }
                    });
                }

                if (!string.IsNullOrEmpty(eligibleStreet.Residents))
                {
                    if (eligibleStreet.Residents.Contains("+"))
                    {
                        options.Add(new Option
                        {
                            Text       = PermitConstants.RENEW_RESIDENT_PERMIT_TEXT,
                            Value      = PermitConstants.RENEW_RESIDENT_PERMIT_VALUE,
                            Chargeable = true
                        });
                    }
                    else
                    {
                        if (int.Parse(eligibleStreet.Residents) > 0)
                        {
                            options.Add(new Option
                            {
                                Text       = PermitConstants.RENEW_RESIDENT_PERMIT_TEXT,
                                Value      = PermitConstants.RENEW_RESIDENT_PERMIT_VALUE,
                                Chargeable = true
                            });
                        }
                    }
                }
            }
            else
            {
                if (!string.IsNullOrEmpty(eligibleStreet.Entitlement))
                {
                    if (eligibleStreet.Entitlement.Contains("P&D Car Parks"))
                    {
                        options.Add(new Option
                        {
                            Text       = PermitConstants.RENEW_RESIDENT_PERMIT_TEXT,
                            Value      = PermitConstants.RENEW_RESIDENT_PERMIT_VALUE,
                            Chargeable = false
                        });
                    }

                    if (eligibleStreet.Visitors > 0 && eligibleStreet.Entitlement.Contains("On Street"))
                    {
                        options.Add(new Option
                        {
                            Text       = PermitConstants.NEW_VISITOR_PERMIT_TEXT,
                            Value      = PermitConstants.NEW_VISITOR_PERMIT_VALUE,
                            Chargeable = false
                        });
                    }
                }
            }

            return(options.OrderBy(o => o.Text).ToList());
        }
        public async Task <string> GetPermitInformationFromAddress(string yourAddress, string applicationType)
        {
            EligibleStreet eligibleStreets = await _permitHelper.GetAddressDetails(yourAddress);

            return(GetPermitText(eligibleStreets, applicationType));
        }