public void GetCurrentWeatherByZipcode_InvalidRequestUri()
{
//Arrange
var logger = new Mock <ILogger <IWeatherProvider> >();
OpenWeather openWeather = new OpenWeather();
var weatherApiRetriever = new Mock <IApiDataRetriever <OpenWeather> >();
weatherApiRetriever.Setup(m => m.GetData(It.IsAny <Uri>(), It.IsAny <string>()))
.ReturnsAsync(openWeather);
var uriProvider = new Mock <IExternalApiUriProvider>();
Uri invalidUri = new Uri("http://invaliduri");
uriProvider.Setup(m => m.GetCurrentWeatherByZipCodeUri(It.IsAny <string>(), It.IsAny <string>())).Returns(invalidUri);
var weatherResponseConverter = new Mock <IExternalApiResponseConverter <OpenWeather, CurrentWeatherModel> >();
var weatherProvider = new WeatherProvider(logger.Object, weatherApiRetriever.Object, uriProvider.Object, weatherResponseConverter.Object);
//Act
var result = weatherProvider.GetCurrentWeatherByZipCode("10247", "de"); //10247 - Berlin Friedrichshain
//Assert
Assert.ThrowsAsync <HttpResponseWithStatusCodeException>(
() => weatherProvider.GetCurrentWeatherByZipCode("berlin", "de"), "Invalid input parameters.");
}
public static async Task <List <WeatherInfo> > GetWeather()
{
// TODO get preferred weather provider once settings are implemented. For the scope of the capstone, the only weather provider is the national weather service
WeatherProvider weatherProvider = StoredProcedures.QueryWeatherProvider("National Weather Service");
if (weatherProvider.Name.Equals("National Weather Service"))
{
// TODO after we get more weather providers, split this out into its own method to prevent polluting a common space
List <ForecastPeriod> nwsPeriods = await GetWeatherFromNWS(weatherProvider);
// the list of weather infos to return
List <WeatherInfo> weatherInfos = new List <WeatherInfo>();
if (nwsPeriods != null)
{
// convert the periods to weather infos and add those infos to the list
nwsPeriods.ForEach(period =>
{
WeatherInfo weatherInfo = new WeatherInfo();
weatherInfo.CurrentTemperature = period.temperature;
// national weather service doesn't give high or low, so ignore those
weatherInfo.WindSpeed = period.windSpeed;
weatherInfo.Description = period.detailedForecast;
// fix the name up so the date time parser can parse it out
period.name = DateTimeParser.ReplaceDaytimeNamesWithTimeValue(period.name);
weatherInfo.DateApplicable = DateTimeParser.ParseDateTimeFromText(period.name);
// precipitation chance and humidity are not given by the nws api in separate fields
weatherInfos.Add(weatherInfo);
});
}
return(weatherInfos);
}
return(null);
}
public static void Main()
{
//subject
WeatherSubscriber DeutscherWetterdienst = new WeatherSubscriber();
//observers
WeatherProvider WebDienst = new WeatherProvider("WebDienst");
WebDienst.Subscribe(DeutscherWetterdienst);
WeatherProvider WetterApp = new WeatherProvider("WetterApp");
WetterApp.Subscribe(DeutscherWetterdienst);
WeatherProvider Tagesschau = new WeatherProvider("Tagesschau");
Tagesschau.Subscribe(DeutscherWetterdienst);
Console.WriteLine("Achtung! Der deutscher Wetterdienst hat neue Wetterdaten:");
DeutscherWetterdienst.SetMeasurements(new WeatherData(10, 7, 14));
Console.Read();
Tagesschau.Unsubscribe();
Console.WriteLine("Achtung! Die Tagesschau sucht sich ein anderen Wetterdienst.");
Console.Read();
Console.WriteLine("Achtung! Der deutscher Wetterdienst hat neue Wetterdaten:");
DeutscherWetterdienst.SetMeasurements(new WeatherData(28, 26, 14));
Console.Read();
Console.WriteLine("Fehler! Der deutscher Wetterdienst hat keine Wetterdaten");
DeutscherWetterdienst.SetMeasurements(null);
Console.Read();
}
async Task <WeatherCheckResponse> CheckFromProvider(WeatherProvider provider, string location)
{
using (var httpClient = new HttpClient())
{
var weatherCheckResponse = new WeatherCheckResponse(provider, location, measurements);
try
{
var response = await httpClient.GetAsync($"{provider.EndPoint}/{location}");
response.EnsureSuccessStatusCode();
var stringResponse = await response.Content.ReadAsStringAsync();
JsonConvert.PopulateObject(stringResponse, weatherCheckResponse);
}
catch (HttpRequestException ex)
{
weatherCheckResponse.BadRequestMessage = $"Error getting weather from {provider.Name}: {ex.Message}";
}
catch (Exception ex)
{
weatherCheckResponse.BadRequestMessage = $"Error getting weather from {provider.Name}: {ex.Message}";
}
return(weatherCheckResponse);
}
}
private static async Task <List <ForecastPeriod> > GetWeatherFromNWS(WeatherProvider provider)
{
// get the office and grid points
string getGridPointsURL = provider.urls.Find(url => url.Contains("/points/:latitude,:longitude"));
string forecastURL = provider.urls.Find(url => url.Contains("/forecast"));
// get the location's latitude and longitude
Dictionary <string, double> coordinates = await LocationProvider.GetLatitudeAndLongitude();
if (coordinates != null)
{
double latitude = coordinates["latitude"];
double longitude = coordinates["longitude"];
// fill in the url's values
getGridPointsURL = getGridPointsURL.Replace(":latitude", latitude.ToString()).Replace(":longitude", longitude.ToString());
Point GridPointResponse = JsonConvert.DeserializeObject <Point>(await MakeSimpleGetRequest(getGridPointsURL));
// get the office, gridX, and gridY
PointProperties properties = GridPointResponse.properties;
string office = properties.office;
string gridX = properties.gridX.ToString();
string gridY = properties.gridY.ToString();
// replace the parts of the forecast url with our values
forecastURL = forecastURL.Replace(":office", office).Replace(":gridX", gridX).Replace(":gridY", gridY);
Forecast ForecastResponse = JsonConvert.DeserializeObject <Forecast>(await MakeSimpleGetRequest(forecastURL));
return(ForecastResponse.properties.periods);
}
else
{
return(null);
}
}
private void DetermineWeather()
{
WeatherProvider weatherProvider = new WeatherProvider();
this.weatherToday = weatherProvider.GetWeather();
this.weatherForecast = weatherProvider.GetWeather();
}
public void GetCurrentWeatherByCityName_GetData_Returns_EmptyOpenWeather()
{
//Arrange
var logger = new Mock <ILogger <IWeatherProvider> >();
OpenWeather openWeather = new OpenWeather();
var uriProvider = new Mock <IExternalApiUriProvider>();
Uri uri = new Uri("http://someuri");
uriProvider.Setup(m => m.GetCurrentWeatherByCityUri(It.IsAny <string>(), It.IsAny <string>())).Returns(uri);
var weatherApiRetriever = new Mock <IApiDataRetriever <OpenWeather> >();
weatherApiRetriever.Setup(m => m.GetData(It.IsAny <Uri>(), It.IsAny <string>()))
.ReturnsAsync(openWeather);
var weatherResponseConverter = new Mock <IExternalApiResponseConverter <OpenWeather, CurrentWeatherModel> >();
weatherResponseConverter.Setup(m => m.Convert(It.IsAny <OpenWeather>())).Throws(new Exception("Invalid input parameter."));
var weatherProvider = new WeatherProvider(logger.Object, weatherApiRetriever.Object, uriProvider.Object, weatherResponseConverter.Object);
//Act
//Assert
Assert.ThrowsAsync <HttpResponseWithStatusCodeException>(
() => weatherProvider.GetCurrentWeatherByCityName("berlin", "de"), "Invalid input parameters.");
}
public IActionResult Method()
{
WeatherService_MethodInection weatherService = new WeatherService_MethodInection();
var weatherProvider = new WeatherProvider();
return(View(weatherService.GetForeCast("Hyderabad", weatherProvider)));
}
/// <summary>
// Gets the Weather Information for given cityId
/// </summary>
/// <param name="cityId"></param>
/// <returns>WheatheInfo</returns>
public async Task <WeatherInfo> Get(string cityId)
{
var WeatherProvider = new WeatherProvider();
IWeatherProvider Weather = WeatherProvider.FactoryMethod(_WeatherInfoProvider);
WeatherInfo WeatherInfo = await Weather.GetWeatherInfo(cityId);
return(WeatherInfo);
}
public void Test_GetForecastShortTerm_Return()
{
//Arrange
Location location = new Location();
IWeatherProvider provider = new WeatherProvider();
//Act and Assert
Assert.IsInstanceOfType(provider.GetForecastShortTerm(location), typeof(Task <ForecastShortTerm>));
}
public WeatherStationController()
{
if (_provider == null)
{
_provider = new WeatherProvider();
actualCondition.Subscribe(_provider);
statistics.Subscribe(_provider);
simpleForecast.Subscribe(_provider);
}
}
public void Forecast404()
{
try
{
var result = new WeatherProvider().getWeatherForecast("d");
}
catch (Exception ex)
{
Assert.IsNotNull(ex);
}
}
public void CurrentWeather404()
{
try
{
var result = new WeatherProvider().getCurrentWeather("d");
}
catch (Exception ex)
{
Assert.IsNotNull(ex);
}
}
public void Can_Add_Observer()
{
// Arrange
var provider = new WeatherProvider();
// Act
var subject = new WeatherObserver(provider, new CurrentTemperatureDisplay());
// Assert
Assert.That(provider.NumberOfSubscribers, Is.EqualTo(1));
}
public async Task Test_GetForecastForTrip_TripNull()
{
//Arrange
IClock iClock = new SystemClock();
IWeatherProvider weatherProvider = new WeatherProvider();
IWeatherUtils weatherUtils = new WeatherUtils(iClock);
ILocationWeatherManager locationWeatherManager = new LocationWeatherManager(weatherProvider, weatherUtils);
ITripIntervalManager tripIntervalManager = new TripIntervalManager();
ITripWeatherManager tripWeatherManager = new TripWeatherManager(locationWeatherManager, weatherUtils, tripIntervalManager);
//Act and Assert
var result = await tripWeatherManager.GetForecastForTrip(null);
}
public void GetCurrentWeatherByZipcode_InvalidInput()
{
//Arrange
var logger = new Mock <ILogger <IWeatherProvider> >();
var weatherApiRetriever = new Mock <IApiDataRetriever <OpenWeather> >();
var uriProvider = new Mock <IExternalApiUriProvider>();
var weatherResponseConverter = new Mock <IExternalApiResponseConverter <OpenWeather, CurrentWeatherModel> >();
var weatherProvider = new WeatherProvider(logger.Object, weatherApiRetriever.Object, uriProvider.Object, weatherResponseConverter.Object);
//Act
//Assert
Assert.ThrowsAsync <HttpResponseWithStatusCodeException>(() => weatherProvider.GetCurrentWeatherByZipCode("", ""), "Invalid input parameters.");
}
/// <summary>
/// Gets the Weather Information for all the cities from master city.json file
/// </summary>
/// <returns></returns>
public async Task <HttpResponseMessage> GetAll()
{
var WeatherProvider = new WeatherProvider();
IWeatherProvider Weather = WeatherProvider.FactoryMethod(_WeatherInfoProvider);
bool success = await Weather.GetBulkWeatherInfo();
if (success)
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.OK));
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError));
}
}
public async Task <HttpResponseMessage> GetMany()
{
HttpResponseMessage result = null;
var httpRequest = System.Web.HttpContext.Current.Request;
if (httpRequest.Files.Count > 0)
{
bool success = false;
var postedFile = httpRequest.Files[0];
var finfo = new FileInfo(postedFile.FileName);
if (finfo.Extension.ToLower() == ".txt")
{
var fname = $"{Path.GetFileNameWithoutExtension(finfo.FullName)}_{DateTime.Now.ToFileTime()}{finfo.Extension}";
var filePath = System.Web.HttpContext.Current.Server.MapPath("~/UserUploads/" + fname);
postedFile.SaveAs(filePath);
using (StreamReader r = new StreamReader(filePath))
{
string json = r.ReadToEnd();
var WeatherProvider = new WeatherProvider();
IWeatherProvider Weather = WeatherProvider.FactoryMethod(_WeatherInfoProvider);
try
{
var cities = JsonConvert.DeserializeObject <List <City> >(json);
success = await Weather.GetWeatherInfo(cities);
}
catch (Exception ex)
{
result = Request.CreateResponse(HttpStatusCode.BadRequest);
}
}
}
else
{
result = Request.CreateResponse(HttpStatusCode.BadRequest);
}
if (success)
{
result = Request.CreateResponse(HttpStatusCode.OK);
}
}
else
{
result = Request.CreateResponse(HttpStatusCode.BadRequest);
}
return(result);
}
static void Main(string[] args)
{
WeatherSubscriber subscriber = new WeatherSubscriber();
WeatherProvider channel7 = new WeatherProvider("Channel 7");
channel7.Subscribe(subscriber);
WeatherProvider cnn = new WeatherProvider("CNN");
cnn.Subscribe(subscriber);
WeatherProvider mouseTv = new WeatherProvider("Mouse TV");
mouseTv.Subscribe(subscriber);
subscriber.SetMeasurements(new WeatherData(10, 7, 14));
mouseTv.Unsubscribe();
subscriber.SetMeasurements(new WeatherData(28, 26, 14));
subscriber.SetMeasurements(null);
Console.Read();
}
public static WeatherProvider QueryWeatherProvider(string ProviderName = "")
{
WeatherProvider provider = null;
SqliteConnection conn = OpenDatabase();
SqliteCommand command = conn.CreateCommand();
command.CommandText = @"SELECT TWeatherProviders.weatherProviderID, TWeatherProviders.weatherProviderName, TWeatherProviderURLS.weatherProviderURL AS 'baseURL', group_concat(TWeatherProviderURLParts.weatherProviderURLPartURLString,'###') AS 'urlParts', TWeatherProviderAccessTypes.weatherProviderAccessType AS 'type'
FROM TWeatherProviders, TWeatherProviderURLS, TWeatherProviderURLParts, TWeatherProviderAccessTypes
WHERE TWeatherProviders.weatherProviderID = TWeatherProviderURLS.weatherProviderID AND TWeatherProviders.weatherProviderID = TWeatherProviderURLParts.weatherProviderID
AND TWeatherProviders.weatherProviderName = '{providerName}';".Replace("{providerName}", ProviderName);
using (SqliteDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
provider = WeatherProvider.FromDataRow(reader);
}
}
conn.Close();
return(provider);
}
private async Task SyncWeatherAsync([CanBeNull] TrackObjectBase track)
{
var trackGeoTags = track?.GeoTags;
if (track != null && (trackGeoTags == null || trackGeoTags.IsEmptyOrInvalid))
{
trackGeoTags = await TracksLocator.TryToLocateAsync(track);
if (_disposed)
{
return;
}
}
if (trackGeoTags == null && !string.IsNullOrWhiteSpace(SettingsHolder.Drive.LocalAddress))
{
trackGeoTags = await TracksLocator.TryToLocateAsync(SettingsHolder.Drive.LocalAddress);
if (_disposed)
{
return;
}
}
if (trackGeoTags == null)
{
Logging.Warning("Failed to calculate coordinates for real conditions");
Dispose();
return;
}
Logging.Debug("Geotags: " + trackGeoTags);
while (!_disposed)
{
ApplyWeather(await WeatherProvider.TryToGetWeatherAsync(trackGeoTags));
await Task.Delay(UpdateWeatherPeriod);
}
}
public void NotifySubscribers()
{
var provider = new SubscriptionProvider(_subscriptionRepositoryFactory());
provider.DeleteExpiredSubscriptions();
List <SubscriptionInfo> subscriptions = provider.GetConfirmed();
DateRange dateRange = new DateRange {
From = DateTime.Now, To = DateTime.Now.AddDays(3)
};
var weatherProvider = new WeatherProvider(_sources);
foreach (SubscriptionInfo subscription in subscriptions)
{
List <DateTime> rainDates = new List <DateTime>();
Location coords = new Location {
Latitude = subscription.Latitude, Longitude = subscription.Longitude
};
List <Weather> weatherForecast = weatherProvider.GetWeather(dateRange, coords);
foreach (Weather weather in weatherForecast)
{
if (weather.Precipitation == Precipitation.Rain)
{
rainDates.Add(weather.Date);
}
}
if (rainDates.Count > 0)
{
var emailMessage = EmailComposer.GetNotificationMail(subscription, rainDates);
EmailSender.SendEmail(emailMessage);
provider.UpdateNotifyDate(subscription);
}
}
}
public void GetCurrentWeatherByZipcode_GetData_Returns_ApiError()
{
//Arrange
var logger = new Mock <ILogger <IWeatherProvider> >();
var uriProvider = new Mock <IExternalApiUriProvider>();
Uri uri = new Uri("http://someuri");
uriProvider.Setup(m => m.GetCurrentWeatherByZipCodeUri(It.IsAny <string>(), It.IsAny <string>())).Returns(uri);
var weatherApiRetriever = new Mock <IApiDataRetriever <OpenWeather> >();
weatherApiRetriever.Setup(m => m.GetData(It.IsAny <Uri>(), It.IsAny <string>()))
.Throws(new HttpResponseWithStatusCodeException(HttpStatusCode.NotFound, "city not found"));
var weatherResponseConverter = new Mock <IExternalApiResponseConverter <OpenWeather, CurrentWeatherModel> >();
var weatherProvider = new WeatherProvider(logger.Object, weatherApiRetriever.Object, uriProvider.Object, weatherResponseConverter.Object);
//Act
//Assert
Assert.ThrowsAsync <HttpResponseWithStatusCodeException>(
() => weatherProvider.GetCurrentWeatherByZipCode("70247", "de"), "Invalid input parameters.");
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="e">Details about the launch request and process.</param>
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
DebugSettings.EnableFrameRateCounter = true;
}
#endif
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat application initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
// add needed objects to IoC container
var locator = Resources[LocaterResource] as ViewModelLocator;
if (locator != null)
{
var container = locator.Container;
container.Register(locator);
var dateTimeTask = new DateTimeProvider(container);
container.Register(dateTimeTask);
dateTimeTask.Start();
var client = new MqttClient(MqttBrokerAddress);
container.Register(client);
var telemetryProvider = new TelemetryProvider(container);
container.Register(telemetryProvider);
var rssProvider = new RssProvider(container);
container.Register(rssProvider);
rssProvider.Start();
var speechInterpreter = new SpeechInterpreter(container);
container.Register(speechInterpreter);
speechInterpreter.Start();
var WeatherProvider = new WeatherProvider(container);
container.Register(WeatherProvider);
var ioProvider = new IOProvider(container);
container.Register(ioProvider);
}
ApplicationView.GetForCurrentView().TryEnterFullScreenMode();
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
// Ensure the current window is active
Window.Current.Activate();
if (locator != null)
{
var container = locator.Container;
container.Register(Window.Current);
}
}
public void ForecastOK()
{
var result = new WeatherProvider().getWeatherForecast("dnipro");
Assert.IsNotNull(result);
}
public WeatherService()
{
this.provider = new WeatherProvider("xkq544hkar4m69qujdgujn7w");
}
public MainViewModel()
{
DataProvider = new XmlWeatherProvider("Data/WeatherData.xml");
PaneViewModel temperaturePane = new PaneViewModel(
showXAxis: false
);
PaneViewModel pressurePane = new PaneViewModel(
showXAxis: false
);
PaneViewModel humidityPane = new PaneViewModel(
showXAxis: true
);
LegendViewModel temperatureLegend = new LegendViewModel(dockTarget: temperaturePane);
LegendViewModel pressureLegend = new LegendViewModel(dockTarget: pressurePane);
LegendViewModel humidityLegend = new LegendViewModel(dockTarget: humidityPane);
XAxisViewModel xAxis = new XAxisViewModel {
MinValue = DataProvider.WeatherInfos.First().Timestamp,
MaxValue = DataProvider.WeatherInfos.ElementAt(10).Timestamp
};
YAxisViewModel temperatureYAxis = new YAxisViewModel(
title: "Temperature, F",
constantLines: null
);
YAxisViewModel pressureYAxis = new YAxisViewModel(
title: "Pressure, mbar",
constantLines: null
);
YAxisViewModel humidityYAxis = new YAxisViewModel(
title: "Humidity, %",
constantLines: new ConstantLineViewModel[] {
new ConstantLineViewModel(
title: String.Empty,
value: 60.0)
}
);
SeriesViewModel temperatureSeries = new SeriesViewModel(
name: "Temperature",
type: SeriesType.Line,
argumentName: "Timestamp",
valueName: "Temperature",
legend: temperatureLegend,
pane: temperaturePane,
yAxis: temperatureYAxis
);
SeriesViewModel pressureSeries = new SeriesViewModel(
name: "Pressure",
type: SeriesType.Area,
argumentName: "Timestamp",
valueName: "Pressure",
legend: pressureLegend,
pane: pressurePane,
yAxis: pressureYAxis
);
SeriesViewModel humiditySeries = new SeriesViewModel(
name: "Humidity",
type: SeriesType.Bar,
argumentName: "Timestamp",
valueName: "RelativeHumidity",
legend: humidityLegend,
pane: humidityPane,
yAxis: humidityYAxis);
Chart = new ChartViewModel(
series: new SeriesViewModel[] { temperatureSeries, pressureSeries, humiditySeries },
panes: new PaneViewModel[] { temperaturePane, pressurePane, humidityPane },
xAxis: xAxis,
yAxes: new YAxisViewModel[] { temperatureYAxis, pressureYAxis, humidityYAxis },
legends: new LegendViewModel[] { temperatureLegend, pressureLegend, humidityLegend }
);
}
public async Task GetCurrentTempAsync_LondonsIdIspassed_resultIsNotNull()
{
CurrentTemp result = await WeatherProvider.GetCurrentTempAsync("328328");
Assert.IsNotNull(result);
}
public async Task GetAutocompleteCityAsync_QueryForLon_FirstResultIsLondon()
{
List <City> result = await WeatherProvider.GetAutocompleteCityAsync("Lon");
Assert.AreEqual(result[0].LocalizedName, "London");
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="e">Details about the launch request and process.</param>
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
DebugSettings.EnableFrameRateCounter = true;
}
#endif
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat application initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
// add needed objects to IoC container
var locator = Resources[LocaterResource] as ViewModelLocator;
if (locator != null)
{
var container = locator.Container;
container.Register(locator);
var dateTimeTask = new DateTimeProvider(container);
container.Register(dateTimeTask);
dateTimeTask.Start();
var client = new MqttClient(MqttBrokerAddress);
container.Register(client);
var telemetryProvider = new TelemetryProvider(container);
container.Register(telemetryProvider);
var rssProvider = new RssProvider(container);
container.Register(rssProvider);
rssProvider.Start();
var speechInterpreter = new SpeechInterpreter(container);
container.Register(speechInterpreter);
speechInterpreter.Start();
var WeatherProvider = new WeatherProvider(container);
container.Register(WeatherProvider);
var ioProvider = new IOProvider(container);
container.Register(ioProvider);
}
ApplicationView.GetForCurrentView().TryEnterFullScreenMode();
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
// Ensure the current window is active
Window.Current.Activate();
if (locator != null)
{
var container = locator.Container;
container.Register(Window.Current);
}
}
public async Task GetForecastsAsyncTest_GetLondonForecast_CountOf5DaysReceived()
{
Forecasts result = await WeatherProvider.GetForecastsAsync("328328");
Assert.AreEqual(result.DailyForecasts.Count, 5);
}
public WeatherDialog()
{
_weatherProviders.Add(new OpenWeatherMap());
_weatherProviders.Add(new GismeteoWeather());
_mainWeatherProvider = _weatherProviders[0];
}
