/// <summary>Returns the HL7 exceptions in the given arraylist in an array </summary>
private NuGenHL7Exception[] toArray(System.Collections.ArrayList list)
{
NuGenHL7Exception[] retVal = new NuGenHL7Exception[list.Count];
list.CopyTo(retVal);
return(retVal);
}
/// <summary> Tests whether the given type falls within a maximum length. </summary>
/// <returns> null of OK, an HL7Exception otherwise
/// </returns>
public virtual NuGenHL7Exception testLength(Genetibase.NuGenHL7.model.Type type, int maxLength)
{
NuGenHL7Exception e = null;
System.String encoded = NuGenPipeParser.encode(type, this.enc);
if (encoded.Length > maxLength)
{
e = new NuGenProfileNotFollowedException("Length of " + encoded.Length + " exceeds maximum of " + maxLength);
}
return(e);
}
private void addTableTestResult(System.Collections.ArrayList exList, System.String profileID, System.String codeSystem, System.String value_Renamed)
{
if (codeSystem != null && value_Renamed != null)
{
NuGenHL7Exception e = testValueAgainstTable(profileID, codeSystem, value_Renamed);
if (e != null)
{
exList.Add(e);
}
}
}
/// <summary> Tests a group against a group section of a profile.</summary>
public virtual NuGenHL7Exception[] testGroup(Group group, AbstractSegmentContainer profile, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList(20);
System.Collections.ArrayList allowedStructures = new System.Collections.ArrayList(20);
for (int i = 1; i <= profile.Children; i++)
{
ProfileStructure struct_Renamed = profile.getChild(i);
//only test a structure in detail if it isn't X
if (!struct_Renamed.Usage.ToUpper().Equals("X".ToUpper()))
{
allowedStructures.Add(struct_Renamed.Name);
//see which instances have content
try
{
Structure[] instances = group.getAll(struct_Renamed.Name);
System.Collections.ArrayList instancesWithContent = new System.Collections.ArrayList(10);
for (int j = 0; j < instances.Length; j++)
{
if (hasContent(instances[j]))
{
instancesWithContent.Add(instances[j]);
}
}
NuGenHL7Exception ce = testCardinality(instancesWithContent.Count, struct_Renamed.Min, struct_Renamed.Max, struct_Renamed.Usage, struct_Renamed.Name);
if (ce != null)
{
exList.Add(ce);
}
//test children on instances with content
for (int j = 0; j < instancesWithContent.Count; j++)
{
Structure s = (Structure)instancesWithContent[j];
NuGenHL7Exception[] childExceptions = testStructure(s, struct_Renamed, profileID);
addToList(childExceptions, exList);
}
}
catch (NuGenHL7Exception)
{
exList.Add(new NuGenProfileNotHL7CompliantException(struct_Renamed.Name + " not found in message"));
}
}
}
//complain about X structures that have content
addToList(checkForExtraStructures(group, allowedStructures), exList);
return(toArray(exList));
}
/// <summary> Checks cardinality and creates an appropriate exception if out
/// of bounds. The usage code is needed because if min cardinality
/// is > 0, the min # of reps is only required if the usage code
/// is 'R' (see HL7 v2.5 section 2.12.6.4).
/// </summary>
/// <param name="reps">the number of reps
/// </param>
/// <param name="min">the minimum number of reps
/// </param>
/// <param name="max">the maximum number of reps (-1 means *)
/// </param>
/// <param name="usage">the usage code
/// </param>
/// <param name="name">the name of the repeating structure (used in exception msg)
/// </param>
/// <returns> null if cardinality OK, exception otherwise
/// </returns>
protected internal virtual NuGenHL7Exception testCardinality(int reps, int min, int max, System.String usage, System.String name)
{
NuGenHL7Exception e = null;
if (reps < min && usage.ToUpper().Equals("R".ToUpper()))
{
e = new NuGenProfileNotFollowedException(name + " must have at least " + min + " repetitions (has " + reps + ")");
}
else if (max > 0 && reps > max)
{
e = new NuGenProfileNotFollowedException(name + " must have no more than " + max + " repetitions (has " + reps + ")");
}
return(e);
}
/// <summary> Tests a Type against the corresponding section of a profile.</summary>
/// <param name="encoded">optional encoded form of type (if you want to specify this -- if null,
/// default pipe-encoded form is used to check length and constant val)
/// </param>
public virtual NuGenHL7Exception[] testType(Genetibase.NuGenHL7.model.Type type, AbstractComponent profile, System.String encoded, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList();
if (encoded == null)
{
encoded = NuGenPipeParser.encode(type, this.enc);
}
NuGenHL7Exception ue = testUsage(encoded, profile.Usage, profile.Name);
if (ue != null)
{
exList.Add(ue);
}
if (!profile.Usage.Equals("X"))
{
//check datatype
System.String typeClass = type.GetType().FullName;
if (typeClass.IndexOf("." + profile.Datatype) < 0)
{
typeClass = typeClass.Substring(typeClass.LastIndexOf('.') + 1);
exList.Add(new NuGenProfileNotHL7CompliantException("HL7 datatype " + typeClass + " doesn't match profile datatype " + profile.Datatype));
}
//check length
if (encoded.Length > profile.Length)
{
exList.Add(new NuGenProfileNotFollowedException("The type " + profile.Name + " has length " + encoded.Length + " which exceeds max of " + profile.Length));
}
//check constant value
if (profile.ConstantValue != null && profile.ConstantValue.Length > 0)
{
if (!encoded.Equals(profile.ConstantValue))
{
exList.Add(new NuGenProfileNotFollowedException("'" + encoded + "' doesn't equal constant value of '" + profile.ConstantValue + "'"));
}
}
NuGenHL7Exception[] te = testTypeAgainstTable(type, profile, profileID);
for (int i = 0; i < te.Length; i++)
{
exList.Add(te[i]);
}
}
return(this.toArray(exList));
}
private NuGenHL7Exception testValueAgainstTable(System.String profileID, System.String codeSystem, System.String value_Renamed)
{
NuGenHL7Exception ret = null;
CodeStore store = ProfileStoreFactory.getCodeStore(profileID, codeSystem);
if (store == null)
{
}
else
{
if (!store.isValidCode(codeSystem, value_Renamed))
{
ret = new NuGenProfileNotFollowedException("Code " + value_Renamed + " not found in table " + codeSystem + ", profile " + profileID);
}
}
return(ret);
}
/// <summary>Tests the message by passing it to all test apps that have been registered
/// using addTest().
/// </summary>
/// <returns> exceptions that describe any identified problems with the message
/// </returns>
public override NuGenHL7Exception[] test(Message in_Renamed)
{
System.Collections.ArrayList problems = new System.Collections.ArrayList(40);
for (int i = 0; i < tests.Count; i++)
{
NuGenTestApplication app = (NuGenTestApplication)tests[i];
NuGenHL7Exception[] shortList = app.test(in_Renamed);
for (int j = 0; j < shortList.Length; j++)
{
problems.Add(shortList[i]);
}
}
NuGenHL7Exception[] retVal = new NuGenHL7Exception[problems.Count];
problems.CopyTo(retVal);
return(retVal);
}
/// <summary> Tests all remaining messages available from the currrent source.</summary>
public virtual NuGenHL7Exception[] testAll()
{
System.Collections.ArrayList list = new System.Collections.ArrayList();
System.String message = null;
while ((message = NextMessage).Length > 0)
{
NuGenHL7Exception e = parsesCorrectly(this.context, message);
if (e != null)
{
list.Add(e);
}
}
NuGenHL7Exception[] retVal = new NuGenHL7Exception[list.Count];
list.CopyTo(retVal);
return(retVal);
}
/// <summary> Tests the message against a profile or profiles. A constant profile
/// is used if one was provided to the constructor, otherwise any profiles
/// declared in the message are used.
/// </summary>
public override NuGenHL7Exception[] test(Message in_Renamed)
{
NuGenValidationException[] errors = rule.test(in_Renamed);
NuGenHL7Exception[] result = new NuGenHL7Exception[errors.Length];
for (int i = 0; i < errors.Length; i++)
{
System.Exception t = errors[i].InnerException;
if ((t != null) && (t is NuGenHL7Exception))
{
result[i] = (NuGenHL7Exception)t;
}
else
{
result[i] = new NuGenHL7Exception(errors[i]);
}
}
return(result);
}
/// <summary> Checks whether the given message parses correctly with a GenericParser.
/// Failure indicates that the parsed and re-encoded message is semantically
/// different than the original, or that the message could not be parsed. This
/// may stem from an error in the parser, or from an error in the message. This
/// may also arise from unexpected message components (e.g. Z-segments) although
/// in future HAPI versions these will be parsed as well.
/// </summary>
/// <param name="message">an XML or ER7 encoded message string
/// </param>
/// <returns> null if it parses correctly, an HL7Exception otherwise
/// </returns>
public static NuGenHL7Exception parsesCorrectly(System.String context, System.String message)
{
NuGenHL7Exception problem = null;
try
{
Message m = parser.parse(message);
System.String encoding = parser.getEncoding(message);
System.String result = parser.encode(m, encoding);
if (!NuGenEncodedMessageComparator.equivalent(message, result))
{
problem = new NuGenHL7Exception(context + ": Original differs semantically from parsed/encoded message.\r\n-----Original:------------\r\n" + message + " \r\n------ Parsed/Encoded: ----------\r\n" + result + " \r\n-----Original Standardized: ---------\r\n" + NuGenEncodedMessageComparator.standardize(message) + " \r\n---------------------\r\n");
}
}
catch (System.Exception e)
{
problem = new NuGenHL7Exception(context + ": " + e.Message + " in message: \r\n-------------\r\n" + message + "\r\n-------------");
;
}
return(problem);
}
/// <summary> Tests an element against the corresponding usage code. The element
/// is required in its encoded form.
/// </summary>
/// <param name="encoded">the pipe-encoded message element
/// </param>
/// <param name="usage">the usage code (e.g. "CE")
/// </param>
/// <param name="name">the name of the element (for use in exception messages)
/// </param>
/// <returns>s null if there is no problem, an HL7Exception otherwise
/// </returns>
private NuGenHL7Exception testUsage(System.String encoded, System.String usage, System.String name)
{
NuGenHL7Exception e = null;
if (usage.ToUpper().Equals("R".ToUpper()))
{
if (encoded.Length == 0)
{
e = new NuGenProfileNotFollowedException("Required element " + name + " is missing");
}
}
else if (usage.ToUpper().Equals("RE".ToUpper()))
{
//can't test anything
}
else if (usage.ToUpper().Equals("O".ToUpper()))
{
//can't test anything
}
else if (usage.ToUpper().Equals("C".ToUpper()))
{
//can't test anything yet -- wait for condition syntax in v2.6
}
else if (usage.ToUpper().Equals("CE".ToUpper()))
{
//can't test anything
}
else if (usage.ToUpper().Equals("X".ToUpper()))
{
if (encoded.Length > 0)
{
e = new NuGenXElementPresentException("Element " + name + " is present but specified as not used (X)");
}
}
else if (usage.ToUpper().Equals("B".ToUpper()))
{
//can't test anything
}
return(e);
}
/// <summary> Sets the source reader to point to the given file, and tests
/// all the messages therein (if a directory, processes all contained
/// files recursively).
/// </summary>
public virtual NuGenHL7Exception[] testAll(System.IO.FileInfo source)
{
System.Collections.ArrayList list = new System.Collections.ArrayList();
System.Console.Out.WriteLine("Testing " + source.FullName);
if (System.IO.Directory.Exists(source.FullName))
{
System.IO.FileInfo[] contents = SupportClass.FileSupport.GetFiles(source);
for (int i = 0; i < contents.Length; i++)
{
NuGenHL7Exception[] exceptions = testAll(contents[i]);
for (int j = 0; j < exceptions.Length; j++)
{
list.Add(exceptions[j]);
}
}
}
else if (System.IO.File.Exists(source.FullName))
{
System.IO.StreamReader in_Renamed = new System.IO.StreamReader(source.FullName, System.Text.Encoding.Default);
Source = in_Renamed;
Context = source.FullName;
NuGenHL7Exception[] exceptions = testAll();
for (int i = 0; i < exceptions.Length; i++)
{
list.Add(exceptions[i]);
}
}
else
{
System.Console.Out.WriteLine("Warning: " + source.FullName + " is not a normal file");
}
NuGenHL7Exception[] retVal = new NuGenHL7Exception[list.Count];
list.CopyTo(retVal);
return(retVal);
}
/// <summary> Tests a segment against a segment section of a profile.</summary>
public virtual NuGenHL7Exception[] testSegment(Genetibase.NuGenHL7.model.Segment segment, Seg profile, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList(20);
System.Collections.ArrayList allowedFields = new System.Collections.ArrayList(20);
for (int i = 1; i <= profile.Fields; i++)
{
Field field = profile.getField(i);
//only test a field in detail if it isn't X
if (!field.Usage.ToUpper().Equals("X".ToUpper()))
{
allowedFields.Add((System.Int32)i);
//see which instances have content
try
{
Genetibase.NuGenHL7.model.Type[] instances = segment.getField(i);
System.Collections.ArrayList instancesWithContent = new System.Collections.ArrayList(10);
for (int j = 0; j < instances.Length; j++)
{
if (hasContent(instances[j]))
{
instancesWithContent.Add(instances[j]);
}
}
NuGenHL7Exception ce = testCardinality(instancesWithContent.Count, field.Min, field.Max, field.Usage, field.Name);
if (ce != null)
{
ce.FieldPosition = i;
exList.Add(ce);
}
//test field instances with content
for (int j = 0; j < instancesWithContent.Count; j++)
{
Genetibase.NuGenHL7.model.Type s = (Genetibase.NuGenHL7.model.Type)instancesWithContent[j];
bool escape = true; //escape field value when checking length
if (profile.Name.ToUpper().Equals("MSH".ToUpper()) && i < 3)
{
escape = false;
}
NuGenHL7Exception[] childExceptions = testField(s, field, escape, profileID);
for (int k = 0; k < childExceptions.Length; k++)
{
childExceptions[k].FieldPosition = i;
}
addToList(childExceptions, exList);
}
}
catch (NuGenHL7Exception)
{
exList.Add(new NuGenProfileNotHL7CompliantException("Field " + i + " not found in message"));
}
}
}
//complain about X fields with content
this.addToList(checkForExtraFields(segment, allowedFields), exList);
NuGenHL7Exception[] ret = toArray(exList);
for (int i = 0; i < ret.Length; i++)
{
ret[i].SegmentName = profile.Name;
}
return(ret);
}
/// <summary> Sets the source reader to point to the given file, and tests
/// all the messages therein (if a directory, processes all contained
/// files recursively).
/// </summary>
public virtual NuGenHL7Exception[] testAll(System.IO.FileInfo source)
{
System.Collections.ArrayList list = new System.Collections.ArrayList();
System.Console.Out.WriteLine("Testing " + source.FullName);
if (System.IO.Directory.Exists(source.FullName))
{
System.IO.FileInfo[] contents = SupportClass.FileSupport.GetFiles(source);
for (int i = 0; i < contents.Length; i++)
{
NuGenHL7Exception[] exceptions = testAll(contents[i]);
for (int j = 0; j < exceptions.Length; j++)
{
list.Add(exceptions[j]);
}
}
}
else if (System.IO.File.Exists(source.FullName))
{
System.IO.StreamReader in_Renamed = new System.IO.StreamReader(source.FullName, System.Text.Encoding.Default);
Source = in_Renamed;
Context = source.FullName;
NuGenHL7Exception[] exceptions = testAll();
for (int i = 0; i < exceptions.Length; i++)
{
list.Add(exceptions[i]);
}
}
else
{
System.Console.Out.WriteLine("Warning: " + source.FullName + " is not a normal file");
}
NuGenHL7Exception[] retVal = new NuGenHL7Exception[list.Count];
list.CopyTo(retVal);
return retVal;
}
/// <summary> Tests all remaining messages available from the currrent source.</summary>
public virtual NuGenHL7Exception[] testAll()
{
System.Collections.ArrayList list = new System.Collections.ArrayList();
System.String message = null;
while ((message = NextMessage).Length > 0)
{
NuGenHL7Exception e = parsesCorrectly(this.context, message);
if (e != null)
list.Add(e);
}
NuGenHL7Exception[] retVal = new NuGenHL7Exception[list.Count];
list.CopyTo(retVal);
return retVal;
}
/// <summary> Checks whether the given message parses correctly with a GenericParser.
/// Failure indicates that the parsed and re-encoded message is semantically
/// different than the original, or that the message could not be parsed. This
/// may stem from an error in the parser, or from an error in the message. This
/// may also arise from unexpected message components (e.g. Z-segments) although
/// in future HAPI versions these will be parsed as well.
/// </summary>
/// <param name="message">an XML or ER7 encoded message string
/// </param>
/// <returns> null if it parses correctly, an HL7Exception otherwise
/// </returns>
public static NuGenHL7Exception parsesCorrectly(System.String context, System.String message)
{
NuGenHL7Exception problem = null;
try
{
Message m = parser.parse(message);
System.String encoding = parser.getEncoding(message);
System.String result = parser.encode(m, encoding);
if (!NuGenEncodedMessageComparator.equivalent(message, result))
{
problem = new NuGenHL7Exception(context + ": Original differs semantically from parsed/encoded message.\r\n-----Original:------------\r\n" + message + " \r\n------ Parsed/Encoded: ----------\r\n" + result + " \r\n-----Original Standardized: ---------\r\n" + NuGenEncodedMessageComparator.standardize(message) + " \r\n---------------------\r\n");
}
}
catch (System.Exception e)
{
problem = new NuGenHL7Exception(context + ": " + e.Message + " in message: \r\n-------------\r\n" + message + "\r\n-------------");
;
}
return problem;
}
/// <summary>Appends an array of HL7 exceptions to a list </summary>
private void addToList(NuGenHL7Exception[] exceptions, System.Collections.ArrayList list)
{
for (int i = 0; i < exceptions.Length; i++)
{
list.Add(exceptions[i]);
}
}
/// <summary>Returns the HL7 exceptions in the given arraylist in an array </summary>
private NuGenHL7Exception[] toArray(System.Collections.ArrayList list)
{
NuGenHL7Exception[] retVal = new NuGenHL7Exception[list.Count];
list.CopyTo(retVal);
return retVal;
}
