public async Task BuffaloForecastCombineAllOptionsGermanCulture()
{
using var germanCultureParse =
new DarkSkyService(_apiKey, jsonSerializerService: new CultureSettingFixture());
var forecast = await germanCultureParse.GetForecast(_latitude, _longitude,
new OptionalParameters
{
ExtendHourly = true,
DataBlocksToExclude = new List <ExclusionBlocks> {
ExclusionBlocks.Flags
},
LanguageCode = "x-pig-latin",
MeasurementUnits = "si"
});
Assert.NotNull(forecast);
Assert.NotNull(forecast.Response);
Assert.NotNull(forecast.Headers);
Assert.NotEmpty(forecast.Response.Daily.Data);
Assert.NotEmpty(forecast.Response.Hourly.Data);
Assert.Null(forecast.Response.Flags);
Assert.Equal(forecast.Response.Latitude, _latitude);
Assert.Equal(forecast.Response.Longitude, _longitude);
}
public async Task UnicodeLanguageIsSupported()
{
var client = new DarkSkyService(apiKey);
var result = await client.GetWeatherDataAsync(AlcatrazLatitude, AlcatrazLongitude, Unit.Auto, Language.Chinese);
Assert.That(result, Is.Not.Null);
}
public async Task BuffaloForecastEverythingParsed()
{
using var parseAllJson =
new DarkSkyService(_apiKey, jsonSerializerService: new MissingMemberHandlingFixture());
await parseAllJson.GetForecast(_latitude, _longitude);
}
public void FullQueryBuilderTest()
{
var expectedQuery =
$"forecast/fakekey/{ResponseFixture.Latitude},{ResponseFixture.Longitude},1970-01-01T00:00:00Z?&exclude=alerts,flags&extend=hourly&lang=x-pig-latin&units=si";
const string baseUri = @"https://api.darksky.net/";
var totalQuery = $"{baseUri}{expectedQuery}";
var queryCheckClient = new Mock <IHttpClient>();
queryCheckClient.Setup(f => f.HttpRequestAsync(totalQuery))
.Returns((string s) => Task.FromResult(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK, ReasonPhrase = s
}));
using var darkSkyServiceQueryCheck =
new DarkSkyService("fakekey", new Uri(baseUri), queryCheckClient.Object);
var parameters = new OptionalParameters
{
DataBlocksToExclude = new List <ExclusionBlocks> {
ExclusionBlocks.Alerts, ExclusionBlocks.Flags
},
ExtendHourly = true,
LanguageCode = "x-pig-latin",
MeasurementUnits = "si",
ForecastDateTime = DateTime.UnixEpoch
};
var result = darkSkyServiceQueryCheck
.GetForecast(ResponseFixture.Latitude, ResponseFixture.Longitude, parameters).Result;
Assert.Equal(result.ResponseReasonPhrase, totalQuery);
Assert.True(result.IsSuccessStatus);
}
public async Task TestGetBasicWeatherData()
{
var api = Config[_apiEnvVar];
Assert.IsNotNull(api);
var weather = new DarkSkyService(api);
var forecast = await weather.GetForecast(_latitude, _longitude, new DarkSkyService.OptionalParameters
{
MeasurementUnits = "si",
});
var humid = forecast.Response.Currently.Humidity;
var temp = forecast.Response.Currently.Temperature;
var wind = forecast.Response.Currently.WindSpeed;
var minToday = forecast.Response.Daily.Data[0].TemperatureLow;
var maxToday = forecast.Response.Daily.Data[0].TemperatureHigh;
var minTomorrow = forecast.Response.Daily.Data[1].TemperatureLow;
var maxTomorrow = forecast.Response.Daily.Data[1].TemperatureHigh;
foreach (var day in forecast.Response.Daily.Data)
{
var time = day.DateTime.ToLocalTime();
Debug.WriteLine(time.ToString());
}
Debug.WriteLine($"Temp: {temp}, Humid: {humid}");
}
public ForecastResult Get(double lat, double lng)
{
var client = new DarkSkyService(DARKSKY_API);
var darkSkyForecast = client.GetWeatherDataAsync(lat, lng).Result;
var result = new ForecastResult
{
CurrentSummary = darkSkyForecast.Currently.Summary,
CurrentTemp = darkSkyForecast.Currently.Temperature.ToString("0.0")
};
foreach (var dsDayForecast in darkSkyForecast.Daily.Days)
{
var dayForecast = new DailyForecast
{
LowTemp = dsDayForecast.LowTemperature.ToString("0.0"),
HiTemp = dsDayForecast.HighTemperature.ToString("0.0"),
Summary = dsDayForecast.Summary,
DayOfWeek = dsDayForecast.SunriseTime.ToLocalTime().DayOfWeek.ToString()
};
result.Future.Add(dayForecast);
}
return(result);
}
public async void TimeMachineExclusionWorksCorrectly()
{
// prepare
var date = new DateTime(2021, 01, 24, 10, 00, 01, DateTimeKind.Utc);
Forecast output = null;
using (var stream = new BufferedStream(File.OpenRead("./Resources/DarkSky_GetWeatherByDate_SI.json"), 8192)) {
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When(DarkSkyService.EndPointRoot + "*")
.Respond("application/json", stream);
var exclusionList = new List <Exclude> {
Exclude.Minutely, Exclude.Hourly
};
IDarkSkyService client = new DarkSkyService("a_valid_key", mockHttp);
output = await client.GetWeatherByDate(AlcatrazLatitude, AlcatrazLongitude, date, exclusionList, DSUnit.SI);
stream.Close();
}
Assert.NotNull(output);
Assert.Null(output.Hourly);
Assert.NotNull(output.Currently);
Assert.NotNull(output.Daily);
Assert.NotNull(output.Daily.Data);
output.Daily.Data.Count.ShouldBe(1);
output.Daily.Data[0].Time.Date.ShouldBe(date.Date);
}
public async Task <RuntimeResult> GetWeatherForLocationAsync([Summary("User")] SocketUser user = null)
{
var targetUser = user ?? Context.User;
var record = UserRepository.GetCoordinates(targetUser);
if (record == null)
{
return(CommandRuntimeResult.FromError(
"Location is not set yet! Please set the location first!"));
}
var geocodeResults = await Geocoder.ReverseGeocodeAsync(record.Latitude, record.Longitude).ConfigureAwait(false);
var geocode = geocodeResults.FirstOrDefault();
if (geocode == null)
{
return(CommandRuntimeResult.FromError(
"I could not find the set location! Try setting another location."));
}
var forecast = await DarkSkyService.GetForecast(
geocode.Coordinates.Latitude,
geocode.Coordinates.Longitude,
_darkSkyParams
).ConfigureAwait(false);
var embeds = await Weather.GetWeatherEmbedsAsync(forecast, geocode).ConfigureAwait(false);
await ReplyAsync("", embed : embeds.WeatherResults.FirstOrDefault().Build()).ConfigureAwait(false);
foreach (var alert in embeds.Alerts)
{
await ReplyAsync("", embed : alert.Build()).ConfigureAwait(false);
}
return(CommandRuntimeResult.FromSuccess());
}
public DarkSkyWeatherService()
{
var settings = Mvx.IoCProvider.Resolve <IAppSettings>();
Serial = settings.DarkSkySerial;
WeatherService = new DarkSkyService(Serial);
}
private static async Task <Forecast> GetDarkSkyForecast(double lat, double longitude)
{
var ds = new DarkSkyService("");
var forecast = await ds.GetWeatherDataAsync(lat, longitude);
return(forecast);
}
public async Task GetForecastWithMockData()
{
var mockCLient = new Mock <IHttpClient>();
mockCLient.Setup(f => f.HttpRequest(It.IsAny <string>())).Returns(Task.FromResult(_mockHttpResponse));
var darkSkyService = new DarkSkyService("fakekey", mockCLient.Object);
var forecast = await darkSkyService.GetForecast(_latitude, _longitude);
Assert.NotNull(forecast);
// Check Response (basic deserialization check)
Assert.NotNull(forecast.Response);
Assert.Equal(forecast.Response.Latitude, _latitude);
Assert.Equal(forecast.Response.Longitude, _longitude);
Assert.NotEmpty(forecast.Response.Alerts);
Assert.NotNull(forecast.Response.Currently);
Assert.NotNull(forecast.Response.Daily);
Assert.NotEmpty(forecast.Response.Daily.Data);
Assert.NotNull(forecast.Response.Flags);
Assert.NotNull(forecast.Response.Hourly);
Assert.NotEmpty(forecast.Response.Hourly.Data);
Assert.NotNull(forecast.Response.Minutely);
Assert.NotEmpty(forecast.Response.Minutely.Data);
Assert.NotNull(forecast.Response.TimeZone);
}
public async void GetWeather()
{
var client = new DarkSkyService(GlobalVars.DarkSkyWeatherKey);
// 52.499836, 6.079915 are Windesheim Coordinates
Weather = await client.GetWeatherDataAsync(52.499836, 6.079915);
}
public async Task <RuntimeResult> GetWeatherForLocationAsync([Summary("Location")][Remainder] string location)
{
var geocodeResults = await Geocoder.GeocodeAsync(location).ConfigureAwait(false);
var geocode = geocodeResults.FirstOrDefault();
if (geocode == null)
{
return(CommandRuntimeResult.FromError($"I could not find {location}! Try another location."));
}
var forecast = await DarkSkyService.GetForecast(
geocode.Coordinates.Latitude,
geocode.Coordinates.Longitude,
_darkSkyParams).ConfigureAwait(false);
var embeds = await Weather.GetWeatherEmbedsAsync(forecast, geocode).ConfigureAwait(false);
await ReplyAsync("", embed : embeds.WeatherResults.FirstOrDefault().Build()).ConfigureAwait(false);
foreach (var alert in embeds.Alerts)
{
await ReplyAsync("", embed : alert.Build()).ConfigureAwait(false);
}
return(CommandRuntimeResult.FromSuccess());
}
public string GetWeatherForLocation(double latitude, double longitude)
{
var service = new DarkSkyService("97fb52ad1c8fb2f59ff1f5da02d0337c");
var forecast = Task.Run(() => service.GetForecast(latitude, longitude)).Result;
return($"Current weather is {forecast.Response.Currently.Temperature}");
}
public async void CurrentAnd7DaysForecastWorksCorrectly()
{
// prepare
Forecast output = null;
using (var stream = new BufferedStream(File.OpenRead("./Resources/DarkSky_CurrentAnd7DaysForecast_SI.json"), 8192)) {
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When(DarkSkyService.EndPointRoot + "*")
.Respond("application/json", stream);
IDarkSkyService client = new DarkSkyService("a_valid_key", mockHttp);
var exclusionList = new List <Exclude> {
Exclude.Hourly, Exclude.Minutely, Exclude.Alerts, Exclude.Flags
};
output = await client.GetWeather(BolognaLatitude, BolognaLongitude, null, exclusionList, DSUnit.Auto, Language.Italian);
stream.Close();
}
// assert
Assert.NotNull(output);
Assert.NotNull(output.Currently);
Assert.Null(output.Minutely);
Assert.Null(output.Hourly);
Assert.NotNull(output.Currently);
Assert.NotNull(output.Daily);
Assert.NotNull(output.Daily.Data);
Assert.NotEmpty(output.Daily.Data);
}
public async void GetForecast_ByCoordinates_Test()
{
// prepare
Forecast output = null;
using (var stream = new BufferedStream(File.OpenRead("./Resources/DarkSky_GetForecast_SI.json"), 8192)) {
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When(DarkSkyService.EndPointRoot + "*")
.Respond("application/json", stream);
IDarkSkyService client = new DarkSkyService("a_valid_key", mockHttp);
output = await client.GetForecast(BolognaLatitude, BolognaLongitude, DSUnit.SI, Language.Italian);
stream.Close();
}
// assert
Assert.NotNull(output);
Assert.NotNull(output.Currently);
Assert.Null(output.Minutely);
Assert.NotNull(output.Hourly);
Assert.NotNull(output.Hourly.Data);
Assert.NotEmpty(output.Hourly.Data);
Assert.NotNull(output.Daily);
Assert.NotNull(output.Daily.Data);
Assert.NotEmpty(output.Daily.Data);
}
//Jeff Munson API key
//9a9c19a4d9a62d812bf17136c99cc6cf
// Zucker Hillside hospital
//40°45'09.7"N 73°42'39.3"W
//40.752700, -73.710906
//Central Park
//40°46'53.5"N 73°57'60.0"W
//40.781531, -73.966657
//18 miles north, White Plains Hospital
//41°01'35.0"N 73°46'05.9"W
//41.026394, -73.768312
//38 miles north NewYork-Presbyterian/Hudson Valley Hospital, Cortlandt Manor NY
//41°17'33.9"N 73°53'34.1"W
//41.292741, -73.892797
//28 miles west, University Hospital in Newark
//40°44'25.5"N 74°11'22.9"W
//40.740423, -74.189698
//33 miles E NE, Stony Brook University Hospital
//40°54'34.6"N 73°06'48.4"W
//40.909615, -73.113439
public DarkSky()
{
//
// TODO: Add constructor logic here
//
client = new DarkSkyService("9a9c19a4d9a62d812bf17136c99cc6cf");
}
public async Task GetForecastWithMockData()
{
var darkSkyService = new DarkSkyService("fakekey", _fixture.MockClient.Object);
var forecast = await darkSkyService.GetForecast(_latitude, _longitude);
Assert.NotNull(forecast);
//Check Response (basic deserialization check)
Assert.NotNull(forecast.Response);
Assert.Equal(forecast.Response.Latitude, _latitude);
Assert.Equal(forecast.Response.Longitude, _longitude);
Assert.NotEmpty(forecast.Response.Alerts);
Assert.NotNull(forecast.Response.Currently);
Assert.NotNull(forecast.Response.Daily);
Assert.NotEmpty(forecast.Response.Daily.Data);
Assert.NotNull(forecast.Response.Flags);
Assert.NotNull(forecast.Response.Hourly);
Assert.NotEmpty(forecast.Response.Hourly.Data);
Assert.NotNull(forecast.Response.Minutely);
Assert.NotEmpty(forecast.Response.Minutely.Data);
Assert.NotNull(forecast.Response.Timezone);
// Check Headers (match pre-defined values)
Assert.NotNull(forecast.Headers);
Assert.Equal(forecast.Headers.ApiCalls.Value, _fixture.ApiCalls);
Assert.Equal(forecast.Headers.CacheControl.MaxAge.Value.TotalMinutes, _fixture.CacheMinutes);
Assert.Equal(forecast.Headers.ResponseTime, _fixture.ResponseTime);
}
/// <summary>
/// Fetches DarkSky api, Tidal api to gather weather data, and select relevant data
/// assigning it to this object
/// </summary>
/// <param name="lat">Latitude</param>
/// <param name="lon">Longitude</param>
/// <param name="location">Location name for provided coordinates</param>
/// <param name="stationId">Tidal station id</param>
/// <param name="addDays">Fetch data for future days. How many days add to today date</param>
/// <param name="addHours">Fetch data for current hours + addHours</param>
public void Update(double lat, double lon, string location, string stationId, int addDays = 0, int addHours = 0)
{
var client = new DarkSkyService(Constants.DarkSkyKey);
// creating time object which depicts forecast time
var time = DateTimeOffset.Now.AddDays(addDays).AddHours(addHours);
// calling api for weather info
DarkSkyApi.Models.Forecast f = Task.Run(() => client.GetTimeMachineWeatherAsync(lat, lon, time)).Result;
// setting model properties with api result
icon = f.Currently.Icon;
this.location = location;
double _temp = Math.Round(UnitConverters.FahrenheitToCelsius(f.Currently.Temperature), 1);
temperature = _temp.ToString() + "°C";
summary = f.Currently.Summary;
humidity = $"{(int)(f.Currently.Humidity * 100)}%";
windSpeed = string.Format("{0:0.00}m/s", f.Currently.WindSpeed / 2.237); // convert to m/s
windDirection = ((int)(f.Currently.WindBearing)).ToString() + "°";
if (stationId != string.Empty)
{
waterLevel = TidalApi.GetInstance().GetWaterInfo(stationId, addDays, time.Hour);
}
else
{
waterLevel = "0m";
}
// setting forecast time in model, setting minutes and seconds to 0
date = new DateTime(time.Year, time.Month, time.Day, time.Hour, 0, 0);
}
public ParksController(NPDbContext context, IConfiguration configuration)
{
_context = context;
Configuration = configuration;
_apiKey = Configuration[_apiEnvVar];
darkSky = new DarkSkyService(_apiKey);
}
public WheaterSimulator()
{
// 37076b047b44f229bd60d7bffb9a8c22
// fa6d00664c0c9abf42654341ff91db31
// e67254e31e12e23461c61e0fb0489142
// ab42e06e054eb1164d36132c278edef9
darkSkyProxy = new DarkSkyService("fa6d00664c0c9abf42654341ff91db31");
}
public void ExceptionThrownForMissingApiKey(string value)
{
Assert.ThrowsAny <ArgumentException>(() =>
{
var darkSkyService = new DarkSkyService(value);
var result = darkSkyService.GetForecast(0, 0);
});
}
public async Task <Forecast> Get(double latitude, double longitude)
{
var client = new DarkSkyService(Environment.GetEnvironmentVariable("ApiKey"));
Forecast result = await client.GetWeatherDataAsync(latitude, longitude);
JsonConvert.SerializeObject(result);
return(result);
}
public void Dispose()
{
_darkSky = null;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Ignore
};
}
public async Task UnitSIWorksCorrectly()
{
var client = new DarkSkyService(apiKey);
var result = await client.GetWeatherDataAsync(MumbaiLatitude, MumbaiLongitude, Unit.SI);
Assert.That(result, Is.Not.Null);
Assert.That(result.Currently, Is.Not.Null);
}
public async Task NonUSDataCanBeRetrieved()
{
var client = new DarkSkyService(apiKey);
var result = await client.GetWeatherDataAsync(MumbaiLatitude, MumbaiLongitude);
Assert.That(result, Is.Not.Null);
Assert.That(result.Currently, Is.Not.Null);
}
public async Task ValidKeyRetrievesData()
{
var client = new DarkSkyService(apiKey);
var result = await client.GetWeatherDataAsync(AlcatrazLatitude, AlcatrazLongitude);
Assert.That(result, Is.Not.Null);
Assert.That(result.Currently, Is.Not.Null);
}
public async Task UnitsCanBeSpecified()
{
var client = new DarkSkyService(apiKey);
var result = await client.GetWeatherDataAsync(AlcatrazLatitude, AlcatrazLongitude, Unit.CA);
Assert.That(result, Is.Not.Null);
Assert.That(result.Flags.Units, Is.EqualTo(Unit.CA.ToValue()));
}
private void Settings_OnChanged()
{
_weather = new DarkSkyService(_settings.DARKSKY_API_KEY);
BoardStatusValues.TOOLATE = _settings.TOO_LATE;
BoardStatusValues.RUNNOW = _settings.RUN_TIME_TO_STATION;
BoardStatusValues.GONOW = _settings.WALK_TIME_TO_STATION;
BoardStatusValues.DRINKUP = _settings.DRINK_UP_TIME;
BoardStatusValues.GETDRINK = _settings.GET_DRINK_TIME;
}
public ResponseHeadersIntegrationTests()
{
var configBuilder = new ConfigurationBuilder().AddEnvironmentVariables();
var config = configBuilder.Build();
var apiKey = config.GetValue <string>(_apiEnvVar);
Assert.False(string.IsNullOrWhiteSpace(apiKey), $"You must set the environment variable {_apiEnvVar}");
_darkSky = new DarkSkyService(apiKey);
}
