/// <summary>
		/// Gets the weather.
		/// </summary>
		/// <returns>The weather.</returns>
		private async Task<Weather.WeatherData> GetWeather()
		{
			var location = new Weather.Location ();
			WeatherData weather = new WeatherData ();

			// Get current location
			try {
				location = await LocationClient.GetLocation ();
			} catch (WebException e) {
				ShowNotification ("Error", "Error defining current location");
				// TODO: show view to enter current location
			} catch (Exception e) {
				ShowNotification ("Error", "Application will be closed.");
				Android.OS.Process.KillProcess(Android.OS.Process.MyPid());
			}

			var storedLocations = await ConfigurationHelper.GetStoredLocations ();
			foreach(var loc in storedLocations)
			{
				var localWeather = await WeatherClient.GetWeather (new Weather.Location{ city = loc});
				if (localWeather != null)
					CurrentWeather.Add (localWeather);
			}

			return weather;
		}
Exemple #2
0
        public void should_update_panel_of_statistics()
        {
            var currentTime = new DateTime();
            var statisticsDisplay = new StatisticsDisplay();
            var weatherData = new WeatherData(new CurrentConditionsDisplay(), statisticsDisplay, new ForecastDisplay());
            weatherData.MeasurementsChanged(currentTime);

            Assert.Equal(currentTime, statisticsDisplay.UpdatedTime);
        }
        public WeatherData[] DefineWeather(string url, string xPathTemp_1, string xPathTemp_2, string xPathPressure, string xPathWindSpeed, string xPathWindSpeed_2,
                                           string xPathWindDirection, string xPathHumidity, string xPathWater, int Param) //парсер
        {
            WeatherData[] dates = new WeatherData[0];
            int           i     = 0;

            if (Param == 1) //now
            {
                dates = new WeatherData[1];
                i     = 1;
            }
            if (Param == 2) //tomorrow
            {
                dates = new WeatherData[8];
                i     = 8;
            }

            string pageContent = LoadPage(url);

            HtmlAgilityPack.HtmlDocument document = new HtmlAgilityPack.HtmlDocument();
            if (pageContent != "" && pageContent != null)
            {
                document.LoadHtml(pageContent);
                int k = 0;
                //temperature
                HtmlNodeCollection linkTemp = document.DocumentNode.SelectNodes(xPathTemp_1);
                if (linkTemp != null)
                {
                    string[] temperature1 = new string[i];
                    foreach (HtmlNode link in linkTemp)
                    {
                        if (k < i)
                        {
                            temperature1[k] = link.InnerText;
                            ++k;
                        }
                    }

                    for (int j = 0; j < i; ++j)
                    {
                        int minus = temperature1[j].IndexOf('m'); //if temp < 0

                        while (!char.IsDigit(temperature1[j][0]))
                        {
                            temperature1[j] = temperature1[j].Remove(0, 1);
                        }
                        dates[j].Temperature = int.Parse(temperature1[j]);

                        if (xPathTemp_2 != null) //если есть дробная часть
                        {
                            HtmlNode linkTemp_1day_2 = document.DocumentNode.SelectSingleNode(xPathTemp_2);

                            string temperature2 = "";
                            if (linkTemp_1day_2 != null)
                            {
                                temperature2          = linkTemp_1day_2.InnerText;
                                dates[j].Temperature += (int.Parse(temperature2.Remove(0, 1)) * 0.1);
                            }
                        }
                        if (minus >= 0) //если температура меньше нуля
                        {
                            try
                            {
                                dates[j].Temperature *= -1;
                            }
                            catch
                            {
                                dates[j].Temperature = double.MaxValue;
                            }
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < i; ++j)
                    {
                        dates[j].Temperature = double.MaxValue;
                    }
                }


                //pressure
                HtmlNodeCollection linkpressure = document.DocumentNode.SelectNodes(xPathPressure);
                if (linkpressure != null)
                {
                    string[] pressure = new string[i];
                    k = 0;
                    foreach (HtmlNode link in linkpressure)
                    {
                        pressure[k] = link.InnerText;
                        ++k;
                    }
                    for (int j = 0; j < i; ++j)
                    {
                        try
                        {
                            dates[j].Pressure = int.Parse(pressure[j]);
                        }
                        catch
                        {
                            dates[j].Pressure = int.MaxValue;
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < i; ++j)
                    {
                        dates[j].Pressure = int.MaxValue;
                    }
                }

                //wind speed
                HtmlNodeCollection linkwindspeed = document.DocumentNode.SelectNodes(xPathWindSpeed);
                if (linkwindspeed != null)
                {
                    string[] wind1_2    = new string[i];
                    char[]   separators = new char[] { '-', ' ', '\0', '\n' };
                    k = 0;
                    foreach (HtmlNode link in linkwindspeed)
                    {
                        wind1_2[k] = link.InnerText;
                        ++k;
                    }
                    for (int j = 0; j < i; ++j)
                    {
                        string[] wind = wind1_2[j].Split(separators, StringSplitOptions.RemoveEmptyEntries);
                        dates[j].WindSpeed_1 = int.Parse(wind[0]);
                        if (wind.Length > 1)
                        {
                            dates[j].WindSpeed_2 = int.Parse(wind[1]);
                        }
                    }
                    if (xPathWindSpeed_2 != null) //только для 3 дней
                    {
                        HtmlNodeCollection linkwindspeed2 = document.DocumentNode.SelectNodes(xPathWindSpeed_2);
                        string[]           wind2          = new string[i];
                        char[]             separator      = new char[] { '-', ' ', '\0', '\n' };
                        k = 0;
                        foreach (HtmlNode link in linkwindspeed2)
                        {
                            wind2[k] = link.InnerText;
                            ++k;
                        }
                        for (int j = 0; j < i; ++j)
                        {
                            try
                            {
                                string[] wind = wind2[j].Split(separators, StringSplitOptions.RemoveEmptyEntries);
                                if (wind[0] != "&mdash;")
                                {
                                    dates[j].WindSpeed_2 = int.Parse(wind[0]);
                                }
                                else
                                {
                                    dates[j].WindSpeed_2 = 0;
                                }
                            }
                            catch
                            {
                                dates[j].WindSpeed_1 = int.MaxValue;
                                dates[j].WindSpeed_2 = int.MaxValue;
                            }
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < i; ++j)
                    {
                        dates[j].WindSpeed_1 = int.MaxValue;
                        dates[j].WindSpeed_2 = int.MaxValue;
                    }
                }

                //wind direction
                HtmlNodeCollection linkWindDirection = document.DocumentNode.SelectNodes(xPathWindDirection);
                if (linkWindDirection != null)
                {
                    string[] WindDirection = new string[i];
                    k = 0;
                    foreach (HtmlNode link in linkWindDirection)
                    {
                        WindDirection[k] = link.InnerText;
                        ++k;
                    }
                    for (int j = 0; j < i; ++j)
                    {
                        try
                        {
                            string[] directions = WindDirection[j].Split(new char[] { ' ', '\n' }, StringSplitOptions.RemoveEmptyEntries);
                            dates[j].WindDirection = directions[0];
                        }
                        catch
                        {
                            dates[j].WindDirection = "";
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < i; ++j)
                    {
                        dates[j].WindDirection = "";
                    }
                }

                //humidity
                HtmlNodeCollection linkHumidity = document.DocumentNode.SelectNodes(xPathHumidity);
                if (linkHumidity != null)
                {
                    string[] Humidity = new string[i];
                    k = 0;
                    foreach (HtmlNode link in linkHumidity)
                    {
                        Humidity[k] = link.InnerText;
                        ++k;
                    }
                    for (int j = 0; j < i; ++j)
                    {
                        try
                        {
                            dates[j].Humidity = int.Parse(Humidity[j]);
                        }
                        catch
                        {
                            dates[j].Humidity = int.MaxValue;
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < i; ++j)
                    {
                        dates[j].Humidity = int.MaxValue;
                    }
                }

                //water
                if (xPathWater != null) //доступно только для "сейчас"
                {
                    HtmlNode linkWater_1day = document.DocumentNode.SelectSingleNode(xPathWater);
                    if (linkWater_1day != null)
                    {
                        string TemperatureWater = linkWater_1day.InnerText;
                        dates[0].Water = TemperatureWater;
                    }
                    else
                    {
                        dates[0].Water = "";
                    }
                }
            }
            return(dates);
        }