public async Task <IActionResult> PutForecast(int id, Forecast forecast)
{
if (id != forecast.Id)
{
return(BadRequest());
}
_context.Entry(forecast).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ForecastExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutWeather(long id, Weather weather)
{
if (id != weather.Id)
{
return(BadRequest());
}
_context.Entry(weather).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WeatherExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutTemp(long id, Temp temp)
{
if (id != temp.id)
{
return(BadRequest());
}
_context.Entry(temp).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TempExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <HttpStatusCode> WeatherReading([FromBody] WeatherReading reading)
{
try
{
var dbPlace = _context.Place.Where(p => p.Name == reading.Place.Name).FirstOrDefault();
if (dbPlace == null)
{
await _context.Place.AddAsync(reading.Place);
await _context.SaveChangesAsync();
dbPlace = await _context.Place.FirstOrDefaultAsync(w => w.Lat == reading.Place.Lat && w.Long == reading.Place.Long);
}
reading.Place = dbPlace;
await _context.WeatherReading.AddAsync(reading);
await _context.SaveChangesAsync();
await SendMessage(reading);
return(HttpStatusCode.Accepted);
}
catch (Exception e)
{
return(HttpStatusCode.InternalServerError);
}
}
public async Task <IActionResult> Create([Bind("Id,AutumnStart,AutumnDateTime,WinterStart,WinterDateTime")] MeteorologicalSeason meteorologicalSeason)
{
if (ModelState.IsValid)
{
DateTime WinterCheck = new DateTime(2016, 10, 01);
DateTime AutumnCheck = new DateTime(2016, 10, 01);
var Autumn = MeteorologicalSeason.AutumnDate(_context, AutumnCheck);
var Winter = MeteorologicalSeason.WinterDate(_context, WinterCheck);
if (Autumn == null)
{
meteorologicalSeason.AutumnStart = "Hösten kom aldrig 2016";
}
if (Winter == null)
{
meteorologicalSeason.WinterStart = "Vintern kom aldrig 2016";
}
if (Winter != null)
{
meteorologicalSeason.WinterStart = "Vintern faller på detta datum 2016";
}
if (Autumn != null)
{
meteorologicalSeason.AutumnStart = "Hösten faller på detta datum 2016";
}
meteorologicalSeason.AutumnDateTime = Autumn;
meteorologicalSeason.WinterDateTime = Winter;
_context.Add(meteorologicalSeason);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(meteorologicalSeason));
}
public async Task <ActionResult <WeatherForecast> > TodayWeatherFromCityName(string name)
{
WeatherForecast currentForecast = await _owm.GetWeatherByName(name);
_context.WeatherForecasts.Add(currentForecast);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(TodayWeatherFromCityName), currentForecast));
}
public async Task <AuthenticationResult> RefreshTokenAsync(string token, string refreshToken)
{
var validatedToken = GetPrincipalFromToken(token);
if (validatedToken == null)
{
return(new AuthenticationResult(Errors.InvalidToken));
}
//var expiryDateUnix =
// long.Parse(validatedToken.Claims.Single(x => x.Type == JwtRegisteredClaimNames.Exp).Value);
//var expiryDateTimeUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
// .AddSeconds(expiryDateUnix);
//if (expiryDateTimeUtc < DateTime.UtcNow)
//{
// return new AuthenticationResult(Errors.TokenExpired);
//}
var jti = validatedToken.Claims.Single(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
var storedRefreshToken = await _context.RefreshTokens.SingleOrDefaultAsync(x => x.Token == refreshToken);
if (storedRefreshToken == null)
{
return(new AuthenticationResult(Errors.TokenDoesntExist));
}
if (DateTime.UtcNow > storedRefreshToken.ExpiryDate)
{
return(new AuthenticationResult(Errors.RefreshTokenExpired));
}
if (storedRefreshToken.Invalidated)
{
return(new AuthenticationResult(Errors.RefreshTokenInvalid));
}
if (storedRefreshToken.Used)
{
return(new AuthenticationResult(Errors.RefreshTokenUsed));
}
if (storedRefreshToken.JwtId != jti)
{
return(new AuthenticationResult(Errors.RefreshTokenDoesntMatchJwT));
}
storedRefreshToken.Used = true;
_context.RefreshTokens.Update(storedRefreshToken);
await _context.SaveChangesAsync();
var user = await _userManager.FindByIdAsync(validatedToken.Claims.Single(x => x.Type == "id").Value);
return(await GenerateAuthenticationResultForUserAsync(user));
}
public async Task <IActionResult> Create([Bind("date,clocktime,temperature,humidity,airpressure")] Weatherinfo weatherinfo)
{
if (ModelState.IsValid)
{
_context.Add(weatherinfo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(weatherinfo));
}
public async Task <IActionResult> Create([Bind("Id,SelectDate,AvgTemp,AvgHum,MouldRisk")] InformationTableIndoor informationTableIndoor)
{
if (ModelState.IsValid)
{
_context.Add(informationTableIndoor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(informationTableIndoor));
}
public async Task <IActionResult> Post([FromBody] Contracts.WeatherReport weatherReport)
{
var stadium = await context.Stadiums.Where(s => s.Name == weatherReport.Stadium).FirstOrDefaultAsync();
if (stadium == null)
{
return(BadRequest($"No stadium could be found by name {weatherReport.Stadium}"));
}
var model = new WeatherReport()
{
CreatedDate = DateTimeOffset.Now,
EmailAddress = weatherReport.EmailAddress,
ReportTime = weatherReport.ReportTime.Value,
Stadium = stadium,
TemperatureDegreesFahrenheit = weatherReport.TemperatureDegreesFahrenheit.Value,
WeatherDescription = weatherReport.WeatherDescription
};
stadium.CurrentWeather = model;
await context.SaveChangesAsync();
return(Ok());
}
public async Task <bool> PostTemperature(Temperature temperature)
{
var newTemperature = _context.Temperatures.Add(temperature);
await _context.SaveChangesAsync();
return(true);
}
public async Task <bool> PostPressure(BarometicPressure pressure)
{
var addedPressure = _context.Pressures.Add(pressure);
await _context.SaveChangesAsync();
return(true);
}
public async Task <ActionResult <Contact> > PostContact([FromBody] NewContact newContact)
{
var contact = _mapper.Map <Contact>(newContact);
using var db = new WeatherContext();
db.Contacts.Add(contact);
await db.SaveChangesAsync();
return(CreatedAtAction(nameof(PostContact), new { id = contact.Id }, _mapper.Map <Contact>(contact)));
}
public async Task <DataRequest> CreateWeatherData(DataRequest weather)
{
var newRecord = await _context.DataRequest.AddAsync(weather);
DataRequest response = newRecord.Entity;
await _context.SaveChangesAsync();
return(response);
}
public async Task SaveWeatherAsync(Weather weather)
{
var weatherDb = await _dbContext.Weathers
.Where(x => x.City.Equals(weather.City, StringComparison.InvariantCultureIgnoreCase) &&
x.Date == weather.Date)
.FirstOrDefaultAsync();
if (weatherDb != null)
{
return;
}
await _dbContext.Weathers.AddAsync(weather);
await _dbContext.SaveChangesAsync();
}
public async Task <IActionResult> Post(string id)
{
var station = await _context.Stations.FindAsync(id);
if (station == null)
{
return(BadRequest($"No station found with id: {id}"));
}
string url = $"https://opendata-download-metobs.smhi.se/api/version/latest/parameter/1/station/{id}/period/corrected-archive/data.csv";
var httpClient = new HttpClient();
var response = await httpClient.GetStringAsync(url);
var readings = response.Split('\n').Skip(10).Where(line => line.Length > 0).Select(line =>
{
var row = line.Split(';');
var date = row[0];
var time = row[1];
var temperature = row[2];
var couldParse = DateTime.TryParse(date + " " + time, out var dateTime);
if (!couldParse)
{
return(null);
}
var temperatureValue = double.Parse(temperature.Replace('.', ','));
return(new TemperatureReading
{
Station = station,
Date = dateTime,
Temperature = temperatureValue
});
}).ToList();
await _context.TemperatureReadings.AddRangeAsync(readings.Where(x => x != null));
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Post(string stationId)
{
var station = await _db.WeatherStation.FindAsync(stationId);
if (station == null)
{
return(BadRequest($"No station found with id: {stationId}"));
}
var response = await _importer.ImportTemperatures(stationId);
var readings = response.Split('\n')
.Skip(10)
.Where(line => line.Length > 0)
.Select(line =>
{
var row = line.Split(';');
var date = row[0];
var time = row[1];
var temperature = row[2];
DateTime.TryParse(date + " " + time, out var dateTime);
var temperatureValue = double.Parse(temperature.Replace('.', ','));
return(new TemperatureInfo
{
WeatherStation = station,
Date = dateTime,
Temperature = temperatureValue
});
}).ToList();
await _db.Temperature.AddRangeAsync(readings.Where(x => x != null));
await _db.SaveChangesAsync();
return(Created("Temperature import completed!", "tjena tjena"));
}
/// <summary>
/// InsertWeatherData
/// </summary>
/// <param name="weather"></param>
/// <returns></returns>
public async Task <ZipCodeWeather> InsertWeatherData(ZipCodeWeather weather)
{
_logger.LogInformation("Insert Weather Data...");
var result = await _context.ZipCodeWeather.FindAsync(weather.ZipCode);
ZipCodeWeather response;
if (result != null)
{
// update
result.City = weather.City;
result.Country = weather.Country;
result.WeatherDesc = weather.WeatherDesc;
result.Temp = weather.Temp;
result.TempMin = weather.TempMin;
result.TempMax = weather.TempMax;
result.Wind = weather.Wind;
result.Cloud = weather.Cloud;
result.Pressure = weather.Pressure;
result.Longitude = weather.Longitude;
result.Latitude = weather.Latitude;
result.AsOfDate = weather.AsOfDate;
response = result;
}
else
{
// insert
var entityEntry = await _context.ZipCodeWeather.AddAsync(weather);
response = entityEntry.Entity;
}
var recordCount = await _context.SaveChangesAsync();
_logger.LogInformation($"{recordCount} records added or updated successfully.");
return(response);
}
public async Task <ActionResult <UserDto> > Register(UserDto regUser)
{
regUser.Email = regUser.Email.ToLower();
var emailExist = await _context.User.Where(u => u.Email == regUser.Email).FirstOrDefaultAsync();
if (emailExist != null)
{
return(BadRequest(new { errorMessage = "Email already in use" }));
}
User user = new User
{
Email = regUser.Email,
FirstName = regUser.FirstName,
LastName = regUser.LastName
};
user.PwHash = HashPassword(regUser.Password, BcryptWorkfactor);
_context.User.Add(user);
await _context.SaveChangesAsync();
return(CreatedAtAction("Get", new { id = user.UserId }, regUser));
}
public async Task <string> Post([FromQuery] string token, [FromQuery] Weather weather)
{
if (token != "xxxxx")
{
return("Token error.");
}
try
{
weather.DateTime = DateTime.Now;
weather.WeatherName = await GetXinzhiWeather();
await PostWeibo(weather);
_context.Weathers.Add(weather);
await _context.SaveChangesAsync();
return("True");
}
catch (Exception)
{
return("False");
}
}
public async Task DeleteAllAsync()
{
db.Towns.RemoveRange(db.Towns);
await db.SaveChangesAsync();
}
public Task <int> SaveChangesAsync()
{
return(_dbContext.SaveChangesAsync());
}
public async Task SaveAsync()
{
await db.SaveChangesAsync();
}
