예제 #1
0
        public void TryParseWithInvalidInputShouldReturnFalse(string input)
        {
            var result = BomRainfallData.TryParse(input, out var data);

            result.Should().BeFalse();
            data.Should().BeNull();
        }
        public bool ProcessLine(string dataLine)
        {
            if (BomRainfallData.TryParse(dataLine, out var bomRainfallData))
            {
                Aggregate(bomRainfallData);
                return(true);
            }

            return(false);
        }
예제 #3
0
        public void ValidateWithValidDataShouldReturnTrue(string input)
        {
            var parseResult = BomRainfallData.TryParse(input, out var data);

            parseResult.Should().BeTrue();
            data.Should().NotBeNull();

            var validateResult = data.Validate();

            validateResult.Should().BeTrue();
        }
예제 #4
0
        private static BomWeatherDataProcessor AggregateAllSampleData()
        {
            var processor = new BomWeatherDataProcessor();

            foreach (var line in SampleData)
            {
                BomRainfallData.TryParse(line, out var data);
                processor.Aggregate(data);
            }

            return(processor);
        }
예제 #5
0
        public void TryParseWithValidInputShouldReturnData()
        {
            var input = "field 1,field 2,field 3,field 4,field 5,field 6,field 7,field 8";

            var result = BomRainfallData.TryParse(input, out var data);

            result.Should().BeTrue();
            data.Should().NotBeNull();

            data.ProductCode.Should().Be("field 1");
            data.BranchNumber.Should().Be("field 2");
            data.Year.Should().Be("field 3");
            data.Month.Should().Be("field 4");
            data.Day.Should().Be("field 5");
            data.RainfallMillimetres.Should().Be("field 6");
            data.RainfallPeriodDays.Should().Be("field 7");
            data.QualityControl.Should().Be("field 8");
        }
        public void Aggregate(BomRainfallData bomRainfallData)
        {
            if (!bomRainfallData.Validate())
            {
                return;
            }

            var date = bomRainfallData.GetDate();

            if (!_weatherDataByYear.TryGetValue(date.Year, out var dataForYear))
            {
                dataForYear = new WeatherDataForYear()
                {
                    Year = date.Year
                };

                _weatherDataByYear.Add(date.Year, dataForYear);
            }

            AggregateYearData(dataForYear, bomRainfallData);
        }
        private static void AggregateYearData(WeatherDataForYear dataForYear, BomRainfallData bomRainfallData)
        {
            var rainfallReading = new RainfallReading(bomRainfallData.GetDate(), bomRainfallData.GetRainfall());

            if (dataForYear.FirstDate == null || rainfallReading.Date < dataForYear.FirstDate)
            {
                dataForYear.FirstDate = rainfallReading.Date;
            }

            if (dataForYear.LastDate == null || rainfallReading.Date > dataForYear.LastDate)
            {
                dataForYear.LastDate = rainfallReading.Date;
            }

            if (rainfallReading.Rainfall > 0)
            {
                dataForYear.TotalRainfall += rainfallReading.Rainfall;
                dataForYear.DaysWithRainfall++;
            }
            else
            {
                dataForYear.DaysWithNoRainfall++;
            }

            dataForYear.AllReadings.Add(rainfallReading);

            var monthData = dataForYear.MonthlyAggregates.FirstOrDefault(month => month.MonthNumber == rainfallReading.Date.Month);

            if (monthData == null)
            {
                monthData = WeatherDataForMonth.FromDate(rainfallReading.Date);

                dataForYear.MonthlyAggregates.Add(monthData);
            }

            AggregateMonthData(monthData, rainfallReading);
        }