Esempio n. 1
0
 public IList <WasteComposition> Map(IList <WasteTypeCompositionData> source)
 {
     return(source.OrderBy(x => x.ChemicalCompositionCategory)
            .Select(item => WasteComposition.CreateWasteComposition(
                        item.Constituent,
                        Convert.ToDecimal(item.MinConcentration),
                        Convert.ToDecimal(item.MaxConcentration),
                        item.ChemicalCompositionCategory)).ToList());
 }
        private List <WasteComposition> GetWasteTypeCollection()
        {
            List <WasteComposition> wasteCompositions = new List <WasteComposition>();

            wasteCompositions.Add(WasteComposition.CreateWasteComposition("First Constituent", 1, 100, ChemicalCompositionCategory.Metals));
            wasteCompositions.Add(WasteComposition.CreateWasteComposition("Second Constituent", 2, 100, ChemicalCompositionCategory.Wood));
            wasteCompositions.Add(WasteComposition.CreateWasteComposition("Third Constituent", 3, 100, ChemicalCompositionCategory.Food));
            wasteCompositions.Add(WasteComposition.CreateWasteComposition("Fourth Constituent", 4, 100, ChemicalCompositionCategory.Textiles));
            wasteCompositions.Add(WasteComposition.CreateWasteComposition("Fifth Constituent", 5, 100, ChemicalCompositionCategory.Plastics));
            return(wasteCompositions);
        }
        public void GetWasteCompositionPercentages_DoesReturnWasteWherePercentagesHasOneZero()
        {
            var wcs = new List <WasteComposition>();
            var wc  = WasteComposition.CreateWasteComposition("One", 0, 10, ChemicalCompositionCategory.Food);

            wcs.Add(wc);

            wasteType.WasteCompositions = wcs;

            var result = formatter.GetWasteCompositionPercentages(wasteType);

            AssertExpectedCompositionPercentage("One", 10, 0, result.Single());
        }
        public void ConstructAsRdfType_AnnexMessageShown()
        {
            wasteType.ChemicalCompositionType = ChemicalComposition.RDF;
            wasteType.WasteCompositions       = new List <WasteComposition>
            {
                WasteComposition.CreateWasteComposition("test", 1, 5, ChemicalCompositionCategory.Food)
            };

            var first  = new WasteCompositionViewModel(wasteType, wasteCompositionFormatter);
            var result = new WasteCompositionViewModel(first, 7);

            Assert.Equal("See Annex 7", result.AnnexMessage);
        }
        public void GetWasteCompositionPercentages_ListWithOneItem_ReturnsExpectedResult(string constituent,
                                                                                         decimal min,
                                                                                         decimal max,
                                                                                         ChemicalCompositionCategory category)
        {
            wasteType.WasteCompositions = new List <WasteComposition>
            {
                WasteComposition.CreateWasteComposition(constituent, min, max, category)
            };

            var result = formatter.GetWasteCompositionPercentages(wasteType);

            AssertExpectedCompositionPercentage(constituent, max, min, result.Single());
        }
        public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
        {
            var allCompositions = WasteComposition.Concat(OtherCodes).ToList();

            for (var i = 0; i < WasteComposition.Count; i++)
            {
                if (IsDecimal(WasteComposition[i].MinConcentration) && IsDecimal(WasteComposition[i].MaxConcentration))
                {
                    var minConcentrationValue = Convert.ToDecimal(WasteComposition[i].MinConcentration);
                    var maxConcentrationValue = Convert.ToDecimal(WasteComposition[i].MaxConcentration);

                    if (minConcentrationValue > maxConcentrationValue)
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinShouldBeLowerThanMax,
                                                                        EnumHelper.GetDescription(WasteComposition[i].ChemicalCompositionCategory).ToLower()), new[] { "WasteComposition[" + i + "]" }));
                    }

                    if (maxConcentrationValue < 0 || maxConcentrationValue > 100)
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MaxRange,
                                                                        EnumHelper.GetDescription(WasteComposition[i].ChemicalCompositionCategory).ToLower()), new[] { "WasteComposition[" + i + "]" }));
                    }

                    if (minConcentrationValue < 0 || minConcentrationValue > 100)
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinRange,
                                                                        EnumHelper.GetDescription(WasteComposition[i].ChemicalCompositionCategory).ToLower()), new[] { "WasteComposition[" + i + "]" }));
                    }
                }

                if (string.IsNullOrEmpty(WasteComposition[i].MinConcentration) || string.IsNullOrEmpty(WasteComposition[i].MaxConcentration))
                {
                    yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinMaxRequired,
                                                                    EnumHelper.GetDescription(WasteComposition[i].ChemicalCompositionCategory).ToLower()), new[] { "WasteComposition[" + i + "]" }));
                }
                else if ((!IsDecimal(WasteComposition[i].MinConcentration) && !WasteComposition[i].MinConcentration.ToUpper().Equals(ChemicalCompositionResources.NA)) ||
                         (!IsDecimal(WasteComposition[i].MaxConcentration) && !WasteComposition[i].MaxConcentration.ToUpper().Equals(ChemicalCompositionResources.NA)))
                {
                    yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinMaxValid,
                                                                    EnumHelper.GetDescription(WasteComposition[i].ChemicalCompositionCategory).ToLower()), new[] { "WasteComposition[" + i + "]" }));
                }

                if (!string.IsNullOrEmpty(WasteComposition[i].MinConcentration) && !string.IsNullOrEmpty(WasteComposition[i].MaxConcentration))
                {
                    if ((WasteComposition[i].MinConcentration.ToUpper().Equals(ChemicalCompositionResources.NA) && !WasteComposition[i].MaxConcentration.ToUpper().Equals(ChemicalCompositionResources.NA)) ||
                        (!WasteComposition[i].MinConcentration.ToUpper().Equals(ChemicalCompositionResources.NA) && WasteComposition[i].MaxConcentration.ToUpper().Equals(ChemicalCompositionResources.NA)))
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.FieldShouldHaveNaOrValue,
                                                                        EnumHelper.GetDescription(WasteComposition[i].ChemicalCompositionCategory).ToLower()), new[] { "WasteComposition[" + i + "]" }));
                    }
                }
            }

            for (var i = 0; i < OtherCodes.Count; i++)
            {
                if (IsDecimal(OtherCodes[i].MinConcentration) && IsDecimal(OtherCodes[i].MaxConcentration))
                {
                    var minConcentrationValue = Convert.ToDecimal(OtherCodes[i].MinConcentration);
                    var maxConcentrationValue = Convert.ToDecimal(OtherCodes[i].MaxConcentration);

                    if (minConcentrationValue < 0 || minConcentrationValue > 100)
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinRange,
                                                                        EnumHelper.GetDescription(OtherCodes[i].ChemicalCompositionCategory).ToLower()), new[] { "OtherCodes[" + i + "]" }));
                    }

                    if (maxConcentrationValue < 0 || maxConcentrationValue > 100)
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MaxRange,
                                                                        EnumHelper.GetDescription(OtherCodes[i].ChemicalCompositionCategory).ToLower()), new[] { "OtherCodes[" + i + "]" }));
                    }

                    if (minConcentrationValue > maxConcentrationValue)
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinShouldBeLowerThanMax,
                                                                        EnumHelper.GetDescription(OtherCodes[i].ChemicalCompositionCategory).ToLower()), new[] { "OtherCodes[" + i + "]" }));
                    }
                }

                if (!string.IsNullOrEmpty(OtherCodes[i].Constituent) && (string.IsNullOrEmpty(OtherCodes[i].MinConcentration) || string.IsNullOrEmpty(OtherCodes[i].MaxConcentration)))
                {
                    yield return(new ValidationResult(string.Format(ChemicalCompositionResources.MinMaxRequired,
                                                                    EnumHelper.GetDescription(OtherCodes[i].ChemicalCompositionCategory).ToLower()), new[] { "OtherCodes[" + i + "]" }));
                }

                if (string.IsNullOrEmpty(OtherCodes[i].Constituent) && (!string.IsNullOrEmpty(OtherCodes[i].MinConcentration) || !string.IsNullOrEmpty(OtherCodes[i].MaxConcentration)))
                {
                    yield return(new ValidationResult(string.Format(ChemicalCompositionResources.OtherNameRequired,
                                                                    EnumHelper.GetDescription(OtherCodes[i].ChemicalCompositionCategory).ToLower()), new[] { "OtherCodes[" + i + "]" }));
                }

                if (!string.IsNullOrEmpty(OtherCodes[i].MinConcentration) && !string.IsNullOrEmpty(OtherCodes[i].MaxConcentration))
                {
                    if ((OtherCodes[i].MinConcentration.ToUpper().Equals(ChemicalCompositionResources.NA) && !OtherCodes[i].MaxConcentration.ToUpper().Equals(ChemicalCompositionResources.NA)) ||
                        (!OtherCodes[i].MinConcentration.ToUpper().Equals(ChemicalCompositionResources.NA) && OtherCodes[i].MaxConcentration.ToUpper().Equals(ChemicalCompositionResources.NA)))
                    {
                        yield return(new ValidationResult(string.Format(ChemicalCompositionResources.FieldShouldHaveNaOrValue,
                                                                        EnumHelper.GetDescription(OtherCodes[i].ChemicalCompositionCategory).ToLower()), new[] { "OtherCodes[" + i + "]" }));
                    }
                }
            }

            if (HasAnnex && !(string.IsNullOrEmpty(FurtherInformation)))
            {
                yield return(new ValidationResult(ChemicalCompositionResources.FurtherInfoValidation, new[] { "FurtherInformation" }));
            }

            var totalNas      = 0;
            var totalNotEmpty = 0;

            foreach (WasteTypeCompositionData i in allCompositions)
            {
                if (!string.IsNullOrEmpty(i.MinConcentration) && !string.IsNullOrEmpty(i.MaxConcentration))
                {
                    totalNotEmpty = totalNotEmpty + 1;

                    if (i.MinConcentration.ToUpper().Equals(ChemicalCompositionResources.NA) &&
                        i.MaxConcentration.ToUpper().Equals(ChemicalCompositionResources.NA))
                    {
                        totalNas = totalNas + 1;
                    }
                }
            }

            if (totalNas == totalNotEmpty)
            {
                yield return(new ValidationResult(ChemicalCompositionResources.WasteDataRequired));
            }
        }