IoT-Linq/Iot/Program.cs

/*--------------------------------------------------------------
*				HTBLA-Leonding / Class: 1xHIF
*--------------------------------------------------------------
*              Musterlösung-HA
*--------------------------------------------------------------
* Description: Iot
*--------------------------------------------------------------
*/

using System;
using System.Linq;
using System.Text;

using Iot.Tools;


Console.WriteLine("Iot");
Console.WriteLine("=====================");

#region Import Csvs

string fileNameActor           = "Actor.csv";
string fileNameActorType       = "ActorType.csv";
string fileNameMeasurement     = "Measurement.csv";
string fileNameMeasurementType = "MeasurementType.csv";

var actorsCsv = new CsvImport<Iot.CsvEntities.Actor>()
{
    DateFormat = "yyyy/MM/dd",
    TimeFormat = "HH:mm:ss",
    Encoding   = Encoding.UTF8
}.Read(fileNameActor);

var actorsTypeCsv = new CsvImport<Iot.CsvEntities.ActorType>()
{
    DateFormat = "yyyy/MM/dd",
    TimeFormat = "HH:mm:ss",
    Encoding   = Encoding.UTF8
}.Read(fileNameActorType);

var measurementsCsv = new CsvImport<Iot.CsvEntities.Measurement>()
{
    DateFormat = "yyyy/MM/dd",
    TimeFormat = "HH:mm:ss",
    Encoding   = Encoding.UTF8
}.Read(fileNameMeasurement);

var measurementTypesCsv = new CsvImport<Iot.CsvEntities.MeasurementType>()
{
    DateFormat = "yyyy/MM/dd",
    TimeFormat = "HH:mm:ss",
    Encoding   = Encoding.UTF8
}.Read(fileNameMeasurementType);

#endregion

#region Convert to Entities (with navigation properties)

var actorTypes = actorsTypeCsv.Select(at => new Iot.Entities.ActorType
{
    Id = at.Id,
    Name = at.Name
}).ToDictionary(x => x.Id, x => x);

var actors = actorsCsv.Select(a => new Iot.Entities.Actor
{
    Id = a.Id,
    Name = a.Name,
    FirstSeen = a.FirstSeen,
    ActorTypeId = a.ActorTypeId,
    ActorType = actorTypes[a.ActorTypeId]
}).ToList();

var measurementTypes = measurementTypesCsv.Select(mt => new Iot.Entities.MeasurementType
{
    Id = mt.Id,
    Name = mt.Name,
    Comment = mt.Comment
}).ToList();

var measurementTypeDict = measurementTypes.ToDictionary(x => x.Id);
var actorDict = actors.ToDictionary(a => a.Id);

var measurements = measurementsCsv.Select(m =>
{
    actorDict.TryGetValue(m.ActorId, out var actor);
    measurementTypeDict.TryGetValue(m.MeasurementTypeId, out var measurementType);
    
    return new Iot.Entities.Measurement
    {
        Id = m.Id,
        Time = m.Time,
        ActorId = m.ActorId,
        MeasurementTypeId = m.MeasurementTypeId,
        Value = m.Value,
        Actor = actor,
        MeasurementType = measurementType
    };
}).ToList();


// Populate Actor.Measurements using ToLookup (O(n) instead of O(n*m))
var measurementsByActor = measurements.ToLookup(m => m.ActorId);
foreach (var actor in actors)
{
    actor.Measurements = measurementsByActor[actor.Id].ToList();
}

// Populate MeasurementType.Measurements using ToLookup (O(n) instead of O(n*m))
var measurementsByType = measurements.ToLookup(m => m.MeasurementTypeId);
foreach (var measurementType in measurementTypes)
{
    measurementType.Measurements = measurementsByType[measurementType.Id].ToList();
}

// Populate ActorType.Actors using ToLookup (O(n) instead of O(n*m))
var actorsByType = actors.ToLookup(a => a.ActorTypeId);
foreach (var actorType in actorTypes.Values)
{
    actorType.Actors = actorsByType[actorType.Id].ToList();
}

#endregion

#region some Reports

Console.WriteLine("List of Actors");
Console.WriteLine("Id Name              Count");
Console.WriteLine("==========================");

var actorReport = actors
    .Select(a => new
    {
        a.Id,
        a.Name,
        Count = a.Measurements.Count
    })
    .OrderBy(a => a.Id);

foreach (var item in actorReport)
{
    Console.WriteLine($"{item.Id,2} {item.Name,-17} {item.Count,5}");
}

Console.WriteLine();
Console.WriteLine("List of Measurement-Types");
Console.WriteLine("Id Name              Count");
Console.WriteLine("==========================");

var measurementTypeReport = measurementTypes
    .Select(mt => new
    {
        mt.Id,
        mt.Name,
        Count = mt.Measurements.Count
    })
    .OrderBy(mt => mt.Id);

foreach (var item in measurementTypeReport)
{
    Console.WriteLine($"{item.Id,2} {item.Name,-17} {item.Count,5}");
}

Console.WriteLine();
Console.WriteLine("List of Actor by Measurement-Types");
Console.WriteLine("Actor          Measurement        Count         Min        Max");
Console.WriteLine("==============================================================");

var actorMeasurementReport = measurements
    .GroupBy(m => new
    {
        ActorName = m.Actor?.Name ?? "Unknown",
        MeasurementName = m.MeasurementType?.Name ?? "Unknown"
    })
    .Select(g =>
    {
        var values = g.Select(m => m.Value).ToList();
        return new
        {
            Actor = g.Key.ActorName,
            Measurement = g.Key.MeasurementName,
            Count = values.Count,
            Min = values.Min(),
            Max = values.Max()
        };
    })
    .OrderBy(r => r.Actor)
    .ThenBy(r => r.Measurement);

foreach (var item in actorMeasurementReport)
{
    Console.WriteLine($"{item.Actor,-14} {item.Measurement,-18} {item.Count,5} {item.Min,10:F2} {item.Max,10:F2}");
}

#endregion