public void Add(string weatherStationName, double temperature, double?windSpeed, double?airPressure, double?humidity, double?realFeeling, int?freezingLevel)
{
int weatherStationId = context.WeatherStations
.Where(x => x.Name == weatherStationName)
.Select(x => x.WeatherStationId)
.FirstOrDefault();
if (weatherStationId == 0)
{
throw new ArgumentException(ServiceExceptionMessage.InvalidWeatherParameterStationMessage, weatherStationName);
}
WeatherParameter parameter = new WeatherParameter()
{
DateTime = DateTime.Now,
TemperatureCelsius = temperature,
RealFeelingCelsius = realFeeling,
WindSpeed = windSpeed,
Humidity = humidity,
AirPressure = airPressure,
FreezingLevelInMeters = freezingLevel,
WeatherStationId = weatherStationId
};
context.WeatherParameters.Add(parameter);
context.SaveChanges();
}
public void Init()
{
_paramTerrain = (TerrainParameter)AssetDatabase.LoadAssetAtPath(_terrainParamPath, typeof(TerrainParameter));
_paramWeather = (WeatherParameter)AssetDatabase.LoadAssetAtPath(_weatherParamPath, typeof(WeatherParameter));
_paramTemperature = (TemperatureParameter)AssetDatabase.LoadAssetAtPath(_temperatureParamPath, typeof(TemperatureParameter));
_paramMana = (ManaParameter)AssetDatabase.LoadAssetAtPath(_manaParamPath, typeof(ManaParameter));
_paramRain = (RainParameter)AssetDatabase.LoadAssetAtPath(_rainParamPath, typeof(RainParameter));
_biomeDistribution = (BiomeDistribution)AssetDatabase.LoadAssetAtPath(_biomeDistributionPath, typeof(BiomeDistribution));
_terrainColor = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_terrainColorRangePath, typeof(ColorRangeDistribution));
_weatherColor = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_weatherColorRangePath, typeof(ColorRangeDistribution));
_manaColor = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_manaColorRangePath, typeof(ColorRangeDistribution));
_rainColor = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_rainColorRangePath, typeof(ColorRangeDistribution));
_serializedObj = new SerializedObject(this);
_propertyParamTerrain = _serializedObj.FindProperty("_paramTerrain");
_propertyParamWeather = _serializedObj.FindProperty("_paramWeather");
_propertyParamTemperature = _serializedObj.FindProperty("_paramTemperature");
_propertyParamMana = _serializedObj.FindProperty("_paramMana");
_propertyParamRain = _serializedObj.FindProperty("_paramRain");
_propertyBiomeDistribution = _serializedObj.FindProperty("_biomeDistribution");
_propertyTerrainColorRange = _serializedObj.FindProperty("_terrainColor");
_propertyWeatherColorRange = _serializedObj.FindProperty("_weatherColor");
_propertyManaColorRange = _serializedObj.FindProperty("_manaColor");
_propertyRainColorRange = _serializedObj.FindProperty("_rainColor");
_propertyWidth = _serializedObj.FindProperty("_width");
_propertyHeight = _serializedObj.FindProperty("_height");
_propertySeed = _serializedObj.FindProperty("_seed");
_noticeTxt = string.Empty;
_worldTexture = null;
_tileData = null;
_executor.Clear();
}
public void Get_ShouldReturnOk()
{
// Arrange
var date = DateTime.Now;
var expected = new WeatherDTO()
{
data = new List <WeatherItem> {
new WeatherItem {
precision = 10, pressure = 23, value = 30
}
},
location = new Location {
latitude = 44, longitude = 50
},
time = date
};
var parameter = new WeatherParameter {
Latitude = 44, Longitude = 50, Timestamp = date
};
var weatherServiceMock = new Mock <IWeatherService>();
weatherServiceMock.Setup(p => p.GetWeather(parameter)).Returns(Task.FromResult(expected));
// Act
var controller = new WeatherController(weatherServiceMock.Object);
// IHttpActionResult actionResult = controller.Get(44,50,date);
//var actionResult = actionResult as OkNegotiatedContentResult<WeatherDTO>;
//// Assert
//Assert.IsType<OkNegotiatedContentResult<WeatherDTO>>(actionResult);
}
public OpenWeather(WeatherParameter parameter)
{
Parameter = parameter;
Name = "OpenWeather";
ChangeParameter(parameter);
requestUrl = endPointUrl + "?" + $"lat={latitude}&lon={longitude}&units={units}&exclude={exclude}&lang={lang}&appid={apiKey}";
}
private void Initialize()
{
forecasts = new List <SiteWeatherForecast>();
currentForecast = new CityWeatherForecast("Not Stated", "Not Stated", "Not Stated", "Not Stated", "Not Stated");
currentSite = String.Empty;
currentParameter = WeatherParameter.Current;
updateSites = true;
}
public StormGlass(WeatherParameter parameter)
{
Parameter = parameter;
int timeOffset = 3 * 60 * 60;
Name = "StormGlass";
start = (((DateTimeOffset)DateTime.Now).ToUnixTimeSeconds() + timeOffset).ToString();
ChangeParameter(parameter);
requestUrl = endPointUrl + "?" + $"lat={latitude}&lng={longitude}¶ms={parameters}&source={source}&start={start}&end={end}&key={apiKey}";
}
public IHttpActionResult Get([FromUri] WeatherParameter param)
{
WeatherServiceWCF.OpenWeatherServiceClient client = new WeatherServiceWCF.OpenWeatherServiceClient();
string result = client.GetWeather(param);
JObject json = JObject.Parse(result);
return(Ok(json));
}
public static List <ISite> GetSites(WeatherParameter parameter)
{
var services = Host.CreateDefaultBuilder()
.ConfigureServices(services =>
services.AddSingleton <ISite, TomorrowIO>(svc => ConnectedSites.Contains(SitesName.TomorrowIO) ? new TomorrowIO(parameter) : null)
.AddSingleton <ISite, OpenWeather>(svc => ConnectedSites.Contains(SitesName.OpenWeather) ? new OpenWeather(parameter) : null)
.AddSingleton <ISite, StormGlass>(svc => ConnectedSites.Contains(SitesName.StormGlass) ? new StormGlass(parameter) : null)
)
.Build().Services;
return(services.GetServices <ISite>().Where(x => x != null).ToList());
}
public void ChangeParameter(WeatherParameter parameter)
{
Parameter = parameter;
switch (parameter)
{
case WeatherParameter.Current:
exclude = "minutely,hourly,daily,alerts";
break;
case WeatherParameter.Week:
exclude = "minutely,hourly,current,alerts";
break;
}
}
public void ChangeParameter(WeatherParameter parameter)
{
Parameter = parameter;
switch (parameter)
{
case WeatherParameter.Current:
end = start;
break;
case WeatherParameter.Week:
int weekOffset = 6 * 24 * 60 * 60;
end = (Convert.ToInt64(start) + weekOffset).ToString();
break;
}
}
public async Task <WeatherDTO> GetWeather(WeatherParameter weatherParameter)
{
string apiKey = "3cd60b9dd9a7da0d998b1831eb9c8376";
decimal latitude = weatherParameter.Latitude;
decimal longitude = weatherParameter.Longitude;
DateTime timestamp = weatherParameter.Timestamp;
string url = string.Format("http://api.openweathermap.org/pollution/v1/co/{0},{1}/{2}-{3}-{4}T{5}:{6}:{7}Z.json?appid={8}",
latitude, longitude, timestamp.Year, ToDateString(timestamp.Month), ToDateString(timestamp.Day), ToDateString(timestamp.Hour), ToDateString(timestamp.Minute), ToDateString(timestamp.Second), apiKey);
HttpClient httpClient = new HttpClient();
var response = await httpClient.GetAsync(url);
string responseBody = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <WeatherDTO>(responseBody));
}
public async Task <IHttpActionResult> Post(WeatherParameter weatherParameter)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid Parameters"));
}
var dto = await _weatherService.GetWeather(weatherParameter);
return(Ok(dto));
}
catch (Exception)
{
throw;
}
}
public IEnumerator GenerateWeatherMap(
int width,
int height,
float xOffset,
float yOffset,
WeatherParameter para,
IReturn <float[]> ret)
{
_width = width;
_height = height;
_para = para;
_varietyStatus = new WeatherVarietyStatus(xOffset, yOffset);
_weatherMap = new float[_width * _height];
yield return(_GenerateWeatherMap());
ret.Accept(_weatherMap);
}
public void ChangeParameter(WeatherParameter parameter)
{
var time = DateTime.Now;
Parameter = parameter;
switch (parameter)
{
case WeatherParameter.Current:
timeSteps = "current";
requestUrl = endPointUrl + "?" + $"location={location}&timezone={timeZone}&fields={fields}×teps={timeSteps}&units={units}&apikey={apiKey}";
break;
case WeatherParameter.Week:
startTime = time.ToString("s") + "Z";
timeSteps = "1d";
endTime = time.AddDays(6).ToString("s") + "Z";
requestUrl = endPointUrl + "?" + $"location={location}&timezone={timeZone}&startTime={startTime}&endTime=" +
$"{endTime}&fields={fields}×teps={timeSteps}&units={units}&apikey={apiKey}";
break;
}
}
public InfoDisplayer(string sourceName, WeatherParameter parameter)
{
this.sourceName = sourceName;
this.parameter = parameter;
}
public async Task <string> GetWeatherInfoStringAsync(WeatherParameter param)
{
return(await _httpClient.GetAsync(AmapUriConst.Weather, param));
}
public async Task <WeatherResponse> GetWeatherInfoAsync(WeatherParameter param)
{
return(await _httpClient.GetAsync <WeatherResponse>(AmapUriConst.Weather, param));
}
public TomorrowIO(WeatherParameter parameter)
{
Parameter = parameter;
Name = "TomorrowIO";
ChangeParameter(parameter);
}
