/// <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
}
}
/// <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 TestGettingAndSetting()
{
var marktlokation = new Marktlokation()
{
MarktlokationsId = "54321012345",
};
Assert.IsFalse(marktlokation.TryGetExterneReferenz("foo", out var _));
marktlokation.ExterneReferenzen = new List <ExterneReferenz>()
{
};
Assert.IsFalse(marktlokation.TryGetExterneReferenz("foo", out var _));
marktlokation.ExterneReferenzen.Add(new ExterneReferenz()
{
ExRefName = "foo", ExRefWert = "bar"
});
Assert.IsTrue(marktlokation.TryGetExterneReferenz("foo", out var actualBar));
Assert.AreEqual("bar", actualBar);
Assert.ThrowsException <System.ArgumentException>(() => marktlokation.SetExterneReferenz(new ExterneReferenz()
{
ExRefName = null, ExRefWert = "nicht bar"
}), "must not add invalid values");
Assert.ThrowsException <System.ArgumentException>(() => marktlokation.SetExterneReferenz(new ExterneReferenz()
{
ExRefName = "foo", ExRefWert = null
}), "must not add invalid values");
Assert.ThrowsException <System.ArgumentNullException>(() => marktlokation.SetExterneReferenz(null), "must not add null");
Assert.ThrowsException <System.InvalidOperationException>(() => marktlokation.SetExterneReferenz(new ExterneReferenz()
{
ExRefName = "foo", ExRefWert = "nicht bar"
}), "By default conflicting values are rejected");
marktlokation.SetExterneReferenz(new ExterneReferenz()
{
ExRefName = "foo", ExRefWert = "nicht bar"
}, overwriteExisting: true);
Assert.IsTrue(marktlokation.TryGetExterneReferenz("foo", out actualBar));
Assert.AreNotEqual("bar", actualBar);
marktlokation.ExterneReferenzen = null;
marktlokation.SetExterneReferenz(new ExterneReferenz()
{
ExRefName = "foo", ExRefWert = "bar"
}); // if null, list is automatically created
marktlokation.SetExterneReferenz(new ExterneReferenz()
{
ExRefName = "foo", ExRefWert = "bar"
}); // setting a non-conflicting value twice doesn't hurt
Assert.IsTrue(marktlokation.TryGetExterneReferenz("foo", out actualBar));
Assert.AreEqual("bar", actualBar);
}
public void TestMaLoIdValidity()
{
Assert.IsFalse(Marktlokation.ValidateId(null));
Assert.IsFalse(Marktlokation.ValidateId(" "));
Assert.IsTrue(Marktlokation.ValidateId("51238696781"));
Assert.IsTrue(Marktlokation.ValidateId("41373559241"));
Assert.IsTrue(Marktlokation.ValidateId("56789012345"));
Assert.IsTrue(Marktlokation.ValidateId("52935155442"));
Assert.IsFalse(Marktlokation.ValidateId("512386967890"));
Assert.IsFalse(Marktlokation.ValidateId("41373559240"));
Assert.IsFalse(Marktlokation.ValidateId("12345"));
Assert.IsFalse(Marktlokation.ValidateId("asdFG"));
Assert.IsFalse(Marktlokation.ValidateId("DE1234567890123456789012345678901"));
}
public void TestCompletenessReportHashing()
{
BO4E.StaticLogger.Logger = new Microsoft.Extensions.Logging.Debug.DebugLogger("Testlogger", (log, level) => { return(true); });
CompletenessReport cr = new CompletenessReport()
{
LokationsId = "56789012345",
Coverage = 0.9M,
Einheit = BO4E.ENUM.Mengeneinheit.MWH,
wertermittlungsverfahren = BO4E.ENUM.Wertermittlungsverfahren.MESSUNG,
UserProperties = new Dictionary <string, JToken>()
{
{ "anlage", "5012345678" },
{ "profil", "123456" }
}
};
Assert.IsTrue(cr.IsValid());
var conf = new AnonymizerConfiguration();
conf.SetOption(DataCategory.POD, AnonymizerApproach.HASH);
conf.SetOption(DataCategory.USER_PROPERTIES, AnonymizerApproach.HASH);
CompletenessReport hashedReport;
using (Anonymizer anonymizer = new Anonymizer(conf))
{
hashedReport = anonymizer.ApplyOperations <CompletenessReport>(cr);
}
Assert.IsNotNull(hashedReport);
Assert.AreNotEqual(cr.LokationsId, hashedReport.LokationsId);
Assert.IsTrue(Marktlokation.ValidateId(hashedReport.LokationsId));
Assert.IsNotNull(cr.UserProperties["anlage"]);
Assert.AreNotEqual(cr.UserProperties["anlage"].Value <string>(), hashedReport.UserProperties["anlage"].Value <string>());
Assert.IsNotNull(cr.UserProperties["profil"]);
Assert.AreNotEqual(cr.UserProperties["profil"].Value <string>(), hashedReport.UserProperties["profil"].Value <string>());
conf.hashingSalt = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=";
CompletenessReport saltedReport;
using (Anonymizer anonymizer = new Anonymizer(conf))
{
saltedReport = anonymizer.ApplyOperations <CompletenessReport>(cr);
}
Assert.IsNotNull(saltedReport.LokationsId);
Assert.AreNotEqual(cr.LokationsId, saltedReport.LokationsId);
Assert.AreNotEqual(hashedReport.LokationsId, saltedReport.LokationsId);
Assert.IsTrue(Anonymizer.IsHashedKey(hashedReport.LokationsId));
Assert.IsTrue(Anonymizer.IsHashedKey(saltedReport.LokationsId));
}
public void TestMeLoValidity()
{
var malo = new Marktlokation()
{
MarktlokationsId = "1235678901",
Sparte = Sparte.STROM,
Energierichtung = Energierichtung.AUSSP
};
Assert.IsFalse(malo.IsValid()); // because the obligatory bilanzierungsmethode is not set
malo.Bilanzierungsmethode = Bilanzierungsmethode.SLP;
Assert.IsTrue(malo.IsValid(checkId: false)); // because all obligatory fields are set
Assert.IsFalse(malo.IsValid()); // but the marklokationsId is wrong
malo.MarktlokationsId = "51238696781"; // matches the appropriate regex and has the right check sum
Assert.IsTrue(malo.IsValid());
}
public void TestMaLoDeserialization()
{
JObject json;
using (StreamReader r = new StreamReader("BoMapperTests/marktlokation_simple.json"))
{
string jsonString = r.ReadToEnd();
json = JObject.Parse(jsonString);
}
string maloString = json["input"].ToString();
Marktlokation malo = JsonConvert.DeserializeObject <Marktlokation>(maloString);
Assert.IsNotNull(malo);
BusinessObject bo = JsonConvert.DeserializeObject <BusinessObject>(maloString);
Assert.IsNotNull(bo);
Assert.IsInstanceOfType(bo, typeof(Marktlokation));
}
public void TestMaLoTypeNameHandlingDeserialization()
{
JObject json;
using (StreamReader r = new StreamReader("BoMapperTests/marktlokation_with_typenamehandling.json"))
{
string jsonString = r.ReadToEnd();
json = JObject.Parse(jsonString);
}
JsonSerializerSettings settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects
};
string maloString = json["input"].ToString();
Marktlokation malo = JsonConvert.DeserializeObject <Marktlokation>(maloString, settings);
Assert.IsNotNull(malo);
BusinessObject bo = JsonConvert.DeserializeObject <BusinessObject>(maloString, settings);
Assert.IsNotNull(bo);
Assert.IsInstanceOfType(bo, typeof(Marktlokation));
}
/// <summary>
/// check if a Marktlokation has been pseudonymized using <see cref="AnonymizerApproach.HASH"/>.
/// As of 2019 it's impossible for a "real" Marktlokation to fulfill this condition.
/// </summary>
/// <param name="ma">Marktlokation</param>
/// <returns>true if the <see cref="Marktlokation.marktlokationsId"/> fulfills the requirements of a hashed key</returns>
public static bool HasHashedKey(Marktlokation ma)
{
return(!string.IsNullOrWhiteSpace(ma.MarktlokationsId) && ma.MarktlokationsId.StartsWith(HASHED_MARKTLOKATION_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());
}
