public AppliedStoredManure GetAppliedManureFromStorageSystem(YearData yearData, ManureStorageSystem manureStorageSystem)
        {
            var fieldsAppliedWithStoredManure = yearData.GetFieldsAppliedWithManure(manureStorageSystem);
            var farmManureIds = yearData.GetFarmManureIds(manureStorageSystem);

            var fieldAppliedManures = new List <FieldAppliedManure>();

            foreach (var field in fieldsAppliedWithStoredManure)
            {
                var nutrientManures = field.nutrients.nutrientManures
                                      .Where(nm => farmManureIds.Any(fm => fm == Convert.ToInt32(nm.manureId)))
                                      .ToList();

                foreach (var nutrientManure in nutrientManures)
                {
                    var fieldAppliedManure = new FieldAppliedManure();
                    if (manureStorageSystem.ManureMaterialType == ManureMaterialType.Liquid)
                    {
                        var convertedRate = _manureUnitConversionCalculator
                                            .GetLiquidUSGallonsPerAcreApplicationRate(nutrientManure.rate,
                                                                                      (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                        fieldAppliedManure.USGallonsApplied =
                            field.area * convertedRate;
                    }
                    else
                    {
                        var farmManure = yearData.farmManures
                                         .Single(fm => fm.id == Convert.ToInt32(nutrientManure.manureId));

                        decimal convertedRate;
                        if (string.IsNullOrWhiteSpace(farmManure.moisture))
                        {
                            convertedRate = _manureUnitConversionCalculator
                                            .GetSolidsTonsPerAcreApplicationRate(farmManure.manureId, nutrientManure.rate,
                                                                                 (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));
                        }
                        else
                        {
                            convertedRate = _manureUnitConversionCalculator
                                            .GetSolidsTonsPerAcreApplicationRate(Convert.ToDecimal(farmManure.moisture),
                                                                                 nutrientManure.rate,
                                                                                 (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));
                        }

                        fieldAppliedManure.TonsApplied = field.area * convertedRate;
                    }

                    fieldAppliedManures.Add(fieldAppliedManure);
                }
            }

            var appliedStoredManure = new AppliedStoredManure(fieldAppliedManures, manureStorageSystem);

            return(appliedStoredManure);
        }
        private List <FieldAppliedManure> GetFieldsAppliedCollectedManureForFarmAnimals(List <int> farmAnimalIds, FarmManure farmManure, YearData yearData)
        {
            var farmAnimals = yearData.FarmAnimals.Where(fa => farmAnimalIds.Contains(fa.Id.GetValueOrDefault(0))).ToList();

            var fieldAppliedManures = new List <FieldAppliedManure>();

            foreach (var farmAnimal in farmAnimals)
            {
                var fieldsAppliedWithCollectedManure = yearData
                                                       .GetFieldsAppliedWithManure(farmManure)
                                                       .Where(f => !fieldAppliedManures.Any(fam => fam.FieldId == f.Id)).ToList();

                var manure = _repository.GetManure(farmManure.ManureId);

                foreach (var field in fieldsAppliedWithCollectedManure)
                {
                    var nutrientManures = field?.Nutrients.nutrientManures
                                          .Where(nm => Convert.ToInt32(nm.manureId) == farmManure.Id)
                                          .ToList() ?? new List <NutrientManure>();

                    foreach (var nutrientManure in nutrientManures)
                    {
                        var fieldAppliedManure = new FieldAppliedManure {
                            FieldId = field.Id
                        };

                        if (farmAnimal.ManureType == ManureMaterialType.Liquid)
                        {
                            var convertedRate = _manureUnitConversionCalculator
                                                .GetLiquidUSGallonsPerAcreApplicationRate(nutrientManure.rate,
                                                                                          (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                            fieldAppliedManure.USGallonsApplied =
                                field.Area * convertedRate;
                        }
                        else
                        {
                            if (!decimal.TryParse(manure.Moisture.Replace("%", ""), out var moisture))
                            {
                                moisture = _repository.GetManure(farmManure.ManureId).DefaultSolidMoisture.GetValueOrDefault(0);
                            }

                            var convertedRate = _manureUnitConversionCalculator
                                                .GetSolidsTonsPerAcreApplicationRate(moisture, nutrientManure.rate,
                                                                                     (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                            fieldAppliedManure.TonsApplied = field.Area * convertedRate;
                        }

                        fieldAppliedManures.Add(fieldAppliedManure);
                    }
                }
            }

            return(fieldAppliedManures);
        }
        private List <FieldAppliedManure> CalculateFieldAppliedImportedManure(YearData yearData,
                                                                              FarmManure farmManure, ImportedManure importedManure)
        {
            var fieldAppliedManures             = new List <FieldAppliedManure>();
            var fieldsAppliedWithImportedManure = yearData
                                                  .GetFieldsAppliedWithManure(farmManure)
                                                  .Where(f => !fieldAppliedManures.Any(fam => fam.FieldId == f.Id)).ToList();

            foreach (var field in fieldsAppliedWithImportedManure)
            {
                var nutrientManures = field?.Nutrients.nutrientManures
                                      .Where(nm => Convert.ToInt32(nm.manureId) == farmManure.Id)
                                      .ToList() ?? new List <NutrientManure>();

                foreach (var nutrientManure in nutrientManures)
                {
                    var fieldAppliedManure = new FieldAppliedManure()
                    {
                        FieldId = field.Id
                    };
                    if (importedManure.ManureType == ManureMaterialType.Liquid)
                    {
                        var convertedRate = _manureUnitConversionCalculator
                                            .GetLiquidUSGallonsPerAcreApplicationRate(nutrientManure.rate,
                                                                                      (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                        fieldAppliedManure.USGallonsApplied =
                            field.Area * convertedRate;
                    }
                    else
                    {
                        var convertedRate = _manureUnitConversionCalculator
                                            .GetSolidsTonsPerAcreApplicationRate(importedManure.Moisture.Value, nutrientManure.rate,
                                                                                 (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                        fieldAppliedManure.TonsApplied = field.Area * convertedRate;
                    }

                    fieldAppliedManures.Add(fieldAppliedManure);
                }
            }

            return(fieldAppliedManures);
        }
        public AppliedImportedManure GetAppliedImportedManure(YearData yearData, FarmManure farmManure)
        {
            var fieldsAppliedWithImportedManure = yearData.GetFieldsAppliedWithManure(farmManure);
            var importedManure = yearData.ImportedManures.SingleOrDefault(mss => mss.Id == farmManure?.sourceOfMaterialImportedManureId.Value);
            var farmManureIds  = yearData.GetFarmManureIds(importedManure);

            var fieldAppliedManures = new List <FieldAppliedManure>();

            foreach (var field in fieldsAppliedWithImportedManure)
            {
                var nutrientManures = field.nutrients.nutrientManures
                                      .Where(nm => farmManureIds.Any(fm => fm == Convert.ToInt32(nm.manureId)))
                                      .ToList();

                foreach (var nutrientManure in nutrientManures)
                {
                    var fieldAppliedManure = new FieldAppliedManure();
                    if (importedManure.ManureType == ManureMaterialType.Liquid)
                    {
                        var convertedRate = _manureUnitConversionCalculator
                                            .GetLiquidUSGallonsPerAcreApplicationRate(nutrientManure.rate,
                                                                                      (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                        fieldAppliedManure.USGallonsApplied =
                            field.area * convertedRate;
                    }
                    else
                    {
                        var convertedRate = _manureUnitConversionCalculator
                                            .GetSolidsTonsPerAcreApplicationRate(importedManure.Moisture.Value, nutrientManure.rate,
                                                                                 (ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));

                        fieldAppliedManure.TonsApplied = field.area * convertedRate;
                    }

                    fieldAppliedManures.Add(fieldAppliedManure);
                }
            }

            var appliedImportedManure = new AppliedImportedManure(fieldAppliedManures, importedManure);

            return(appliedImportedManure);
        }