/// <summary>
/// Converts a ConclusioEnum to a human friendly string.
/// The verb "Humanize" is taken from this great project: [Humanizer](https://github.com/MehdiK/Humanizer)
/// </summary>
/// <param name="conclusion">Conclusion to retrieve a humanized string for</param>
/// <returns>The humanized string</returns>
public static string ConclusionHumanized(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.Success:
return("OK (Success)");
case ConclusionEnum.DoesNotApply:
return("N/A (Does not apply)");
case ConclusionEnum.Fatal:
return("Crashed (Fatal)");
case ConclusionEnum.Inconclusive:
return("Inconclusive");
case ConclusionEnum.Major:
return("Major");
case ConclusionEnum.Minor:
return("Minor");
default:
throw new ArgumentOutOfRangeException(string.Format("Found unknown ConclusionEnum: {0}", conclusion.ToString()));
}
}
string ConclusionToGlyphicon(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.DoesNotApply:
return("glyphicon-asterisk");
case ConclusionEnum.Fatal:
return("glyphicon-warning-sign");
case ConclusionEnum.Inconclusive:
return("glyphicon-ban-circle");
case ConclusionEnum.Major:
return("glyphicon-remove");
case ConclusionEnum.Minor:
return("glyphicon-info-sign");
case ConclusionEnum.Success:
return("glyphicon-ok");
default:
return("glyphicon-exclamation-sign");
}
}
/// <summary>
/// Returns a sentence that describes the conclusion for a TestRecord.
/// </summary>
/// <param name="conclusion">Conclusion to return text for</param>
/// <returns>A sentence describing the conclusiong</returns>
public static string TestRecordConclusionDescription(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.Success:
//Alternative: The test found no issues, your system is operating within established parameters
return("The test found no issues");
case ConclusionEnum.DoesNotApply:
return("The test does not apply to this computer and can safely be ignored");
case ConclusionEnum.Fatal:
return("The test script failed to execute correctly and was shut down");
case ConclusionEnum.Inconclusive:
//Alternative: Not enough data to concluse a result
return("The test did not find enough data to conclude a result");
case ConclusionEnum.Major:
//Alternative: An major issue was found
return("The test found a major issue");
case ConclusionEnum.Minor:
//Alternative: A little irregularity was found
return("The test found a little irregularity");
default:
throw new ArgumentOutOfRangeException(string.Format("Found unknown ConclusionEnum: {0}", conclusion.ToString()));
}
}
string CreateHTMLElement_SpanGlyphicon(ConclusionEnum conclusion)
{
//<span class="glyphicon glyphicon-ok" aria-hidden="true">
string glyphicon = ConclusionToGlyphicon(conclusion);
WeakHTMLTag span = new WeakHTMLTag("span");
span.CSSClass = "glyphicon " + glyphicon;
span.Attributes["aria-hidden"] = "true";
return(span.ToString());
}
void ProcessHashtableOutputInternal(BaseRecord record, Hashtable table)
{
//We need a a key "Data" or this is considered to be fatal. The value of this key can still be NULL.
if (table.ContainsKey(Xteq5EngineConstant.ReturnedHashtableKeyData) == false)
{
record.Conclusion = ConclusionEnum.Fatal;
record.AddLineToProcessMessages("Data key missing from returned hashtable");
ProcessFailure(record);
}
else
{
string name = GetStringFromHashtable(table, Xteq5EngineConstant.ReturnedHashtableKeyName);
if (string.IsNullOrEmpty(name) == false)
{
record.Name = name;
}
string text = GetStringFromHashtable(table, Xteq5EngineConstant.ReturnedHashtableKeyText);
if (string.IsNullOrEmpty(text) == false)
{
record.Description = text;
}
string data = GetStringFromHashtable(table, Xteq5EngineConstant.ReturnedHashtableKeyData);
if (string.IsNullOrEmpty(data))
{
//Empty data means DoesNotApply
record.Conclusion = ConclusionEnum.DoesNotApply;
ProcessEmptyData(record, table);
}
else
{
//The data key contains something. First try if the result is maybe the string "n/a"
ConclusionEnum conclusion = ConclusionEnumConverter.ParseConclusion(data);
if (conclusion == ConclusionEnum.DoesNotApply)
{
//The script returned n/a (DoesNotApply), so it can be processed as an empty record
record.Conclusion = ConclusionEnum.DoesNotApply;
ProcessEmptyData(record, table);
}
else
{
//The result was something else. Let the implementation decide.
ProcessNonEmptyData(record, table, data);
}
}
}
}
string CreateHTMLElement_TdGlyphSpan(ConclusionEnum conclusion)
{
//<td class="success"><span class="glyphicon glyphicon-ok" aria-hidden="true"></span></td>
WeakHTMLTag td = new WeakHTMLTag("td");
string cssClass = ConclusionToCSSModifier(conclusion);
if (string.IsNullOrWhiteSpace(cssClass) == false)
{
td.Attributes["class"] = cssClass;
}
td.HTML = CreateHTMLElement_SpanGlyphicon(conclusion);
return(td.ToString());
}
protected override void ProcessNonEmptyData(BaseRecord record, Hashtable table, string dataKeyValue)
{
//The basic values are all set by :base() and it was also validated that the hashtable contains a key ".Data".
TestRecord testRecord = new TestRecord(record);
//Data is not NULL and not "", hence we need to check which conclusion the author wanted to report
ConclusionEnum conclusion = ConclusionEnumConverter.ParseConclusion(dataKeyValue);
if (conclusion == ConclusionEnum.Fatal)
{
//We were not able to parse the value inside .Data
testRecord.AddLineToProcessMessages(string.Format("Unable to parse result {0}", dataKeyValue));
}
testRecord.Conclusion = conclusion;
_results.Add(testRecord);
}
/// <summary>
/// Returns a recommended action for the user, based on the conclusion.
/// This exists only for tests, because for assets there is never a recommended action.
/// </summary>
/// <param name="conclusion">Conclusion to get a recommended action for</param>
/// <returns>An empty string if no recommended action exist, or the recommended action</returns>
public static string TestRecordConclusionRecommendedAction(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.Success:
case ConclusionEnum.DoesNotApply:
case ConclusionEnum.Inconclusive:
case ConclusionEnum.Fatal: //The user can't do anything about a fatal test
return("");
case ConclusionEnum.Major:
return("Investigate and fix the issue immediately");
case ConclusionEnum.Minor:
return("Investigate and fix the issue when time permits");
default:
throw new ArgumentOutOfRangeException(string.Format("Found unknown ConclusionEnum: {0}", conclusion.ToString()));
}
}
/// <summary>
/// Returns a sentence that describes the conclusion for an AssetRecord.
/// </summary>
/// <param name="conclusion">Conclusion to return a sentence for</param>
/// <returns>A sentence describing the conclusion</returns>
public static string AssetRecordConclusionDescription(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.Success:
return("The asset successfully retrieved information"); //Different from TestRecord
case ConclusionEnum.DoesNotApply:
return("The asset does not apply to this computer and can safely be ignored");
case ConclusionEnum.Fatal:
return("The asset did not execute correctly and was shut down");
//These cases are invalid for assets and will therefore result in an exception
case ConclusionEnum.Inconclusive:
case ConclusionEnum.Major:
case ConclusionEnum.Minor:
throw new ArgumentException(string.Format("ConclusionEnum {0} is not valid for an AssetRecord", conclusion.ToString()));
default:
throw new ArgumentOutOfRangeException(string.Format("Found unknown ConclusionEnum: {0}", conclusion.ToString()));
}
}
string ConclusionToCSSModifier(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.DoesNotApply:
case ConclusionEnum.Inconclusive:
return("");
case ConclusionEnum.Success:
return("success");
case ConclusionEnum.Fatal:
return("danger");
case ConclusionEnum.Major:
return("warning");
case ConclusionEnum.Minor:
return("info");
default:
return("ConclusionToCssModifierFailed");
}
}
string CreateHTMLElement_TdGlyphSpan(ConclusionEnum conclusion)
{
//<td class="success"><span class="glyphicon glyphicon-ok" aria-hidden="true"></span></td>
WeakHTMLTag td = new WeakHTMLTag("td");
string cssClass = ConclusionToCSSModifier(conclusion);
if (string.IsNullOrWhiteSpace(cssClass) == false)
{
td.Attributes["class"] = cssClass;
}
td.HTML = CreateHTMLElement_SpanGlyphicon(conclusion);
return td.ToString();
}
string CreateHTMLElement_SpanGlyphicon(ConclusionEnum conclusion)
{
//<span class="glyphicon glyphicon-ok" aria-hidden="true">
string glyphicon = ConclusionToGlyphicon(conclusion);
WeakHTMLTag span = new WeakHTMLTag("span");
span.CSSClass = "glyphicon " + glyphicon;
span.Attributes["aria-hidden"] = "true";
return span.ToString();
}
string ConclusionToGlyphicon(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.DoesNotApply:
return "glyphicon-asterisk";
case ConclusionEnum.Fatal:
return "glyphicon-warning-sign";
case ConclusionEnum.Inconclusive:
return "glyphicon-ban-circle";
case ConclusionEnum.Major:
return "glyphicon-remove";
case ConclusionEnum.Minor:
return "glyphicon-info-sign";
case ConclusionEnum.Success:
return "glyphicon-ok";
default:
return "glyphicon-exclamation-sign";
}
}
string ConclusionToCSSModifier(ConclusionEnum conclusion)
{
switch (conclusion)
{
case ConclusionEnum.DoesNotApply:
case ConclusionEnum.Inconclusive:
return "";
case ConclusionEnum.Success:
return "success";
case ConclusionEnum.Fatal:
return "danger";
case ConclusionEnum.Major:
return "warning";
case ConclusionEnum.Minor:
return "info";
default:
return "ConclusionToCssModifierFailed";
}
}
