public void DataTable_ContainsInterpretedSerogroup()
{
var sut = CreateExportDefinition();
var isolate = new MeningoIsolate
{
CsbPcr = NativeMaterialTestResult.Negative,
CscPcr = NativeMaterialTestResult.Positive,
CswyPcr = NativeMaterialTestResult.Negative,
PorAPcr = NativeMaterialTestResult.Positive,
FetAPcr = NativeMaterialTestResult.Positive,
PorAVr1 = "X",
PorAVr2 = "Y",
FetAVr = "Z",
Sending = Sending,
EpsilometerTests = new List <EpsilometerTest>()
};
isolate.Sending.Isolate.GrowthOnMartinLewisAgar = Growth.TypicalGrowth;
isolate.Sending.Material = MeningoMaterial.NativeMaterial;
Sending.Isolate = isolate;
var export = sut.ToDataTable(Sendings);
export.Rows[0]["Serogruppe"].Should().Be("C");
}
private void RunStemInterpretation(MeningoIsolate isolate)
{
var matchingRule = StemInterpretationRules.FirstOrDefault(r => CheckStemRule(r.Value, isolate));
if (matchingRule.Key != null)
{
var rule = matchingRule.Value;
Rule = matchingRule.Key;
NoMeningococci = rule.NoMeningococci;
if (!string.IsNullOrEmpty(rule.Identification))
{
typings.Add(new Typing {
Attribute = "Identifikation", Value = rule.Identification
});
}
Result.Comment = rule.Comment;
Result.Report = rule.Report.Select(r => Smart.Format(r, isolate, rule)).ToArray();
foreach (var typingTemplateKey in rule.Typings)
{
var template = TypingTemplates[typingTemplateKey];
typings.Add(new Typing
{
Attribute = template.Attribute,
Value = Smart.Format(template.Value, isolate)
});
}
}
}
public MeningoIsolate Convert(Dictionary <string, object> source, MeningoIsolate destination, ResolutionContext context)
{
var isolate = CreateMeningoIsolate(source);
FillPorAPcr(isolate, source);
FillFetAPcr(isolate, source);
FillPubMlst(isolate, source);
FillAntibiotics(isolate, source);
return(isolate);
}
private void FillAntibiotics(MeningoIsolate isolate, Dictionary <string, object> source)
{
var receivingDate = string.IsNullOrEmpty(source["eing_dat"].ToString())
? DateTime.MinValue
: DateTime.Parse(source["eing_dat"].ToString());
FillAntibiotic(isolate, DoubleOrNull(source, "penicillin"), receivingDate, Antibiotic.Benzylpenicillin);
FillAntibiotic(isolate, DoubleOrNull(source, "cefotaxim"), receivingDate, Antibiotic.Cefotaxime);
FillAntibiotic(isolate, DoubleOrNull(source, "ciprofloxacin"), receivingDate, Antibiotic.Ciprofloxacin);
FillAntibiotic(isolate, DoubleOrNull(source, "rifampicin"), receivingDate, Antibiotic.Rifampicin);
}
private static string FindSpecies(MeningoIsolate isolate)
{
var possibleSpecies = new List <string> {
isolate.MaldiTofBestMatch, isolate.RibosomalRna16SBestMatch
};
if (isolate.RealTimePcr == NativeMaterialTestResult.Positive)
{
possibleSpecies.Add(EnumUtils.GetEnumDescription <RealTimePcrResult>(isolate.RealTimePcrResult));
}
return(possibleSpecies.FirstOrDefault(s => !string.IsNullOrEmpty(s)));
}
private bool CheckNativeMaterialRule(NativeMaterialInterpretationRule rule, MeningoIsolate isolate)
{
return(rule.CsbPcr.Contains(isolate.CsbPcr) &&
rule.CscPcr.Contains(isolate.CscPcr) &&
rule.CswyPcr.Contains(isolate.CswyPcr) &&
rule.CswyAllele == isolate.CswyAllele &&
rule.PorAPcr.Contains(isolate.PorAPcr) &&
rule.FetAPcr.Contains(isolate.FetAPcr) &&
rule.RibosomalRna16S.Contains(isolate.RibosomalRna16S) &&
(rule.RibosomalRna16SBestMatch == null || rule.RibosomalRna16SBestMatch == isolate.RibosomalRna16SBestMatch) &&
rule.RealTimePcr.Contains(isolate.RealTimePcr) &&
rule.RealTimePcrResult == isolate.RealTimePcrResult);
}
private bool CheckStemRule(StemInterpretationRule rule, MeningoIsolate isolate)
{
return(rule.SendingInvasive.Contains(isolate.Sending?.Invasive) &&
rule.GrowthOnBloodAgar == isolate.GrowthOnBloodAgar &&
(rule.GrowthOnMartinLewisAgar == null || rule.GrowthOnMartinLewisAgar.Contains(isolate.GrowthOnMartinLewisAgar)) &&
(!rule.Oxidase.HasValue || rule.Oxidase == isolate.Oxidase) &&
(rule.Agglutination == null || rule.Agglutination.Contains(isolate.Agglutination)) &&
(!rule.Onpg.HasValue || rule.Onpg == isolate.Onpg) &&
(rule.GammaGt == null || rule.GammaGt.Contains(isolate.GammaGt)) &&
(rule.SerogroupPcr == null || rule.SerogroupPcr.Contains(isolate.SerogroupPcr)) &&
(!rule.MaldiTof.HasValue || rule.MaldiTof == isolate.MaldiTof) &&
(!rule.PorAPcr.HasValue || rule.PorAPcr == isolate.PorAPcr) &&
(!rule.FetAPcr.HasValue || rule.FetAPcr == isolate.FetAPcr));
}
private static void FillPorAPcr(MeningoIsolate isolate, Dictionary <string, object> source)
{
var vr1 = source["vr1"].ToString();
var vr2 = source["vr2"].ToString();
if (!string.IsNullOrEmpty(vr1))
{
isolate.PorAVr1 = vr1;
isolate.PorAPcr = NativeMaterialTestResult.Positive;
}
if (!string.IsNullOrEmpty(vr2))
{
isolate.PorAVr2 = vr2;
isolate.PorAPcr = NativeMaterialTestResult.Positive;
}
}
public void DataTable_ContainsNoMeningococci()
{
var sut = CreateExportDefinition();
var isolate = new MeningoIsolate
{
Sending = Sending,
EpsilometerTests = new List<EpsilometerTest>()
};
isolate.Sending.SamplingLocation = MeningoSamplingLocation.Liquor;
isolate.Sending.Material = MeningoMaterial.VitalStem;
Sending.Isolate = isolate;
var export = sut.ToDataTable(Sendings);
export.Rows[0]["Serogruppe"].Should().Be(DBNull.Value);
export.Rows[0]["Regel"].Should().Be("StemInterpretation_27");
export.Rows[0]["Meningokokken"].Should().Be("kein Nachweis");
}
private static MeningoIsolate CreateMeningoIsolate(Dictionary <string, object> source)
{
var stemNumber = int.TryParse(SanitizeStemnumber(source), out int stemNumberInt) ? stemNumberInt : (int?)null;
var serogruppe = source["serogruppe"];
var serogruppePcr = StringOrNull(source, "serogruppe_PCR") ?? string.Empty;
var isolate = new MeningoIsolate
{
MeningoIsolateId = (int)source["dbnr"],
MeningoSendingId = (int)source["dbnr"],
StemNumber = stemNumber,
RplF = StringOrNull(source, "rplF"),
Agglutination = AgglutinationMap[serogruppe.ToString()],
SerogroupPcr = SerogroupPcrMap[serogruppePcr],
RibosomalRna16S = RibosomalRna16SMap[source["univ_pcr"].ToString()],
RibosomalRna16SBestMatch = StringOrNull(source, "sequenz"),
Remark = StringOrNull(source, $"{Program.StemAccessTable}.notizen"),
EpsilometerTests = new List <EpsilometerTest>(),
};
if ("h".Equals(source["art"]))
{
isolate.GrowthOnBloodAgar = Growth.No;
isolate.GrowthOnMartinLewisAgar = Growth.No;
}
var nhsRealTimePCR = StringOrNull(source, "NHS");
isolate.RealTimePcr = NativeMaterialTestResult.NotDetermined;
if (!string.IsNullOrEmpty(nhsRealTimePCR))
{
if ("negativ".Equals(nhsRealTimePCR))
{
isolate.RealTimePcr = NativeMaterialTestResult.Negative;
}
else
{
isolate.RealTimePcr = NativeMaterialTestResult.Positive;
isolate.RealTimePcrResult = RealTimePcrMap[nhsRealTimePCR];
}
}
return(isolate);
}
private static void FillFetAPcr(MeningoIsolate isolate, Dictionary <string, object> source)
{
var fetAVr = source["fet-a"].ToString();
switch (fetAVr)
{
case "del.":
case "-":
isolate.FetAPcr = NativeMaterialTestResult.Negative;
break;
case "inhib.":
isolate.FetAPcr = NativeMaterialTestResult.Inhibitory;
break;
case var _ when !string.IsNullOrEmpty(fetAVr):
isolate.FetAPcr = NativeMaterialTestResult.Positive;
isolate.FetAVr = fetAVr;
break;
}
}
private void FillPubMlst(MeningoIsolate isolate, Dictionary <string, object> source)
{
var porB = StringOrNull(source, "Serotyp");
var sequenceType = StringOrNull(source, "st");
var clonalComplex = StringOrNull(source, "cc");
var penA = StringOrNull(source, "pena");
var fhbp = StringOrNull(source, "fHbp");
if (!string.IsNullOrEmpty($"{porB}{sequenceType}{clonalComplex}{penA}{fhbp}"))
{
Console.WriteLine($"Prefilled PubMLST data for Isolate '{isolate.MeningoSendingId}' was not imported: Serotyp(PorB)={porB};st={sequenceType};cc={clonalComplex};pena={penA};fHbp={fhbp}");
return;
isolate.NeisseriaPubMlstIsolate = new NeisseriaPubMlstIsolate
{
PorB = porB,
SequenceType = sequenceType,
ClonalComplex = clonalComplex,
PenA = penA,
Fhbp = fhbp
};
}
}
private NeisseriaPubMlstIsolate CreateOrUpdatePubMlstIsolate(MeningoIsolate isolate, NeisseriaPubMlstIsolate pubMlstIsolate)
{
//TODO fix this duplication from MeningoIsolateController and try to find a
//mapping framework which does not mess with EntityFramework context as automapper
var pubMlstIsolateFromDatabase =
_db.NeisseriaPubMlstIsolates.SingleOrDefault(n =>
n.PubMlstId == pubMlstIsolate.PubMlstId);
if (pubMlstIsolateFromDatabase == null)
{
pubMlstIsolateFromDatabase = pubMlstIsolate;
_db.NeisseriaPubMlstIsolates.Add(pubMlstIsolateFromDatabase);
}
else
{
pubMlstIsolateFromDatabase.PorAVr1 = pubMlstIsolate.PorAVr1;
pubMlstIsolateFromDatabase.PorAVr2 = pubMlstIsolate.PorAVr2;
pubMlstIsolateFromDatabase.FetAVr = pubMlstIsolate.FetAVr;
pubMlstIsolateFromDatabase.PorB = pubMlstIsolate.PorB;
pubMlstIsolateFromDatabase.Fhbp = pubMlstIsolate.Fhbp;
pubMlstIsolateFromDatabase.Nhba = pubMlstIsolate.Nhba;
pubMlstIsolateFromDatabase.NadA = pubMlstIsolate.NadA;
pubMlstIsolateFromDatabase.PenA = pubMlstIsolate.PenA;
pubMlstIsolateFromDatabase.GyrA = pubMlstIsolate.GyrA;
pubMlstIsolateFromDatabase.ParC = pubMlstIsolate.ParC;
pubMlstIsolateFromDatabase.ParE = pubMlstIsolate.ParE;
pubMlstIsolateFromDatabase.RpoB = pubMlstIsolate.RpoB;
pubMlstIsolateFromDatabase.RplF = pubMlstIsolate.RplF;
pubMlstIsolateFromDatabase.SequenceType = pubMlstIsolate.SequenceType;
pubMlstIsolateFromDatabase.ClonalComplex = pubMlstIsolate.ClonalComplex;
pubMlstIsolateFromDatabase.BexseroReactivity = pubMlstIsolate.BexseroReactivity;
pubMlstIsolateFromDatabase.TrumenbaReactivity = pubMlstIsolate.TrumenbaReactivity;
}
isolate.NeisseriaPubMlstIsolate = pubMlstIsolateFromDatabase;
return(pubMlstIsolateFromDatabase);
}
private void RunNativeMaterialInterpretation(MeningoIsolate isolate)
{
var matchingRule = NativeMaterialInterpretationRules.FirstOrDefault(r => CheckNativeMaterialRule(r.Value, isolate));
if (matchingRule.Key != null)
{
var rule = matchingRule.Value;
Rule = matchingRule.Key;
NoMeningococci = rule.NoMeningococci;
Result.Comment = rule.Comment;
Result.Report = rule.Report.Select(r => Smart.Format(r, isolate, rule)).ToArray();
foreach (var typingTemplateKey in rule.Typings)
{
var template = TypingTemplates[typingTemplateKey];
typings.Add(new Typing
{
Attribute = template.Attribute,
Value = Smart.Format(template.Value, isolate, rule)
});
}
}
}
public void Interpret(MeningoIsolate isolate)
{
//TODO fix mix of model and business logic in that class it could just return
// an interpretation here whereas this class would be more the interpreter.
typings.Clear();
Serogroup = null;
Rule = null;
NoMeningococci = false;
Result.Report = new [] { "Diskrepante Ergebnisse, bitte Datenbankeinträge kontrollieren." };
Smart.Default.Settings.FormatErrorAction = ErrorAction.ThrowError;
Smart.Default.Settings.ParseErrorAction = ErrorAction.ThrowError;
if (isolate.Sending.Material == MeningoMaterial.NativeMaterial || isolate.Sending.Material == MeningoMaterial.IsolatedDna)
{
RunNativeMaterialInterpretation(isolate);
}
else
{
RunStemInterpretation(isolate);
}
DetectSerogroup();
}
private string DetectSerogroup(MeningoIsolate isolate)
{
_isolateInterpretation.Interpret(isolate);
return(_isolateInterpretation.Serogroup);
}
private string DetectMeningococci(MeningoIsolate isolate)
{
_isolateInterpretation.Interpret(isolate);
return _isolateInterpretation.NoMeningococci ? "kein Nachweis" : null;
}
private string DetectInterpretationRule(MeningoIsolate isolate)
{
_isolateInterpretation.Interpret(isolate);
return _isolateInterpretation.Rule;
}
