public WeatherReply(WeatherQuery query, Weather weather, DateTime replyTime, Exception exception = null)
{
Query = query;
Weather = weather;
ReplyTime = replyTime;
Exception = exception;
}
public async Task <IActionResult> Get()
{
_logger.LogInformation($"User {User.Identity.Name} getting weather forecast.");
var query = new WeatherQuery();
var result = await _mediator.Send(query);
return(Ok(result));
}
private void Start()
{
weatherQuery = GetComponent <WeatherQuery>();
if (!weatherQuery)
{
Debug.LogError("WeatherQuery not on same Object!");
}
}
/// <summary>
/// Constructor
/// </summary>
public WeatherForm()
{
InitializeComponent();
ActiveControl = QueryBox;
client = new WebClient();
parser = new JavaScriptSerializer();
query = new WeatherQuery();
}
public async Task None(IDialogContext context, LuisResult result)
{
var query = new WeatherQuery
{
Location = result.Query
};
var message = await WeatherHub.GetWeather(query);
await context.PostAsync(message);
context.Wait(MessageReceived);
}
/// <summary>
/// 今天天气情况
/// </summary>
/// <returns></returns>
public string WeatherInfoToday()
{
try
{
var result = new WeatherQuery().QueryToday();
return(new ResultFormat(1, result).ToString());
}
catch (Exception ex)
{
LogHelper.GetInstance().Error(ex.ToString());
return(new ResultFormat(0, ex.ToString()).ToString());
}
}
public void SetUp()
{
cache = Substitute.For <IForecastsCache>();
cache.TryGetForecasts(DefaultCity, out _).Returns(false);
weatherSource = Substitute.For <IWeatherSource>();
weatherSource.GetWeatherFor(Arg.Any <string>(), Arg.Any <int>())
.Returns(new WeatherForecastResult());
watherController = new WeatherController(weatherSource, cache);
query = new WeatherQuery
{
City = DefaultCity,
DaysCount = 10
};
}
public async Task GetWeatherIntent(IDialogContext context, LuisResult result)
{
#if DEBUG
await context.PostAsync(FormatLuisResult(result));
#endif
var weatherQuery = new WeatherQuery();
if (result.TryFindEntity(ENTITY_LOCATION, out EntityRecommendation LocationRecommendation))
{
weatherQuery.Location = LocationRecommendation.Entity;
}
var weatherFormDialog = new FormDialog <WeatherQuery>(weatherQuery, this.BuildWeatherForm, FormOptions.PromptInStart, result.Entities);
context.Call(weatherFormDialog, this.ResumeAfterFormDialog);
}
public async Task <WeatherForecastResult> WeatherForecasts([FromQuery] WeatherQuery weatherQuery)
{
if (cache.TryGetForecasts(weatherQuery.City, out var cachedForecasts))
{
return(WeatherForecastResult.Successfull(cachedForecasts));
}
var weatherForecastResult = await weatherSource.GetWeatherFor(weatherQuery.City, weatherQuery.DaysCount);
if (weatherForecastResult.Status == Status.Success)
{
cache.UpdateCache(weatherQuery.City, weatherForecastResult.WeatherForecast);
}
return(weatherForecastResult);
}
// TODO переделать на общий алгоритм
public override WeatherReply Get(PlaceEnum place)
{
var query = new WeatherQuery(WeatherServiceEnum.Wunderground, place);
var uri = String.Format(UriPattern,
Config.Wunderground_ApiKey,
Config.Wunderground_Places_Codes[place]
);
var responseStr = HttpHelper.Get(new Uri(uri));
var weather = parser.Parse(responseStr);
var reply = new WeatherReply(query, weather, DateTime.Now);
return reply;
}
//requests current weather from server and implements main weather functionallity
public async void LoadWeather(string cityName)
{
WeatherQuery request = GetComponent <WeatherQuery>();
WeatherData data = await request.FetchWeatherData(cityName);
if (data != null)
{
displayCity.text = cityName;
temperature.text = string.Format("{0}°", data.main.temp);
currentWeather.text = data.weather[0].main;
int weatherId = data.weather[0].id;
weatherObject.WeatherScene = CodeToWeather(weatherId);
weatherObject.CloudRain.RainRate = CodeToRainIntenseity(weatherId);
weatherObject.ThunderstormRain.RainRate = CodeToRainIntenseity(weatherId);
weatherObject.CloudSnow.RainRate = CodeToSnowIntensity(weatherId);
}
else
{
throw new System.ArgumentNullException();
}
}
public async Task <WeatherInfo> GetWeatherAsync(WeatherQuery weatherQuery)
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(OpenWeatherBaseurl);
httpClient.DefaultRequestHeaders.Add("x-api-key", this.ApiKey);
string url = string.Format(Query, weatherQuery.Location, "Metric", "jp");
HttpResponseMessage response = await httpClient.GetAsync(url);
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Culture = new System.Globalization.CultureInfo("en-us");
return(JsonConvert.DeserializeObject <WeatherInfo>(json, settings));
}
else
{
return(null);
}
}
}
public static async Task <string> GetWeather(WeatherQuery query)
{
var service = GetWeatherService();
var responseBuilder = GetResponseBuilder();
if (query.IsForDate)
{
var weatherForecast = await service.GetWeatherForecast(
query.Location, query.DateRange, CancellationToken.None);
var message = responseBuilder.Build(weatherForecast, query.DateRange);
return(message);
}
else
{
var currentWeather = await service.GetCurrentWeather(
query.Location, CancellationToken.None);
var message = responseBuilder.Build(currentWeather);
return(message);
}
}
public async Task <List <WeatherForecastResponse> > Handle(WeatherQuery request, CancellationToken cancellationToken)
{
var forecasts = await _weatherService.GetWeatherForecast();
return(_mapper.MapWeatherForecastDtosToWeatherForecastResponses(forecasts.ToList()));
}
public virtual WeatherReply Get(WeatherQuery query)
{
throw new NotImplementedException();
}
public async void onBoot()
{
try
{
SettingsXML = XDocument.Load(await ApplicationData.Current.LocalFolder.OpenStreamForReadAsync("SettingsData.xml"));
StorageFile ProfilePictureFile = await ApplicationData.Current.LocalFolder.GetFileAsync("profile.jpg");
for (int i = 0; i < 2; i++)
{
await Task.Delay(1000);
CityYouSelected = theSettings.getWeatherQuery();
UnitTemperature = theSettings.isUnitTemperatureC();
theWeather = new Weather(CityYouSelected, UnitTemperature);
WeatherQuery theWeatherQuery = new WeatherQuery();
if (UnitTemperature == true)
{
UnitTemperatureString = "°C";
}
else
{
UnitTemperatureString = "°F";
}
MainPageInformation.TextAlignment = TextAlignment.Center;
UsernameText.TextAlignment = TextAlignment.Center;
DisplayNameText.TextAlignment = TextAlignment.Center;
await Task.Delay(100);
profilePicture.Source = new BitmapImage(new Uri(ProfilePictureFile.Path, UriKind.Absolute));
MainPageInformation.Text = "Weather Forecast for " + CityYouSelected + ":\nMin: " + theWeatherQuery.getMinTemp() +
UnitTemperatureString + "\tMax: " + theWeatherQuery.getMaxTemp() + UnitTemperatureString + "\nHumidity:\t" +
theWeatherQuery.getHumidity() + "%";
UsernameText.Text = "@" + theSettings.getUserQuery();
DisplayNameText.Text = theSettings.getNameQuery();
theExtras.LoadNews(NewsTextLine, new Uri("http://feeds.bbci.co.uk/news/world/rss.xml"));
}
}
catch (Exception e)
{
onBoot();
}
//This should get location from SettingsData.xml but i was waiting to finish the
// queries class. Now its hard coded to beirut. ---- DONE
// ------------ NVM now it gets location from queries. --------------------------//
//Options for weather we need to add= Celsius or Fahrenhiet. ---- DONE
// Metric or imperial measurement. --- DONE
// The xml has a lot of data we can use
//theArduino.UpdatingPinsThread(1);
}
private WeatherQuery GetWeatherQueryFromLuisResult(LuisResult result)
{
var weatherQuery = new WeatherQuery();
var locationEntity = result.Entities
.SingleOrDefault(a => a.Type == "builtin.weather.absolute_location");
var dateRangeEntity = result.Entities
.SingleOrDefault(a => a.Type == "builtin.weather.date_range");
weatherQuery.Location = locationEntity?.Entity;
if (dateRangeEntity != null)
{
CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
TextInfo textInfo = cultureInfo.TextInfo;
weatherQuery.DateRange = new DateRange
{
Name = textInfo.ToTitleCase(dateRangeEntity.Entity)
};
var dateValue = dateRangeEntity.Resolution["date"];
DateTimeOffset dt;
if (DateTimeOffset.TryParse(dateValue, out dt))
{
var startTs = dt.ToUnixTimeSeconds();
var endTs = startTs + Convert.ToInt64(TimeSpan.FromDays(1).TotalSeconds);
weatherQuery.DateRange.StartTs = startTs;
weatherQuery.DateRange.EndTs = endTs;
}
else
{
Regex weekendRegex = new Regex("(\\d{4})-W(\\d{2})-WE");
Regex weekRegex = new Regex("(\\d{4})-W(\\d{2})");
var weekendMatch = weekendRegex.Match(dateValue);
var weekMatch = weekRegex.Match(dateValue);
if (weekendMatch.Success)
{
var year = int.Parse(weekendMatch.Groups[1].Value);
var weekNumber = int.Parse(weekendMatch.Groups[2].Value);
var firstDayOfWeek = DateTimeHelper.FirstDayOfWeek(year, weekNumber);
var timestamp = firstDayOfWeek.ToUnixTimeSeconds();
var startTs = timestamp + Convert.ToInt64(TimeSpan.FromDays(5).TotalSeconds);
var endTs = timestamp + Convert.ToInt64(TimeSpan.FromDays(7).TotalSeconds);
weatherQuery.DateRange.StartTs = startTs;
weatherQuery.DateRange.EndTs = endTs;
}
else if (weekMatch.Success)
{
var year = int.Parse(weekMatch.Groups[1].Value);
var weekNumber = int.Parse(weekMatch.Groups[2].Value);
var firstDayOfWeek = DateTimeHelper.FirstDayOfWeek(year, weekNumber);
var timestamp = firstDayOfWeek.ToUnixTimeSeconds();
var startTs = timestamp;
var endTs = timestamp + Convert.ToInt64(TimeSpan.FromDays(7).TotalSeconds);
weatherQuery.DateRange.StartTs = startTs;
weatherQuery.DateRange.EndTs = endTs;
}
else
{
weatherQuery.DateRange.Name = "Today";
var startTs = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
var endTs = DateTimeOffset.UtcNow.AddDays(1).ToUnixTimeSeconds();
weatherQuery.DateRange.StartTs = startTs;
weatherQuery.DateRange.EndTs = endTs;
}
}
}
//weatherQuery.DateRange = new DateRange(
// DateTime.Now.AddDays(1).Date, DateTime.Now.AddDays(5).Date);
return(weatherQuery);
}
public void WeatherTest()
{
var weather = new WeatherQuery();
var result = weather.QueryToday();
}
public override WeatherReply Get(WeatherQuery query)
{
return concreteServices[query.WeatherService].Get(query.Place);
}
