public void TestCaginMeLos()
{
BO4E.StaticLogger.Logger = new Microsoft.Extensions.Logging.Debug.DebugLogger("Testlogger", (log, level) => { return(true); });
var result = new Dictionary <string, string>()
{
{ "DE0004096816110000000000000022591", null },
{ "DE0004946353300000000000001652988", null },
{ "DE00746663128OF000000000000010156", null },
{ "DE0004946307100000000000001312595", null },
};
var conf = new AnonymizerConfiguration();
conf.SetOption(DataCategory.POD, AnonymizerApproach.HASH);
using (Anonymizer anonymizer = new Anonymizer(conf))
{
foreach (var plaintextMeLoId in result.Keys.ToList())
{
Messlokation melo = new Messlokation()
{
MesslokationsId = plaintextMeLoId
};
var hashedMelo = anonymizer.ApplyOperations <Messlokation>(melo);
result[plaintextMeLoId] = hashedMelo.MesslokationsId;
}
}
var resultJson = JsonConvert.SerializeObject(result);
}
/// <summary>
/// Checks if a stright might originate from <see cref="AnonymizerApproach.HASH"/>
/// </summary>
/// <param name="key">a string, e.g. '54321012345'</param>
/// <returns>true if the <paramref name="key"/> could originate from hashing.</returns>
public static bool IsHashedKey(string key)
{
if (string.IsNullOrWhiteSpace(key))
{
return(false);
}
if ((Marktlokation.ValidateId(key) && key.StartsWith(HASHED_MARKTLOKATION_PREFIX)) ||
(Messlokation.ValidateId(key) && key.StartsWith(HASHED_MESSLOKATION_PREFIX)))
{
return(true);
}
else
{
byte[] bytes;
try
{
bytes = Convert.FromBase64String(key);
}
catch (FormatException)
{
return(false);
}
return(true); // Todo: fix this
//return bytes.Length == 256 / 8; // sha256 = 256 bits
}
}
public void TestFlags()
{
var melo = new Messlokation()
{
MesslokationsId = "DE0123456789012345678901234567890",
Sparte = BO4E.ENUM.Sparte.STROM
};
Assert.IsNull(melo.UserProperties);
Assert.IsFalse(melo.HasFlagSet("foo"));
Assert.IsTrue(melo.SetFlag <Messlokation>("foo"));
Assert.IsNotNull(melo.UserProperties);
Assert.IsTrue(melo.UserProperties.TryGetValue("foo", out var upValue) && upValue.Value <bool>());
Assert.IsTrue(melo.HasFlagSet("foo"));
Assert.IsFalse(melo.SetFlag <Messlokation>("foo"));
Assert.IsTrue(melo.SetFlag <Messlokation>("foo", flagValue: false));
Assert.IsFalse(melo.HasFlagSet("foo"));
Assert.IsTrue(melo.SetFlag <Messlokation>("foo", flagValue: null));
Assert.IsFalse(melo.UserProperties.TryGetValue("foo", out var _));
Assert.IsFalse(melo.SetFlag <Messlokation>("foo", flagValue: null));
Assert.IsFalse(melo.HasFlagSet("foo"));
Assert.IsTrue(melo.SetFlag <Messlokation>("foo", flagValue: true));
melo.UserProperties["foo"] = null;
Assert.IsFalse(melo.HasFlagSet("foo"));
}
/// <summary>
/// Applies hashing on string value
/// </summary>
/// <param name="input">string that is going to be hashed</param>
/// <returns>new string containing hashed content</returns>
protected void HashString(ref string input, DataCategory?dataCategory)
{
string hashedValue;
if (dataCategory.HasValue && dataCategory.Value == DataCategory.POD)
{
if (Messlokation.ValidateId(input) || input.Length == 33)
{
string base36String = Sha256Hash(input, BASE36_ALPHABET);
hashedValue = $"{HASHED_MESSLOKATION_PREFIX}{base36String.Substring(0, 31)}";
Debug.Assert(Messlokation.ValidateId(hashedValue));
}
else if (Marktlokation.ValidateId(input) || input.Length == 11)
{
string base10String = Sha256Hash(input, BASE10_ALPHABET);
base10String = $"{HASHED_MARKTLOKATION_PREFIX}{base10String.Substring(0, 9)}";
string checkSum = Marktlokation.GetChecksum(base10String);
hashedValue = base10String + checkSum;
Debug.Assert(Marktlokation.ValidateId(hashedValue));
}
else
{
hashedValue = Sha256Hash(input);
}
}
else
{
hashedValue = Sha256Hash(input);
}
input = hashedValue;
}
public void TestMeLoIdValidity()
{
Assert.IsFalse(Messlokation.ValidateId(null));
Assert.IsFalse(Messlokation.ValidateId(" "));
Assert.IsTrue(Messlokation.ValidateId("DE1234567890123456789012345678901"));
Assert.IsTrue(Messlokation.ValidateId("DE00056266802AO6G56M11SN51G21M24S"));
Assert.IsFalse(Messlokation.ValidateId("deimudderihrfalschemeldoid"));
Assert.IsFalse(Messlokation.ValidateId("kleinbuchstabensindnichterlaubt01"));
}
public void TestCloning()
{
Messlokation bo = new Messlokation()
{
MesslokationsId = "DE345",
};
Messlokation cloneBo = BusinessObjectExtensions.DeepClone <Messlokation>((Messlokation)bo);
Assert.AreNotSame(bo, cloneBo);
// Assert.AreEqual<Messlokation>((Messlokation)bo, cloneBo); <--- keine ahnung warum das failed. vllt. auch mit json patch/diff arbeiten wie im hubnet projekt
}
public void BasicTest()
{
Messlokation melo = new Messlokation();
var result = melo.GetJsonScheme().ToString();
Energiemenge em = new Energiemenge();
result = em.GetJsonScheme().ToString();
string result2 = BusinessObject.GetJsonSchema(typeof(Energiemenge)).ToString();
Assert.AreEqual(result, result2);
}
public void TestAnonymizeEnergiemengeHashing()
{
BO4E.StaticLogger.Logger = new Microsoft.Extensions.Logging.Debug.DebugLogger("Testlogger", (log, level) => { return(true); });
Energiemenge em = new Energiemenge()
{
LokationsId = "DE0123456789012345678901234567890",
LokationsTyp = BO4E.ENUM.Lokationstyp.MeLo,
Energieverbrauch = new List <Verbrauch>()
{
new Verbrauch()
{
Wert = 123.456M,
Wertermittlungsverfahren = BO4E.ENUM.Wertermittlungsverfahren.MESSUNG,
Startdatum = new DateTime(2019, 1, 1, 0, 0, 0, DateTimeKind.Utc),
Enddatum = new DateTime(2019, 2, 1, 0, 0, 0, DateTimeKind.Utc),
Obiskennzahl = "1-2-3-4",
Einheit = BO4E.ENUM.Mengeneinheit.KWH
}
}
};
var conf = new AnonymizerConfiguration();
conf.SetOption(DataCategory.POD, AnonymizerApproach.HASH);
conf.SetOption(DataCategory.USER_PROPERTIES, AnonymizerApproach.HASH);
Anonymizer anonymizer = new Anonymizer(conf);
var verbrauch2 = JsonConvert.DeserializeObject <Verbrauch>("{\"zw\":\"000000000000485549\",\"startdatum\":\"2018-03-24T01:45:00Z\",\"enddatum\":\"2018-03-24T02:00:00Z\",\"wert\":\"59\",\"status\":\"IU012\",\"obiskennzahl\":\"1-1:2.29.0\",\"wertermittlungsverfahren\":\"MESSUNG\",\"einheit\":\"KWH\"}");
em.Energieverbrauch.Add(verbrauch2);
// hash everything
var result = anonymizer.ApplyOperations <Energiemenge>(em);
Assert.IsNotNull(result);
Assert.AreNotEqual(em.LokationsId, result.LokationsId);
Assert.IsTrue(Messlokation.ValidateId(result.LokationsId));
Assert.AreEqual(em.Energieverbrauch.Count, result.Energieverbrauch.Count);
Assert.IsNotNull(result.Energieverbrauch[1].UserProperties["zw"]);
Assert.AreNotEqual(em.Energieverbrauch[1].UserProperties["zw"].Value <string>(), result.Energieverbrauch[1].UserProperties["zw"].Value <string>());
Assert.IsTrue(Anonymizer.HasHashedKey(result));
// do not hash zw user property
conf.unaffectedUserProperties.Add("zw");
result = anonymizer.ApplyOperations <Energiemenge>(em);
Assert.IsNotNull(result);
Assert.AreNotEqual(em.LokationsId, result.LokationsId);
Assert.IsTrue(Messlokation.ValidateId(result.LokationsId));
Assert.AreEqual(em.Energieverbrauch.Count, result.Energieverbrauch.Count);
Assert.IsNotNull(result.Energieverbrauch[1].UserProperties["zw"]);
Assert.AreEqual(em.Energieverbrauch[1].UserProperties["zw"].Value <string>(), result.Energieverbrauch[1].UserProperties["zw"].Value <string>());
Assert.IsTrue(Anonymizer.HasHashedKey(result));
}
public void TestSameHashDifferentObjectTypes()
{
BO4E.StaticLogger.Logger = new Microsoft.Extensions.Logging.Debug.DebugLogger("Testlogger", (log, level) => { return(true); });
Energiemenge em = new Energiemenge()
{
LokationsId = "DE0123456789012345678901234567890",
LokationsTyp = BO4E.ENUM.Lokationstyp.MeLo,
Energieverbrauch = new List <Verbrauch>()
{
new Verbrauch()
{
Wert = 123.456M,
Wertermittlungsverfahren = BO4E.ENUM.Wertermittlungsverfahren.MESSUNG,
Startdatum = new DateTime(2019, 1, 1, 0, 0, 0, DateTimeKind.Utc),
Enddatum = new DateTime(2019, 2, 1, 0, 0, 0, DateTimeKind.Utc),
Obiskennzahl = "1-2-3-4",
Einheit = BO4E.ENUM.Mengeneinheit.KWH
}
}
};
Assert.IsTrue(em.IsValid());
Messlokation melo = new Messlokation()
{
MesslokationsId = "DE0123456789012345678901234567890"
};
Assert.IsTrue(melo.IsValid());
var conf = new AnonymizerConfiguration();
conf.SetOption(DataCategory.POD, AnonymizerApproach.HASH);
using Anonymizer anonymizer = new Anonymizer(conf);
var hashedEm = anonymizer.ApplyOperations <Energiemenge>(em);
var hashedMelo = anonymizer.ApplyOperations <Messlokation>(melo);
Assert.AreEqual(hashedEm.LokationsId, hashedMelo.MesslokationsId);
}
/// <summary>
/// check if a Messlokation has been pseudonymized using <see cref="AnonymizerApproach.HASH"/>
/// As of 2019 it's impossible for a "real" Messlokation to fulfill this condition.
/// </summary>
/// <param name="me">Messlokation</param>
/// <returns>true if the <see cref="Messlokation.MesslokationsId"/> fulfills the requirements of a hashed key</returns>
public static bool HasHashedKey(Messlokation me)
{
return(!string.IsNullOrWhiteSpace(me.MesslokationsId) && me.MesslokationsId.StartsWith(HASHED_MESSLOKATION_PREFIX));
}
/// <summary>
/// Convert CompletenessReport to CSV string
/// </summary>
/// <param name="separator">Seperatur char for CSV items. By default is ';'</param>
/// <param name="headerLine">Shows header of columns in return string?</param>
/// <param name="lineTerminator">This value goes to end of every line. By default is "\\n"</param>
/// <returns></returns>
public string ToCSV(string separator = ";", bool headerLine = true, string lineTerminator = "\\n")
{
var builder = new StringBuilder();
if (headerLine)
{
var headerColumns = new List <string>
{
"Startdatum",
"Enddatum",
"MeLo",
"MaLo",
"Messung",
"MSB",
"Profil-Nr.",
"Profil-Typ",
"Zeitbereich in dem kein wahrer Wert vorhanden ist von",
"Zeitbereich in dem kein wahrer Wert vorhanden ist bis",
"Anzahl fehlende Werte",
"Prozentuale Vollständigkeit",
"Status"
};
builder.Append(string.Join(separator, headerColumns) + lineTerminator);
}
var columns = new List <string>
{
ReferenceTimeFrame.Startdatum.Value.ToString("yyyy-MM-ddTHH:mm:ssZ"),
ReferenceTimeFrame.Enddatum.Value.ToString("yyyy-MM-ddTHH:mm:ssZ")
};
if (Messlokation.ValidateId(LokationsId))
{
columns.Add(LokationsId); // melo
columns.Add(string.Empty); // malo
}
else if (Marktlokation.ValidateId(LokationsId))
{
columns.Add(string.Empty); //melo
columns.Add(LokationsId); //malo
}
else
{
// fallback only
columns.Add(LokationsId);
columns.Add(LokationsId);
}
columns.Add(imsysRegex.Match(Obiskennzahl).Success ? "IMS" : "RLM"); // messung
columns.Add("MSB"); // MSB
if (UserProperties.TryGetValue("profil", out var profil))
{
columns.Add(profil.ToString());
}
else
{
columns.Add(string.Empty);
}
if (UserProperties.TryGetValue("profilRolle", out var profilRolle))
{
columns.Add(profilRolle.ToString());
}
else
{
columns.Add(string.Empty);
}
if (Gaps != null && Gaps.Any())
{
var minGap = Gaps.Min(x => x.Startdatum); // OrderBy(x => x.Startdatum).First().Startdatum;
var maxGap = Gaps.Max(x => x.Enddatum); // OrderByDescending(x => x.Enddatum).First().Enddatum;
columns.Add(minGap.ToString("yyyy-MM-ddTHH:mm:ssZ"));
columns.Add(maxGap.ToString("yyyy-MM-ddTHH:mm:ssZ"));
var gapsHours = (maxGap - minGap).TotalHours;
columns.Add((gapsHours * 4).ToString(CultureInfo.InvariantCulture));
}
else
{
columns.Add(string.Empty);
columns.Add(string.Empty);
columns.Add(string.Empty);
}
if (Coverage.HasValue)
{
columns.Add((Coverage.Value * 100).ToString("0.####") + " %");
}
else
{
columns.Add(string.Empty);
}
columns.Add("Status");
builder.Append(string.Join(separator, columns) + lineTerminator);
return(builder.ToString());
}
