public void Setup()
{
var kernel = new StandardKernel(new NinjectTestModule());
_db = kernel.Get <WeatherDb>();
_repository = new Repository <City>(_db);
}
public IActionResult Index()
{
var m = new Dashboard()
{
AvailableWidgets = _widgetProvider.LoadWidgets(),
SupportedStations = new Dictionary <System.Guid, IEnumerable <PublicStationData> >()
};
foreach (var widget in m.AvailableWidgets)
{
if (User.Identity.IsAuthenticated)
{
m.SupportedStations.Add(widget.Guid, _widgetProvider.GetSupportedStations(widget).Select(s => s.ToPublicStationData()));
}
else
{
m.SupportedStations.Add(widget.Guid, _widgetProvider.GetSupportedPublicStations(widget).Select(s => s.ToPublicStationData()));
}
}
if (User.Identity.IsAuthenticated)
{
using (var db = new WeatherDb())
{
LoadDashboardFromDatabase(db, ref m);
}
}
else
{
LoadDashboardFromSession(ref m);
}
return(View(m));
}
static void Main(string[] args)
{
// Connectionstring zur lokalen SQL Server Default Instance mit integrierter Security.
// Statt (local) kann auch . geschrieben werden.
string connection = "Server=(local);Database=WeatherDb;Trusted_Connection=True;";
try
{
// Using schließt die Verbindung nach dem Block.
using (WeatherDb db = new WeatherDb(connection))
{
Station found = db.GetStations().FirstOrDefault(s => s.S_ID == 1001);
Console.WriteLine($"Station 1001 is at {(found?.S_Location)}");
foreach (Measurement m in db.GetMeasurements(found.S_ID).Take(10))
{
Console.WriteLine($"{m.M_Date} {m.M_Temperature}°C");
}
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
}
Console.ReadKey();
}
bool ValidateRequest(RequestData data)
{
var requestTimestamp = Utils.DateTimeConverter.UnixTimestampToDateTime(data.Timestamp);
var success = false;
var diff = DateTime.UtcNow.Subtract(requestTimestamp);
if (diff.TotalSeconds < _options.Timeout && diff.TotalSeconds > 0)
{
using (var db = new WeatherDb())
{
var station = db.WeatherStation.First(s => s.Id.Equals(data.StationId));
if (!String.IsNullOrEmpty(station.Secret))
{
var secret = Encoding.ASCII.GetBytes(station.Secret);
var hmac = new HMACSHA1(secret);
var timestampBytes = Encoding.ASCII.GetBytes(data.Timestamp.ToString());
var hashBytes = hmac.ComputeHash(timestampBytes);
var hashString = hashBytes.ToHexString();
success = hashString.Equals(data.HMAC);
}
}
}
return(success);
}
IEnumerable <WeatherStation> GetStations()
{
using (var db = new WeatherDb())
{
var stationIds = Request.Query["s"].ToString().Split(",");
Func <string, WeatherStation> f = id => db.WeatherStation.First(s => s.Id.Equals(id));
return(stationIds.Select(f).ToArray());
}
}
public IActionResult Index()
{
using (var db = new WeatherDb())
{
var q = from s in db.WeatherStation
select s.ToPublicStationData();
return(View(q.ToArray()));
}
}
public IActionResult Index()
{
var message = "Upgrade not required.";
using (var db = new WeatherDb())
{
var info = db.MetaInfo.FirstOrDefault();
if (info == null)
{
var result = CreateDefaultRoles();
if (result.Succeeded)
{
var gen = new PasswordGenerator(includeLowercase: true, includeUppercase: true, includeNumeric: true, includeSpecial: true, passwordLength: 8);
var password = gen.Next();
result = CreateAdminUser(password);
if (result.Succeeded)
{
var admin = _userManager.FindByNameAsync("Admin").Result;
if (admin == null)
{
message = "Admin account not found.";
}
else
{
result = _userManager.AddToRoleAsync(admin, "Administrator").Result;
if (result.Succeeded)
{
info = new MetaInfo()
{
DBRevision = 1
};
db.Insert(info);
message = string.Format("Upgraded to database revision 1. \"Admin\" account with password \"{0}\" created.", password);
}
}
}
}
if (!result.Succeeded)
{
message = ErrorMessageFromResult(result);
}
}
}
return(Content(message));
}
LogEntry GetCurrentLogEntry(WeatherStation station)
{
using (var db = new WeatherDb())
{
var entry = db.LogEntry.Where(l => l.StationId.Equals(station.Id)).OrderByDescending(l => l.Timestamp).FirstOrDefault();
if (entry != null && DateTime.UtcNow.Subtract(entry.Timestamp).TotalHours <= CURRENT_LOG_ENTRY_HOURS_FILTER)
{
return(entry);
}
}
return(null);
}
public IActionResult Edit(string id)
{
using (var db = new WeatherDb())
{
var m = db.WeatherStation.FirstOrDefault(s => s.Id.Equals(id));
if (m == null)
{
return(NotFound());
}
return(View("EditStation", m));
}
}
public IActionResult Values(string id, string from, string to)
{
using (var db = new WeatherDb())
{
var station = db.WeatherStation.FirstOrDefault(s => s.Id.Equals(id));
if (station == null)
{
return(NotFound());
}
if (!station.IsPublic && !User.Identity.IsAuthenticated)
{
return(Forbid());
}
DateTime fromDate = DateTime.UtcNow;
DateTime toDate = DateTime.UtcNow;
Utils.DateTimeConverter.ParseDateTimeString(from, ref fromDate);
Utils.DateTimeConverter.ParseDateTimeString(to, ref toDate);
fromDate = Utils.DateTimeConverter.BeginningOfDay(fromDate);
toDate = Utils.DateTimeConverter.EndOfDay(toDate);
var q = from e in db.LogEntry
where e.StationId.Equals(id) && e.Timestamp >= fromDate && e.Timestamp <= toDate
select e;
var m = new Dictionary <string, object>();
var logValues = new List <object[]>();
foreach (var e in q)
{
logValues.Add(new object[]
{
e.Timestamp.ToLocalTime(),
Math.Round(e.Temperature, 2),
e.Pressure,
e.Humidity,
Math.Round(e.UV, 2)
});
}
m["aaData"] = logValues;
return(Json(m));
}
}
public IActionResult Available()
{
using (var db = new WeatherDb())
{
var q = from s in db.WeatherStation
select s;
if (!User.Identity.IsAuthenticated)
{
q = q.Where(s => s.IsPublic);
}
var stations = q.Select(s => s.ToPublicStationData());
return(Json(stations.ToArray()));
}
}
public IActionResult WeeklyOverview()
{
var station = GetStation();
using (var db = new WeatherDb())
{
var end = DateTime.UtcNow;
var start = Utils.DateTimeConverter.BeginningOfDay(end.AddDays(-6));
var m = new LogEntries()
{
StationName = station.Name,
Entries = db.LogEntry.Where(l => l.StationId.Equals(station.Id) && l.Timestamp >= start && l.Timestamp <= end).ToArray()
};
return(View(m));
};
}
public IActionResult Index(string id)
{
using (var db = new WeatherDb())
{
var station = db.WeatherStation.FirstOrDefault(s => s.Id.Equals(id));
if (station == null)
{
return(NotFound());
}
if (!station.IsPublic && !User.Identity.IsAuthenticated)
{
return(Forbid());
}
return(View(station));
}
}
public IActionResult Delete(string id)
{
using (var db = new WeatherDb())
{
db.BeginTransaction();
try
{
if (db.DataProvider.Name.Equals("SQLite"))
{
db.LogEntry
.Where(e => e.StationId.Equals(id))
.Delete();
db.DashbordFilter
.Where(f => f.StationId.Equals(id))
.Delete();
}
var q = from item in db.DashboardItem
join filter in db.DashbordFilter on item.Id equals filter.DashboardItemId into filters
where filters.Count() == 0
select item;
q.Delete();
db.WeatherStation
.Where(s => s.Id.Equals(id))
.Delete();
db.CommitTransaction();
}
catch (Exception ex)
{
db.RollbackTransaction();
throw ex;
}
return(Ok());
}
}
void LoadDashboardFromDatabase(WeatherDb db, ref Dashboard dashboard)
{
var selectedItems = new List <SelectedDashboardItem>();
var user = _userManager.GetUserAsync(User).Result;
var dashboardItems = db.DashboardItem.Where(item => item.UserId.Equals(user.Id));
foreach (var dashboardItem in dashboardItems)
{
var widget = dashboard.AvailableWidgets.FirstOrDefault(w => w.Guid.Equals(new Guid(dashboardItem.WidgetId)));
if (widget != null)
{
if (_widgetProvider.ValidateStationIds(widget, dashboardItem.Filters.Select(f => f.StationId)))
{
selectedItems.Add(SelectedDashboardItem.Build(dashboardItem, widget));
}
}
}
dashboard.Items = selectedItems;
}
public IActionResult Create(WeatherStation m)
{
if (TryValidateModel(m))
{
using (var db = new WeatherDb())
{
db.BeginTransaction();
try
{
if (db.WeatherStation.Any(s => s.Name.ToLower().Equals(m.Name.ToLower())))
{
ViewData["ValidationError"] = "A weather station with the given name does already exist.";
}
else
{
db.Insert(m);
db.CommitTransaction();
return(Redirect("/WeatherStations"));
}
}
catch (Exception ex)
{
db.RollbackTransaction();
throw ex;
}
}
}
else
{
ViewData["ValidationError"] = "Couldn't validate input, please check entered data.";
}
return(View("CreateStation", m));
}
public Repository(WeatherDb db)
{
_db = db;
_set = _db.Set <T>();
}
public WeatherForecastController(WeatherDb weatherDb, IAccuWeatherAPI accuWeatherAPI)
{
this.weatherDb = weatherDb;
this.accuWeatherAPI = accuWeatherAPI;
}
