public static List <DataHolder> GetAverageTemperatures <T>()
{
List <DataHolder> averageTemperatures = new List <DataHolder>();
Type t = typeof(T);
using (var context = new TemperatureDBContext())
{
if (t == typeof(Outdoor))
{
averageTemperatures = context.Outdoors
.AsEnumerable()
.GroupBy(indoor => Dates.FormatDate(indoor.Date))//grupperar år-månad-dag
.Select(grp => new DataHolder(date: grp.Key,
value: AverageTemperatureOutdoor(grp)))
.OrderByDescending(data => data.Value) //Value är i den här contexten Medel temperatur
.ToList();
}
else if (t == typeof(Indoor))
{
averageTemperatures = context.Indoors
.AsEnumerable()
.GroupBy(indoor => Dates.FormatDate(indoor.Date))
.Select(grp => new DataHolder(date: grp.Key, value: AverageTemperatureIndoor(grp)))
.OrderByDescending(data => data.Value)
.ToList();
}
else
{
throw new NotImplementedException(message: "Type not implemented" + typeof(T));
}
return(averageTemperatures);
}
}
public static List <DataHolder> GetAverageHumidities <T>()
{
List <DataHolder> averageHumidities = new List <DataHolder>();
Type t = typeof(T);
using (var context = new TemperatureDBContext())
{
//beroende på vilken typ T är så väljs tabell
if (t == typeof(Outdoor))
{
averageHumidities = context.Outdoors
.AsEnumerable()
.GroupBy(outdoor => Dates.FormatDate(outdoor.Date))//medel fuktighet för datumet (gruppen)
.Select(grp => new DataHolder(date: grp.Key,
value: AverageHumidityOutdoor(grp)))
.OrderBy(data => data.Value) //Value är i det här fallet Medelluftfuktighet
.ToList();
}
else if (t == typeof(Indoor))
{
averageHumidities = context.Indoors
.AsEnumerable()
.GroupBy(indoor => Dates.FormatDate(indoor.Date))
.Select(grp => new DataHolder(date: grp.Key,
value: AverageHumidityIndoor(grp)))
.OrderBy(data => data.Value)
.ToList();
}
return(averageHumidities);
}
}
public static double AverageTemperatureSpecifiedDate <T>(DateTime date)
{
double temperature;
Type t = typeof(T);
using (var context = new TemperatureDBContext())
{
if (t == typeof(Outdoor))
{
temperature = context.Outdoors.AsEnumerable()
.GroupBy(outdoor => Dates.FormatDate(outdoor.Date)) //grupperar på år-månad-dag
.Where(group => group.Key == date) //väljer den grupp som har det datum som kommer från DatePicker
.Select(AverageTemperatureOutdoor) //väljer värdet för medeltemperaturen
.FirstOrDefault(); //första eller 0
}
else if (t == typeof(Indoor))
{
temperature = context.Indoors.AsEnumerable()
.GroupBy(indoor => Dates.FormatDate(indoor.Date))
.Where(group => group.Key == date)
.Select(AverageTemperatureIndoor)
.FirstOrDefault();
}
else
{
throw new NotImplementedException(message: "Type " + typeof(T) + "not implemented");
}
return(temperature);
}
}
/// <summary>
/// Gets all DateTime objects from the table
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>List of DateTimes for the specified type</returns>
public static List <DateTime> ExtractDates <T>()
{
Type t = typeof(T);
using (var context = new TemperatureDBContext())
{
//kollar vilken typ det är
if (t == typeof(Indoor))
{
return(context.Indoors.AsEnumerable()
.GroupBy(indoorData => FormatDate(indoorData.Date)) //grupperar efter datum
.Select(group => group.Key) //väljer datumet i format yyyy-DD-mm
.OrderBy(date => date) //sorterar på datumet
.ToList());
}
else
{
return(context.Outdoors.AsEnumerable()
.GroupBy(outdoorData => FormatDate(outdoorData.Date))
.Select(group => group.Key)
.OrderBy(date => date)
.ToList());
}
}
}
private void medianHumidity_Click(object sender, RoutedEventArgs e)
{
using (var context = new TemperatureDBContext())
{
bool indoorTable = indoorRadioButton.IsChecked.Value;
if (indoorTable)
{
dataGrid.ItemsSource = SearchDatabase.GetAverageHumidities <Indoor>();
}
else
{
dataGrid.ItemsSource = SearchDatabase.GetAverageHumidities <Outdoor>();
}
}
}
public static List <MoldRisk> ChanceOfMold <T>()
{
//mögelrisk =((fuktighet -78) * (temperatur/15))/0,22
Type t = typeof(T);
List <MoldRisk> listOfMoldRisks = new List <MoldRisk>();
using (var context = new TemperatureDBContext())
{
if (t == typeof(Outdoor))
{
listOfMoldRisks = context.Outdoors.AsEnumerable()
.GroupBy(outdoor => Dates.FormatDate(outdoor.Date)) //grupperar på datum yyyy-MM-dd
.Select(group => new MoldRisk(date: group.Key,
humidity: group.Average(grp => grp.Humidity), //medel fuktighet för datumet (gruppen)
temperature: group.Average(grp => grp.Temperature))) //medel temp för datumet (gruppen)
.OrderBy(moldChance => moldChance.RiskPercent) //sorterar på mögelrisk
.ToList();
}
else if (t == typeof(Indoor))
{
listOfMoldRisks = context.Indoors
.AsEnumerable()
.GroupBy(indoor => Dates.FormatDate(indoor.Date))
.Select(group => new MoldRisk(date: group.Key,
humidity: group.Average(grp => grp.Humidity),
temperature: group.Average(grp => grp.Temperature)))
.OrderBy(moldChance => moldChance.RiskPercent)
.ToList();
}
else
{
throw new NotImplementedException();
}
return(listOfMoldRisks);
}
}
public static void Verify()
{
bool dbCreatedNow;
bool dataInOutdoorTable;
bool dataInIndoorTable;
using (var context = new TemperatureDBContext())
{
//finns inte databasen och tabellerna skapas dom här
dbCreatedNow = context.Database.EnsureCreated();
dataInOutdoorTable = context.Outdoors.Any();
dataInIndoorTable = context.Indoors.Any();
if (dbCreatedNow)
{
MessageBox.Show("Tables created now=" + dbCreatedNow);
}
}
CheckIfDataInTables(dataInIndoorTable, dataInOutdoorTable);
//FreeConsole();
}
public static DateTime?FindAutumnStart()
{
DateTime firstDateToCheck = new DateTime(2016, 08, 01); // hösten börjar tidigast 1a augusti
DateTime?autumnStartDate = null;
using (var context = new TemperatureDBContext())
{
var groupedByDate = context.Outdoors.AsEnumerable()
.Where(outdoor => outdoor.Date >= firstDateToCheck) //alla datum senare än tidigaste höstdatumet
.GroupBy(outdoor => Dates.FormatDate(outdoor.Date)) //grupperar på datum yyyy-MM-dd
.Where(AutumnTemperatureRange) //där temperaturen är under 10 och över 0
.OrderBy(group => group.Key) //grupperar på datumet i fallande ordning
.ToList();
foreach (var grp in groupedByDate)
{
DateTime startDate = grp.Key;
//kollar hur många dagar i följd det finns i groupedByDate,
//antalet dagar det är innan startDate + 4 dagar
var followingDays = groupedByDate.Count(group => FiveDaysInARow(startDate, group.Key));
//om det finns 5 dagar i följd där medeltemperaturen är över 0 och under 10 så är det meterologisk höst
if (followingDays >= 5)
{
//då sätts autumnStartDate till det datumet som kollades
autumnStartDate = startDate;
break;
}
else
{
continue; //annars fortsätter loopen
}
}
}
return(autumnStartDate);
}
public static DateTime?FindWinterStart()
{
DateTime firstDateToCheck = new DateTime(2016, 08, 01); //vintern börjar tidigast den 1a augusti
DateTime?winterStartDate = null;
using (var context = new TemperatureDBContext())
{
var groupedByDate = context.Outdoors.AsEnumerable()
.Where(outdoor => outdoor.Date >= firstDateToCheck) //allt som är senare än firstDate
.GroupBy(outdoor => Dates.FormatDate(outdoor.Date)) //grupperar dom
.OrderBy(group => group.Key)
.Where(WinterTemperatureRange)
.ToList();
foreach (var grp in groupedByDate)
{
//Key är yyyy-MM-dd i format
DateTime firstDate = grp.Key;
var followingDays = groupedByDate.Count(group => FiveDaysInARow(firstDate, group.Key));
if (followingDays >= 5)
{
//om det finns minst 5 dagar i följd där medeltemperaturen är under 0 så är det meterologisk vinter
winterStartDate = firstDate;
break;
}
else
{
continue;
}
}
}
return(winterStartDate);
}
/// <summary>
/// Startar en ny transaktion där datat läggs in i databasen, beroende på vilken typ T är
///
/// </summary>
/// <typeparam name="T"></typeparam>
public static void ImportToDB <T>()
{
//format "2016 - 05 - 31 13:58:30,Inne,24.8,42";
string[] temperatureFileRows;
Type t = typeof(T);
if (t == typeof(Outdoor))
{
temperatureFileRows = File.ReadAllLines(Directory.GetCurrentDirectory() + @"\TemperaturData.csv")
.Where(line => line.Contains($",Ute,"))
.ToArray();
}
else
{
temperatureFileRows = File.ReadAllLines(Directory.GetCurrentDirectory() + @"\TemperaturData.csv")
.Where(line => line.Contains($",Inne,"))
.ToArray();
}
int i = 1;
using (var context = new TemperatureDBContext())
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
foreach (string row in temperatureFileRows)
{
string consoleOutput = "";
string[] rowData = row.Split(',');
DateTime dateFromFile = DateTime.Parse(rowData[0]);
double temperatureFromFile = double.Parse(rowData[2].Replace('.', ',')); //ersätter . med , för att kunda köra parse
int humidityFromFile = int.Parse(rowData[3]);
if (t == typeof(Indoor))
{
Indoor temperatureIndoor = new Indoor()
{
Date = dateFromFile,
Temperature = temperatureFromFile,
Humidity = humidityFromFile
};
context.Indoors.Add(temperatureIndoor);
consoleOutput = $"#{i}. Added indoor date: {temperatureIndoor.Date}," +
$"\n\t Deg: {temperatureIndoor.Temperature} Hum: {temperatureIndoor.Humidity}";
}
else
{
Outdoor temperatureOutdoor = new Outdoor()
{
Date = dateFromFile,
Temperature = temperatureFromFile,
Humidity = humidityFromFile
};
context.Outdoors.Add(temperatureOutdoor);
consoleOutput = $"#{i}. Added outdoor date: {temperatureOutdoor.Date}," +
$"\n\t Deg: {temperatureOutdoor.Temperature} Hum: {temperatureOutdoor.Humidity}";
}
Console.WriteLine(consoleOutput);
i++;
}
Console.WriteLine("Saving changes please wait...");
context.SaveChanges();
Console.WriteLine("Done! press any key to continue");
Console.ReadKey();
}
catch (Exception e)
{
Console.WriteLine(e.Message + "\n\t" + e.InnerException);
transaction.Rollback();
}
finally
{
Console.WriteLine("Comitting please wait...");
transaction.Commit();
}
}
}
}
