public TemperatureLookupFacade
(WeatherService weatherService, GeoLookupService geoLookupService, EnglishMetricsConverter converter)
{
this.weatherService = weatherService;
this.geoLookupService = geoLookupService;
this.converter = converter;
}
public Object GetHourlyReportWeatherBit(string lat, string lon, string start_date, string end_date)
{
Console.WriteLine(lat);
Console.WriteLine(lon);
Console.WriteLine(start_date);
Console.WriteLine(end_date);
WeatherService obj = new WeatherService();
IDatabase db = AppConstant.rediscon.GetDatabase();
var projectData = db.StringGet("WeatherBitHourly" + lat + lon + start_date + end_date);
if (!string.IsNullOrEmpty(projectData))
{
Console.WriteLine("Get Data From Cache");
return(JsonConvert.DeserializeObject(projectData));
}
else
{
Console.WriteLine("Set Data in Cache");
db.StringSet("WeatherBitHourly" + lat + lon + start_date + end_date, obj.GetHourlyReportWeatherBit(lat, lon, start_date, end_date));
Console.WriteLine("Set Data in Cache");
projectData = db.StringGet("WeatherBitHourly" + lat + lon + start_date + end_date);
Console.WriteLine("Set Data in Cache");
return(JsonConvert.DeserializeObject(projectData));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
var appConfiguration = Configuration.Get <AppConfiguration>();
var httpClient = new HttpClient();
var zWayService = new ZWayService(httpClient, LoggerFactory.CreateLogger <ZWayService>());
var weatherService = new WeatherService(httpClient, LoggerFactory.CreateLogger <WeatherService>());
var sunService = new SunService(httpClient, LoggerFactory.CreateLogger <SunService>());
var virtualService = new DeviceGroupService(zWayService);
var aggregatedService = new AggregatedDeviceService(zWayService, virtualService, weatherService, sunService);
var statisticsService = new StatisticsService(LoggerFactory.CreateLogger <StatisticsService>(), aggregatedService, appConfiguration.Statistics);
zWayService.InitAsync(appConfiguration.ZWay).Wait();
weatherService.InitAsync(appConfiguration.Weather).Wait();
sunService.InitAsync(appConfiguration.Sun).Wait();
virtualService.Init(appConfiguration.DeviceGroups);
aggregatedService.Init(appConfiguration.ToggleAutomationRules);
statisticsService.Init();
services.AddMvc();
services.AddSingleton <HttpClient>(new HttpClient());
services.AddSingleton <IDeviceService>(aggregatedService);
services.AddSingleton <VersionService>(new VersionService());
services.AddSingleton <StatisticsService>(statisticsService);
//services.AddSignalR();
}
public static void TestTimeExecution()
{
var weatherService = new WeatherService();
var path = "Data/62318.30.11.2010.30.11.2020.1.0.0.en.utf8.00000000.csv";
var csvMappingResults = weatherService.GroupByOneMonth(CsvReader.readFile(path));
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
weatherService.CalculateMediumTemperature(csvMappingResults);
watch.Stop();
Console.WriteLine($"Simple; Execution time: {watch.ElapsedMilliseconds} ms");
watch.Restart();
weatherService.CalculateMediumTemperatureByTasks(csvMappingResults).GetAwaiter().GetResult();
watch.Stop();
Console.WriteLine($"Tasks (ThreadPool); Execution time: {watch.ElapsedMilliseconds} ms");
watch.Restart();
weatherService.CalculateMediumTemperatureByActors(csvMappingResults).GetAwaiter().GetResult();
watch.Stop();
Console.WriteLine($"Actors (1); Execution time: {watch.ElapsedMilliseconds} ms");
watch.Restart();
weatherService.CalculateMediumTemperatureByActors(csvMappingResults, 3).GetAwaiter().GetResult();
watch.Stop();
Console.WriteLine($"Actors (3); Execution time: {watch.ElapsedMilliseconds} ms");
}
public async Task WhenErrorOnRetrievingWeatherData_PassResponseOn()
{
var locationData = new List <WeatherLocation>
{
new WeatherLocation
{
Title = "Place",
WhereOnEarthId = 123456
}
};
var moqClient = new Mock <IWeatherServiceClient>();
moqClient
.Setup(m => m.GetLocation(It.IsAny <string>()))
.ReturnsAsync(new ProcessResponse <List <WeatherLocation> >(locationData).Success());
moqClient
.Setup(m => m.GetWeatherData(It.IsAny <int>()))
.ReturnsAsync(new ProcessResponse <WeatherData>().Error("Something happened"));
var service = new WeatherService(moqClient.Object);
var result = await service.GetWeatherData("Test");
result.Should().BeEquivalentTo(new ProcessResponse <WeatherData>().Error("Something happened"));
}
public async void FetchWeatherData_ReturnShouldContainDataFromAPI()
{
var data = await WeatherService.FetchWeatherData();
Assert.NotNull(data?.Temperature);
Assert.NotNull(data?.Humidity);
}
/// <summary>
/// Populates the page with data.
/// </summary>
/// <param name="item">Item containing data.</param>
/// <returns></returns>
public async Task SelectItemAsync(object item)
{
SelectedItem = item;
var pos = (SelectedItem as MapElementItem).GetPosition();
weatherControl.Weather = await WeatherService.GetWeatherAsync(pos.Latitude, pos.Longitude);
}
public async Task Getting_weather_for_valid_city_should_return_proper_data()
{
// Arrange
var response = new CurrentWeather
{
Name = "London",
Main = new Main {
Temp = 30
},
Weather = new List <Api.Models.Weather>
{
new Api.Models.Weather {
Main = "Dizzy", Icon = "01d"
}
}
};
var service = new WeatherService(GetClientWithResponse(response));
// Act
var data = await service.GetCurrentWeather("London");
// Assert
data.CityName = "London";
data.Description.Should().Be("Dizzy");
data.Icon.Should().Be("01d");
data.Temperature.Should().Be(30);
}
static void Main(string[] args)
{
WeatherService ws = new WeatherService();
currentWind = ws.GetCurrentWeather().wind;
Console.WriteLine("Harbor Control Console System");
Console.WriteLine("------------------------------------------");
Console.WriteLine($"Current wind speed is : {currentWind.speed}");
//2 speedboats, 1 sailboat, 1 cargo
generateInitialBoats();
//Get boat into the perimeter GetAllowedBoat();
var allowBoat = GetAllowedBoat();
while (!allowBoat)
{
allowBoat = GetAllowedBoat();
}
getAllowedBoat();
var boatWithinPerimeter = boats.Dequeue();
BoatInPerimeter(boatWithinPerimeter);
var timeToDock = GetTime(boatWithinPerimeter.speed);
Task.Delay(timeToDock).Wait();
displayBoatDocked(boatWithinPerimeter);
ScheduleBoats();
// TODO: Random boat generator method to be called. Could not be completed due to time constraint
}
public Basic_WeatherObservablePage()
{
InitializeComponent();
var cities = new string[] { "Brussels", "Mechelen", "Hasselt" };
IObservable <WeatherCondition> weatherFeed =
WeatherService.GetCurrentConditions(cities);
#region Observer
var weatherObserver = weatherFeed
.ObserveOn(SynchronizationContext.Current)
.Subscribe(
wc => Output += $"{wc.City}: {wc.Text}\n",
e => new MessageDialog(e.Message, "Oops, an error").ShowAsync(),
() => new MessageDialog("Completed").ShowAsync());
#endregion
#region alternatives
//LoadWeather(cities);
//WeatherService.StreamWeatherConditions(cities, (wc) => Output += $"{wc.City}: {wc.Text}\n");
#endregion
}
private async Task RefreshWeatherData()
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
var weather = new WeatherService(ApplicationDataController.GetValue(KeyNames.OpenWeatherMapApiKey, string.Empty), new CultureInfo(ApplicationLanguages.PrimaryLanguageOverride));
WeatherData weatherData = null;
try
{
//weatherData = await weather.GetWeatherDataForCity(ApplicationDataController.GetValue(KeyNames.WeatherZip, string.Empty), ApplicationDataController.GetValue(KeyNames.WeatherCountry, string.Empty));
weatherData = await weather.GetWeatherDataForCity(ApplicationDataController.GetValue(KeyNames.WeatherCityName, string.Empty));
}
catch (WeatherServiceException weatherServiceException)
{
await ShowMessageDialogIfSupported(weatherServiceException.Message, "Error");
}
if (weatherData == null)
{
await ShowMessageDialogIfSupported(Strings.UnableToConnectToWeatherService, Strings.Error);
}
else
{
WeatherIcon.Source = GetImageSourceFromUri(weatherData.WeatherIconUri.AbsolutePath);
LocationTxb.Text = Strings.Get(weatherData.Location);
if (string.IsNullOrEmpty(LocationTxb.Text))
{
LocationTxb.Text = weatherData.Location;
}
TemperatureTxb.Text = Math.Round(weatherData.Temp) + "°";
WeatherDescirptionTxb.Text = string.IsNullOrEmpty(weatherData.Description) ? string.Empty : weatherData.Description.ToLower();
}
});
}
//ActionResult<APixuWeatherReport>
public Object GetAccuWeatherReportCurrent(ApiRequest apirequest)
{
if ((apirequest.lat == null) || (apirequest.lon == null))
{
return(NotFound());
}
WeatherService obj = new WeatherService();
IDatabase db = AppConstant.rediscon.GetDatabase();
var projectData = db.StringGet("ACCUCurrent" + apirequest.Place + apirequest.RequestDate.date);
if (!string.IsNullOrEmpty(projectData))
{
Console.WriteLine("Get Data From Cache");
return(JsonConvert.DeserializeObject(projectData));
}
else
{
Console.WriteLine("Set Data in Cache");
db.StringSet("ACCUCurrent" + apirequest.Place + apirequest.RequestDate.date, obj.GetAccuWeatherReportLocID(apirequest.lat + "," + apirequest.lon));
projectData = db.StringGet("ACCUCurrent" + apirequest.Place + apirequest.RequestDate.date);
var projectData1 = JsonConvert.DeserializeObject <Accu>(projectData);
Console.WriteLine(projectData1.Key);
db.StringSet("ACCUCurrent" + apirequest.Place + apirequest.RequestDate.date, obj.GetAccuWeatherReport(projectData1.Key));
projectData = db.StringGet("ACCUCurrent" + apirequest.Place + apirequest.RequestDate.date);
return(JsonConvert.DeserializeObject(projectData));
}
}
public WeatherServiceTests()
{
var weatherRepository = Substitute.For <IWeatherRepository>();
weatherRepository.GetWeather(Arg.Any <string>(), Arg.Any <string>()).Returns(new WeatherModel());
this.weatherService = new WeatherService(weatherRepository);
}
public async Task TestForNotNullData(string country, string city)
{
WeatherService weatherService = MockData.GetService(false, country, city);
var response = await weatherService.GetAsync(country, city);
Assert.NotNull(response);
}
public IActionResult Weather(string city)
{
var service = new WeatherService();
var result = service.GetWeather(city).Result;
return(View(result));
}
public async Task Getting_weather_for_city_with_many_weather_elements_should_return_icon_and_description_from_first()
{
// Arrange
var response = new CurrentWeather
{
Weather = new List <Api.Models.Weather>
{
new Api.Models.Weather {
Main = "Rainy", Icon = "02d"
},
new Api.Models.Weather {
Main = "Dizzy", Icon = "01d"
},
}
};
var service = new WeatherService(GetClientWithResponse(response));
// Act
var data = await service.GetCurrentWeather("London");
// Assert
data.Description.Should().Be("Rainy");
data.Icon.Should().Be("02d");
}
public async Task GetWeather_InvalidParameters_OneOfParametersIsInvalidExceptionThrown(
string country, string city)
{
IWeatherService weatherService = new WeatherService();
await Assert.ThrowsAsync <InvalidParameters>(
(async() => await weatherService.GetWeather(country, city)));
}
/// <summary>
/// Handle the user selecting a zone to populate the views for desired weather conditions
/// </summary>
public void ZoneSelected(object sender, AdapterView.ItemSelectedEventArgs args)
{
var spinner = (Spinner)sender;
var item = spinner.GetItemAtPosition(args.Position);
var weatherOptions = new List <string>();
if (args.Position != 0)
{
weatherOptions = WeatherService.GetWeatherOptionsForZone(item.ToString());
weatherOptions.Insert(0, "Any");
}
var desiredElement = _view.FindViewById <MultiSelectionSpinner>(Resource.Id.DesiredSpinner);
var previousElement = _view.FindViewById <MultiSelectionSpinner>(Resource.Id.PreviousSpinner);
var weatherTable = _view.FindViewById <TableLayout>(Resource.Id.resultsTable);
desiredElement.Items = weatherOptions;
previousElement.Items = weatherOptions;
weatherTable.RemoveAllViews();
desiredElement.RequestLayout();
previousElement.RequestLayout();
weatherTable.RequestLayout();
}
public Object GetSunRiseSunSetData(ApiRequest apirequest)
{
//ActionResult<SunRiseSunSet>
if (apirequest.RequestDate.date == null)
{
apirequest.RequestDate.date = DateTime.Now.ToString("yyyy-MM-dd");
}
WeatherService obj = new WeatherService();
IDatabase db = AppConstant.rediscon.GetDatabase();
var projectData = db.StringGet("SunRiseSunSet" + apirequest.Place + apirequest.RequestDate.date);
if (!string.IsNullOrEmpty(projectData))
{
Console.WriteLine("Get Data From Cache");
return(JsonConvert.DeserializeObject(projectData));
}
else
{
Console.WriteLine("Set Data in Cache");
db.StringSet("SunRiseSunSet" + apirequest.Place + apirequest.RequestDate.date, obj.GetSunRiseSunSet(apirequest.RequestDate.date, apirequest.lat, apirequest.lon));
projectData = db.StringGet("SunRiseSunSet" + apirequest.Place + apirequest.RequestDate.date);
return(JsonConvert.DeserializeObject(projectData));
}
}
public void GetCityNames_When_city_entities_Then_city_names_correctly_returned()
{
var cityRepository = A.Fake <IRepository <CityEntity> >();
A.CallTo(() => cityRepository.GetAll()).Returns(new[]
{
new CityEntity {
Id = 1, Name = "city 1"
},
new CityEntity {
Id = 2, Name = "city 2"
},
new CityEntity {
Id = 3, Name = "city 3"
}
}.AsEnumerable());
var uow = A.Fake <IUnitOfWork>();
A.CallTo(() => uow.Repository <CityEntity>()).Returns(cityRepository);
var weatherService = new WeatherService(uow);
var expectedResult = new List <string> {
"city 1", "city 2", "city 3"
};
var gainedResult = weatherService.GetCityNamesAsync();
CollectionAssert.AreEqual(expectedResult, gainedResult.Result);
}
public async Task InitializeAsync()
{
var service = new WeatherService();
var forecast = await service.GetForecast();
Forecast = new ObservableCollection <WeatherForecast>(forecast);
}
public WeatherForecastController(
WeatherService weatherService,
ILogger <WeatherForecastController> logger)
{
_weatherService = weatherService;
_logger = logger;
}
public SearchPage()
{
InitializeComponent();
_tidalService = new TidalService();
_weatherService = new WeatherService();
howManyDays = "0";
}
static void Main(string[] args)
{
string pathToData;
if (!args.Any())
{
Console.WriteLine("No arguents passed assuming weather.dat file is in same directory as execcutable.");
pathToData = "./weather.dat";
}
else
{
pathToData = args[0];
}
if (!File.Exists(pathToData))
{
Console.WriteLine($"Could not find data: {pathToData}");
return;
}
var weatherData = new WeatherFileReader(pathToData).GetAll();
var dayWithSmallestTempSread = new WeatherService(weatherData).GetDayWithSmallestTempSpread();
Console.WriteLine($"The day with the samllest temperature spread is: {dayWithSmallestTempSread.Day}");
Console.ReadKey();
}
public Form2(IImagePathRepository imagePathRepository, IDayWeatherRepository dayWeatherRepository)
{
InitializeComponent();
_imagePathRepository = imagePathRepository;
_dayWeatherRepository = dayWeatherRepository;
Import();
tabControl1.TabPages.Clear();
foreach (UserControl uc in _controls)
{
TabPage tp = new TabPage();
var displayNameAttribute = uc.GetType().GetCustomAttribute(typeof(DisplayNameAttribute)) as DisplayNameAttribute;
if (displayNameAttribute != null)
{
tp.Text = displayNameAttribute.DisplayName;
}
if (uc is AddDayWeather addDayWeather)
{
addDayWeather.InitAll(_imagePathRepository, _dayWeatherRepository);
}
if (uc is WeatherView weatherView)
{
var weatherService = new WeatherService(_imagePathRepository, _dayWeatherRepository);
weatherView.ResourcesPath = weatherService.GetImagePathList();
weatherView.Items = weatherService.GetDayWeatherList();
}
uc.Dock = DockStyle.Fill;
tp.Controls.Add(uc);
tabControl1.TabPages.Add(tp);
}
}
public void Should_get_weather_DI()
{
IRestRequest myRequest = null;
var httpHelperMock = Mock.Create <IHttpHelper>();
Mock.Arrange(() => httpHelperMock.Execute <Weather>(Arg.IsAny <IRestRequest>()))
.DoInstead((IRestRequest request) => { myRequest = request; })
.Returns(() => new Weather {
ZipCode = "12345", TemperaturInFahrenheit = 68, WindSpeed = 8
})
.OccursOnce();
Mock.Arrange(() => httpHelperMock.GetRestRequest(Arg.AnyString, Arg.IsAny <Method>(), Arg.IsAny <DataFormat>()))
.Returns((string resource, Method method, DataFormat dataFormat) =>
{
var httpHelper = new HttpHelper("http://Foo/");
return(httpHelper.GetRestRequest(resource, method, dataFormat));
});
var ws = new WeatherService(httpHelperMock);
var weather = ws.GetWeatherForZip("04103");
Assert.AreEqual("12345", weather.ZipCode);
Assert.AreEqual(68, weather.TemperaturInFahrenheit);
Assert.AreEqual(8, weather.WindSpeed);
Assert.AreEqual("GET", myRequest.Method.ToString());
Assert.AreEqual("CurrentWeather/04103", myRequest.Resource);
}
public async void TestGetWeather()
{
var openForecast = Option <OpenWeathermapForecast>
.Some(new OpenWeathermapForecast { list = new WeatherList[] {} });
openWeathermapService.GetCurrentWeather(Arg.Any <int>())
.Returns(Task.FromResult(Option <OpenWeathermapCurrent> .Some(new OpenWeathermapCurrent())));
openWeathermapService.GetWeatherforecast(Arg.Any <int>())
.Returns(Task.FromResult(openForecast));
mapper.Map <OpenWeathermapCurrent, Backend.Weatherforecast.Service.Weather>(Arg.Any <OpenWeathermapCurrent>())
.Returns(new Backend.Weatherforecast.Service.Weather());
mapper.Map <WeatherList[], Backend.Weatherforecast.Service.Weather[]>(Arg.Any <WeatherList[]>())
.Returns(new Backend.Weatherforecast.Service.Weather[]
{ new Backend.Weatherforecast.Service.Weather {
Humidity = 42, Temperature = 13
} });
IWeatherService service = new WeatherService(logger, mapper, openWeathermapService,
TestUtilities.ZipcodeToCitiesProvider, citynamesIds);
var resultOpt = await service.GetWeather(TestUtilities.CityIdHamburg).ConfigureAwait(false);
resultOpt
.Some(result =>
{
Assert.NotNull(result);
Assert.Equal(42f, result.AverageHumidity);
Assert.Equal(13f, result.AverageTemperature);
})
.None(() => Assert.False(true, "Test Failed"));
}
public void GetRecipeDetails_CanLoadFromContext()
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite(connection)
.Options;
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
context.Weathers.AddRange(
new Weather {
Id = 1, Name = "Snow"
},
new Weather {
Id = 2, Name = "Summer"
},
new Weather {
Id = 3, Name = "Spring"
});
context.SaveChanges();
}
using (var context = new AppDbContext(options))
{
var service = new WeatherService(context);
var weather = service.GetRecipe(id: 2);
Assert.NotNull(weather);
Assert.Equal(2, weather.Id);
Assert.Equal("Summer", weather.Name);
}
}
public MainPage()
{
InitializeComponent();
WeatherService weatherService = new WeatherService();
weatherService.Get();
}
public async Task CalculatePointTyreDegradationTest_Invalid()
{
//e.g. Silverstone|Towcester|14,57
const double trackDegradationPoint = 57;
var dataManager = new DataManager();
await dataManager.LoadAndParseData();
var tyreDetailsViewModel = new TyreDetailsViewModel(dataManager.Tyres[0]);
var tyreCoefficient = tyreDetailsViewModel.TyreCoefficient;
double temperature = 0.0;
var weatherService = new WeatherService(new OpenWeatherMapApiConsumer(new WebClientConsumer()));
weatherService.GetTemperatureForLocationAsync("Towcester",
(object sender, EventArgs e) =>
{
if (e is TemperatureUpdatedEventArgs temperatureArgs)
{
temperature = temperatureArgs.NewTemperature;
}
});
var pointTyreDegradataion = TyrePlacementViewModel.CalculatePointTyreDegradation(trackDegradationPoint, tyreCoefficient, temperature);
var manualCalculation = (14 + temperature) / tyreCoefficient;
Assert.AreNotEqual(manualCalculation, pointTyreDegradataion);
}
//异步的方法完成以后触发wwsc_getWeatherbyCityNameCompleted事件。
void wwsc_getWeatherbyCityNameCompleted(object sender, WeatherService.getWeatherbyCityNameCompletedEventArgs e)
{
string[] strs = e.Result;
foreach (string str in strs)
{
Response.Write(str + "<br/>");
}
}
public void InteractsWithExternalWeatherService()
{
IWeatherDao wDao = new StubWeatherDao();
IAuditDBDao auditDbDao = new StubAuditDao();
WeatherService service = new WeatherService(wDao, auditDbDao);
Assert.AreEqual(80, service.GetCurrentWeather());
}
public UpdateTileTask()
{
userService = UserService.GetInstance();
weatherService = WeatherService.GetInstance();
userRespose = new GetUserRespose();
userCityRespose = new GetUserCityRespose();
weatherTypeRespose = new GetWeatherTypeRespose();
}
/// <summary>
/// Gets the updated weather and store it as a new record in the database
/// Further implementation to consdier:
/// - Depends on the scenario, you could choose async or sync database save
/// - Check last updated date time, prior to web service calls.
/// </summary>
/// <returns>The updated weather.</returns>
/// <param name="uri">URI.</param>
public async Task<Weather> GetUpdatedWeather (string uri)
{
var service = new WeatherService ();
var response = await service.FetchWeatherAsync (uri);
// // You could choose to save async as well, and return the response object directly to the front-end
var savedId = Save (response);
return response;
}
public void CanCallTheWeatherDao()
{
// arrange
StubWeatherDao stub = new StubWeatherDao();
WeatherService service = new WeatherService(stub);
// act
int result = service.CurrentTemp();
// assert
Assert.AreEqual(75, result);
}
public void UseMock()
{
Mock<IWeatherDao> mockWeatherDao = new Mock<IWeatherDao>();
Mock<IAuditDBDao> auditDbMock = new Mock<IAuditDBDao>();
WeatherService service = new WeatherService(mockWeatherDao.Object, auditDbMock.Object);
// Setting expectations
mockWeatherDao.Setup(x => x.getCurrent()).Returns(75);
Assert.AreEqual(75, service.GetCurrentWeather());
auditDbMock.Verify(x => x.LogRequest());
}
public void CanCallTheWeatherDao_WithMock()
{
// Arrange
Mock<IWeatherDao> mock = new Mock<IWeatherDao>();
WeatherService service = new WeatherService(mock.Object);
mock.Setup(x => x.GetCurrentTemperature()).Returns(32);
// Act
int result = service.CurrentTemp();
// Assert
Assert.AreEqual(32, result);
}
public IEnumerable<WeatherData> It_Try_Get_Xml_Temperature()
{
var location = new GeoLocation() { Latitude = (float)33.481048, Longitude = (float)-86.704159 };
var start = new DateTime(2004, 01, 01, 0, 0, 0);
var end = new DateTime(2016, 09, 24, 0, 0, 0);
var client = new WeatherServiceClient();
var dataXml = client.GetRelativeHumidity(location.Latitude, location.Longitude, start, end);
var data = new WeatherService().RelativeHumidity(location, start, end);
Assert.IsNotNullOrEmpty(dataXml);
return data;
}
static void Main(string[] args)
{
//var client = new WeatherServiceClient();
//var result = client.GetTemperature((float) 33.481048, (float) -86.704159, new DateTime(2012, 1, 1),
// DateTime.Now);
//Console.WriteLine(result);
//Console.ReadKey();
GeoLocation location = new GeoLocation() { Latitude = (float)33.481048, Longitude = (float)-86.704159 };
var start = new DateTime(2004, 01, 01, 0, 0, 0);
var end = new DateTime(2016, 09, 24, 0, 0, 0);
var data = new WeatherService().GetTemperature(location, start, end);
data = new WeatherService().RelativeHumidity(location, start, end);
}
public void CanConvertTemperature_ToString()
{
// arrange
Mock<IWeatherDao> mock = new Mock<IWeatherDao>();
WeatherService service = new WeatherService(mock.Object);
Temperature temp = new Temperature()
{
temp = 75,
scale = "F"
};
mock.Setup(x => x.ConvertToString(It.IsAny<Temperature>())).Returns("75 F");
// act
string result = service.convert(temp);
// assert
Assert.AreEqual("75 F", result);
}
public PivotPage()
{
this.InitializeComponent();
this.navigationHelper = new NavigationHelper(this);
this.navigationHelper.LoadState += this.NavigationHelper_LoadState;
this.navigationHelper.SaveState += this.NavigationHelper_SaveState;
this.NavigationCacheMode = Windows.UI.Xaml.Navigation.NavigationCacheMode.Required;
userService = UserService.GetInstance();
weatherService = WeatherService.GetInstance();
settingService = SettingService.GetInstance();
userRespose = new GetUserRespose();
userCityRespose = new GetUserCityRespose();
weatherRespose = new GetWeatherRespose();
weatherTypeRespose = new GetWeatherTypeRespose();
settingAutoUpdateTimeRepose = new GetSettingAutoUpdateTimeRepose();
}
public MyCityPage()
{
this.InitializeComponent();
this.navigationHelper = new NavigationHelper(this);
this.navigationHelper.LoadState += this.NavigationHelper_LoadState;
this.navigationHelper.SaveState += this.NavigationHelper_SaveState;
userService = UserService.GetInstance();
weatherService = WeatherService.GetInstance();
userRespose = new GetUserRespose();
userCityRespose = new GetUserCityRespose();
weatherTypeRespose = new GetWeatherTypeRespose();
weatherRespose = new GetWeatherRespose();
myCityPage = new ViewModel.MyCityPage();
myCityPageModelList = new List<ViewModel.MyCityPageModel>();
}
public async Task<WeatherForecast> GetCurrentWeatherByCityAsync(City city)
{
var u = new Uri("http://api.openweathermap.org/data/2.5/weather?q=" + city.Name + "," + city.Country + "&appid=" + API_KEY + "&lang=fr&units=metric");
//throw new NotImplementedException();
WeatherService s = new WeatherService();
HttpClient client = new HttpClient();
var json = await client.GetStringAsync(u);
var response = JsonConvert.DeserializeObject<CurrentWeatherModel.RootObject>(json);
WeatherForecast forecast = null;
DateTime dtDateTime = GetDateTime(response.dt);
return new WeatherForecast()
{
City = city,
Date = dtDateTime,
Description = response.weather.First().description,
MaxTemperature = response.main.temp_max,
MinTemperature = response.main.temp_min,
};
}
public MainPage()
{
this.navigationHelper = new NavigationHelper(this);
this.NavigationCacheMode = Windows.UI.Xaml.Navigation.NavigationCacheMode.Required;
userService = UserService.GetInstance();
weatherService = WeatherService.GetInstance();
settingService = SettingService.GetInstance();
colorService = ColorService.GetInstance();
userRespose = new GetUserRespose();
userCityRespose = new GetUserCityRespose();
weatherRespose = new GetWeatherRespose();
weatherTypeRespose = new GetWeatherTypeRespose();
settingAutoUpdateTimeRepose = new GetSettingAutoUpdateTimeRepose();
colorResponse = new GetColorRespose();
homePageModel = new HomePageModel();
this.InitializeComponent();
Loaded += MainPage_Loaded;
}
public void WeatherServiceGetLocationTest()
{
var webService = new Domain.WebServices.Fakes.StubIWeatherWebService
{
GetLocationString = s => new Location
{
Latitude = 11.1f,
Longitude = 22.2f,
LocationId = 1,
LocationText = "Göteborg",
PlaceCode = "abc"
}
};
var repo = new Domain.Repositories.Fakes.StubIWeatherRepository();
var w = new WeatherService(repo, webService);
var actual = w.GetLocation("Göteborg");
Assert.AreEqual(actual.LocationText, "Göteborg");
}
public void Init()
{
_weatherService = new WeatherService();
}
public void LookupWeather(string zipCode)
{
if (String.IsNullOrEmpty(zipCode) || (zipCode == _zipCode)) {
return;
}
_zipCode = zipCode;
WeatherService weatherService = new WeatherService();
_currentAsyncResult = weatherService.BeginGetWeather(zipCode, LookupWeatherCallback, weatherService);
RaisePropertyChanged("Weather", "IsLoading", "Status", "ZipCode");
}