internal static IList<Tag> ParseTags(XmlReader xr, ErrorList errors)
{
xr.MoveToContent();
try
{
var taglist = (XElement)XElement.ReadFrom(xr);
if (taglist.Name == BundleXmlParser.XFHIRNS + TagListSerializer.TAGLIST_ROOT)
{
if (taglist.Elements().All(xe => xe.Name == BundleXmlParser.XFHIRNS + BundleXmlParser.XATOM_CATEGORY))
return ParseTags(taglist.Elements());
else
errors.Add("TagList contains unexpected child elements");
}
else
errors.Add(String.Format("Unexpected element name {0} found at start of TagList", taglist.Name));
}
catch (Exception exc)
{
errors.Add("Exception while loading taglist: " + exc.Message);
}
return null;
}
internal override ErrorList ValidateRules()
{
var result = new ErrorList();
result.AddRange(base.ValidateRules());
if (Content == null)
result.Add("Entry must contain (possibly 0-length) data");
if (ContentType == null)
result.Add("Entry must contain a contentType");
return result;
}
internal override ErrorList ValidateRules()
{
var result = new ErrorList();
if (Value.IsAbsoluteUri)
{
string dummy; string dummy2;
var urnValue = Value.ToString();
if (urnValue.StartsWith("urn:oid:") && !Oid.TryParseValue(urnValue, out dummy))
result.Add(String.Format("Uri is an urn:oid, but the oid {0} is incorrect",urnValue));
else if (urnValue.StartsWith("urn:uuid:") && !Uuid.TryParseValue(urnValue, out dummy2))
result.Add(String.Format("Uri is an urn:uuid, but the uuid {0} is incorrect", urnValue));
}
return result;
}
internal override ErrorList ValidateRules()
{
var result = new ErrorList();
if (Value == null)
result.Add("Uuid values cannot be empty");
else
{
Uuid dummy;
if (!TryParse(Value, out dummy))
result.Add("Not an correctly formatted uuid value");
}
return result;
}
/// <summary>
/// Parse base64Binary
/// </summary>
public static Hl7.Fhir.Model.Base64Binary ParseBase64Binary(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Base64Binary existingInstance = null )
{
Hl7.Fhir.Model.Base64Binary result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Base64Binary();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element value
else if( atName == "value" )
result.Value = Base64Binary.Parse(reader.ReadPrimitiveContents(typeof(Base64Binary))).Value;
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse MedicationAdministration
/// </summary>
public static Hl7.Fhir.Model.MedicationAdministration ParseMedicationAdministration(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.MedicationAdministration existingInstance = null )
{
Hl7.Fhir.Model.MedicationAdministration result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.MedicationAdministration();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( atName == "language" )
result.LanguageElement = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( atName == "text" )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( atName == "contained" )
{
result.Contained = new List<Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element identifier
else if( atName == "identifier" )
{
result.Identifier = new List<Hl7.Fhir.Model.Identifier>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "identifier") )
result.Identifier.Add(IdentifierParser.ParseIdentifier(reader, errors));
reader.LeaveArray();
}
// Parse element status
else if( atName == "status" )
result.StatusElement = CodeParser.ParseCode<Hl7.Fhir.Model.MedicationAdministration.MedicationAdministrationStatus>(reader, errors);
// Parse element patient
else if( atName == "patient" )
result.Patient = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element practitioner
else if( atName == "practitioner" )
result.Practitioner = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element encounter
else if( atName == "encounter" )
result.Encounter = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element prescription
else if( atName == "prescription" )
result.Prescription = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element wasNotGiven
else if( atName == "wasNotGiven" )
result.WasNotGivenElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element reasonNotGiven
else if( atName == "reasonNotGiven" )
{
result.ReasonNotGiven = new List<Hl7.Fhir.Model.CodeableConcept>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "reasonNotGiven") )
result.ReasonNotGiven.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
reader.LeaveArray();
}
// Parse element whenGiven
else if( atName == "whenGiven" )
result.WhenGiven = PeriodParser.ParsePeriod(reader, errors);
// Parse element medication
else if( atName == "medication" )
result.Medication = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element administrationDevice
else if( atName == "administrationDevice" )
{
result.AdministrationDevice = new List<Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "administrationDevice") )
result.AdministrationDevice.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
reader.LeaveArray();
}
// Parse element dosage
else if( atName == "dosage" )
{
result.Dosage = new List<Hl7.Fhir.Model.MedicationAdministration.MedicationAdministrationDosageComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "dosage") )
result.Dosage.Add(MedicationAdministrationParser.ParseMedicationAdministrationDosageComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse ValueSet
/// </summary>
public static Hl7.Fhir.Model.ValueSet ParseValueSet(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.ValueSet existingInstance = null)
{
Hl7.Fhir.Model.ValueSet result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.ValueSet();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (atName == "language")
{
result.LanguageElement = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (atName == "text")
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (atName == "contained")
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element identifier
else if (atName == "identifier")
{
result.IdentifierElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element version
else if (atName == "version")
{
result.VersionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element name
else if (atName == "name")
{
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element publisher
else if (atName == "publisher")
{
result.PublisherElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element telecom
else if (atName == "telecom")
{
result.Telecom = new List <Hl7.Fhir.Model.Contact>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "telecom"))
{
result.Telecom.Add(ContactParser.ParseContact(reader, errors));
}
reader.LeaveArray();
}
// Parse element description
else if (atName == "description")
{
result.DescriptionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element copyright
else if (atName == "copyright")
{
result.CopyrightElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element status
else if (atName == "status")
{
result.StatusElement = CodeParser.ParseCode <Hl7.Fhir.Model.ValueSet.ValueSetStatus>(reader, errors);
}
// Parse element experimental
else if (atName == "experimental")
{
result.ExperimentalElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
}
// Parse element date
else if (atName == "date")
{
result.DateElement = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
}
// Parse element define
else if (atName == "define")
{
result.Define = ValueSetParser.ParseValueSetDefineComponent(reader, errors);
}
// Parse element compose
else if (atName == "compose")
{
result.Compose = ValueSetParser.ParseValueSetComposeComponent(reader, errors);
}
// Parse element expansion
else if (atName == "expansion")
{
result.Expansion = ValueSetParser.ParseValueSetExpansionComponent(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse ConformanceRestResourceSearchParamComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceRestResourceSearchParamComponent ParseConformanceRestResourceSearchParamComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceRestResourceSearchParamComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceRestResourceSearchParamComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceRestResourceSearchParamComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element name
else if( atName == "name" )
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element source
else if( atName == "source" )
result.SourceElement = FhirUriParser.ParseFhirUri(reader, errors);
// Parse element type
else if( atName == "type" )
result.TypeElement = CodeParser.ParseCode<Hl7.Fhir.Model.Conformance.SearchParamType>(reader, errors);
// Parse element documentation
else if( atName == "documentation" )
result.DocumentationElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element xpath
else if( atName == "xpath" )
result.XpathElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element target
else if( atName == "target" )
{
result.TargetElement = new List<Hl7.Fhir.Model.Code>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "target") )
result.TargetElement.Add(CodeParser.ParseCode(reader, errors));
reader.LeaveArray();
}
// Parse element chain
else if( atName == "chain" )
{
result.ChainElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "chain") )
result.ChainElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
public void HasErrorShouldBeTrue()
{
ErrorList errors = new ErrorList();
errors.Add(new ErrorInfo("Name"));
Assert.IsTrue(errors.HasErrors);
}
/// <summary>
/// Parse OperationOutcomeIssueComponent
/// </summary>
public static Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent ParseOperationOutcomeIssueComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent existingInstance = null )
{
Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element severity
else if( atName == "severity" )
result.SeverityElement = CodeParser.ParseCode<Hl7.Fhir.Model.OperationOutcome.IssueSeverity>(reader, errors);
// Parse element type
else if( atName == "type" )
result.Type = CodingParser.ParseCoding(reader, errors);
// Parse element details
else if( atName == "details" )
result.DetailsElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element location
else if( atName == "location" )
{
result.LocationElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "location") )
result.LocationElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse ConformanceMessagingEventComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceMessagingEventComponent ParseConformanceMessagingEventComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceMessagingEventComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceMessagingEventComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceMessagingEventComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element code
else if( atName == "code" )
result.CodeElement = CodeParser.ParseCode(reader, errors);
// Parse element mode
else if( atName == "mode" )
result.ModeElement = CodeParser.ParseCode<Hl7.Fhir.Model.Conformance.ConformanceEventMode>(reader, errors);
// Parse element protocol
else if( atName == "protocol" )
{
result.Protocol = new List<Hl7.Fhir.Model.Coding>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "protocol") )
result.Protocol.Add(CodingParser.ParseCoding(reader, errors));
reader.LeaveArray();
}
// Parse element focus
else if( atName == "focus" )
result.FocusElement = CodeParser.ParseCode(reader, errors);
// Parse element request
else if( atName == "request" )
result.Request = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element response
else if( atName == "response" )
result.Response = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element documentation
else if( atName == "documentation" )
result.DocumentationElement = FhirStringParser.ParseFhirString(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse Document
/// </summary>
public static Hl7.Fhir.Model.Document ParseDocument(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Document existingInstance = null)
{
Hl7.Fhir.Model.Document result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Document();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (atName == "language")
{
result.LanguageElement = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (atName == "text")
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (atName == "contained")
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element identifier
else if (atName == "identifier")
{
result.Identifier = IdentifierParser.ParseIdentifier(reader, errors);
}
// Parse element versionIdentifier
else if (atName == "versionIdentifier")
{
result.VersionIdentifier = IdentifierParser.ParseIdentifier(reader, errors);
}
// Parse element created
else if (atName == "created")
{
result.CreatedElement = InstantParser.ParseInstant(reader, errors);
}
// Parse element type
else if (atName == "type")
{
result.Type = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element subtype
else if (atName == "subtype")
{
result.Subtype = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element title
else if (atName == "title")
{
result.TitleElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element status
else if (atName == "status")
{
result.StatusElement = CodeParser.ParseCode <Hl7.Fhir.Model.Document.DocumentStatus>(reader, errors);
}
// Parse element confidentiality
else if (atName == "confidentiality")
{
result.Confidentiality = CodingParser.ParseCoding(reader, errors);
}
// Parse element subject
else if (atName == "subject")
{
result.Subject = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element author
else if (atName == "author")
{
result.Author = new List <Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "author"))
{
result.Author.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
}
reader.LeaveArray();
}
// Parse element attester
else if (atName == "attester")
{
result.Attester = new List <Hl7.Fhir.Model.Document.DocumentAttesterComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "attester"))
{
result.Attester.Add(DocumentParser.ParseDocumentAttesterComponent(reader, errors));
}
reader.LeaveArray();
}
// Parse element custodian
else if (atName == "custodian")
{
result.Custodian = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element event
else if (atName == "event")
{
result.Event = DocumentParser.ParseDocumentEventComponent(reader, errors);
}
// Parse element encounter
else if (atName == "encounter")
{
result.Encounter = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element replaces
else if (atName == "replaces")
{
result.ReplacesElement = IdParser.ParseId(reader, errors);
}
// Parse element provenance
else if (atName == "provenance")
{
result.Provenance = new List <Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "provenance"))
{
result.Provenance.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
}
reader.LeaveArray();
}
// Parse element stylesheet
else if (atName == "stylesheet")
{
result.Stylesheet = AttachmentParser.ParseAttachment(reader, errors);
}
// Parse element representation
else if (atName == "representation")
{
result.Representation = AttachmentParser.ParseAttachment(reader, errors);
}
// Parse element section
else if (atName == "section")
{
result.Section = new List <Hl7.Fhir.Model.Document.SectionComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "section"))
{
result.Section.Add(DocumentParser.ParseSectionComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse Request
/// </summary>
public static Request ParseRequest(IFhirReader reader, ErrorList errors, Request existingInstance = null)
{
Request result = existingInstance != null ? existingInstance : new Request();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (ParserUtils.IsAtFhirElement(reader, "language"))
{
result.Language = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (ParserUtils.IsAtFhirElement(reader, "text"))
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (ParserUtils.IsAtFhirElement(reader, "contained"))
{
result.Contained = new List <Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element internalId
else if (reader.IsAtRefIdElement())
{
result.InternalId = Id.Parse(reader.ReadRefIdContents());
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
/// <summary>
/// Action performed when Pack file is hit
/// </summary>
/// <param name="param"></param>
private async void PackFileAction(object param)
{
if (SelectedFilter < 0)
{
UserInput.ShowMessage("USER_SELECT_PACK_TYPE");
return;
}
QueueActionType = ActionType.Pack;
if (!IsItemReady())
{
return;
}
FilesActionVm.Instance.CcFiles++;
SetItemState(State.Packing | State.LongAction);
//await Task.Delay(1000);
//this.SetItemState(State.Ready);
//WorkingListVM.Instance.ProcessQueueUponActionFinalization(this);
//return;
HashMismatchFiles.Clear();
ErrorList.Clear();
_successCounter = 0;
var filesInDir = IOHelper.GetAllFilesFromDir(String.Format("{0}{1}", MainWindowVm.Instance.SelectedWorkingProfile.UnpackDirectory, DisplayName));
var indexItems = new List <IndexItem>();
string indexFilePath = String.Format("{0}{1}",
MainWindowVm.Instance.SelectedWorkingProfile.WorkingDirectory,
String.Format("{0}{1}",
DisplayName,
MainWindowVm.Instance.SelectedWorkingProfile.IndexExtension));
string packFilePath = String.Format("{0}{1}",
MainWindowVm.Instance.SelectedWorkingProfile.WorkingDirectory,
String.Format("{0}{1}",
DisplayName,
MainWindowVm.Instance.SelectedWorkingProfile.PackExtension));
if (File.Exists(packFilePath))
{
// File already packed, but will be overwritten
WindowLog.Warning("FILE_ALREADY_PACKED_BUT_OVER", Filename);
File.Delete(packFilePath);
}
if (File.Exists(indexFilePath))
{
File.Delete(EterHelper.ReplaceWithEpkExt(indexFilePath));
}
await Task.Run(() =>
{
int counter = 0;
foreach (var file in filesInDir)
{
//int type = -1;
//string fileExtension = Path.GetExtension(file.FullName);
//if (SelectedFilter.RawExtensions != null)
//{
// foreach (var rawExt in SelectedFilter.RawExtensions)
// if (rawExt.ToLower() == fileExtension.ToLower())
// type = 0;
// foreach (var lzoExt in SelectedFilter.LzoExtensions)
// if (lzoExt.ToLower() == fileExtension.ToLower())
// type = 1;
// foreach (var xteaExt in SelectedFilter.XteaExtensions)
// if (xteaExt.ToLower() == fileExtension.ToLower())
// type = 2;
//}
//if (type == -1)
// type = SelectedFilter.NotIncludedExtensionsType;
string toReplaceStr = String.Format("{0}{1}", MainWindowVm.Instance.SelectedWorkingProfile.UnpackDirectory, DisplayName).Replace("/", "\\");
string fileName = file.FullName.Substring(file.FullName.IndexOf(toReplaceStr) + toReplaceStr.Length + 1);
indexItems.Add(new IndexItem(
counter,
fileName,
null,
0,
0,
null,
0,
SelectedFilter,
DisplayName));
counter++;
}
double lastProgressValue = 0;
try
{
EterFilesDal.BuildIndexAndPackFiles(
indexItems,
packFilePath,
String.Format("{0}{1}\\",
MainWindowVm.Instance.SelectedWorkingProfile.UnpackDirectory,
DisplayName),
MainWindowVm.Instance.SelectedWorkingProfile.IndexKey,
MainWindowVm.Instance.SelectedWorkingProfile.PackKey,
(error) =>
{
if (error != null)
{
ErrorList.Add(error);
}
},
(result, progress) =>
{
if (result == 0)
{
_successCounter++;
}
if (((progress - lastProgressValue) >= 5))
{
ActionProgress = progress;
lastProgressValue = progress;
}
},
() => SetItemState(State.CriticalError));
}
catch (OutOfMemoryException ex)
{
WindowLog.Warning("FILE_TOO_BIG", DisplayName);
SetItemState(State.CriticalError);
}
catch (EterPackFileNotFoundException ex)
{
WindowLog.Error("ETER_EPK_FILE_NOT_FOUND", DisplayName);
SetItemState(State.CriticalError);
}
catch (FileNotFoundException ex)
{
WindowLog.Error("FILE_NOT_FOUND", DisplayName, new object[] { ex.FileName });
SetItemState(State.CriticalError);
}
catch (UnauthorizedAccessException ex)
{
WindowLog.Error("COULD_NOT_ACCESS_FILE", DisplayName, DisplayName);
SetItemState(State.CriticalError);
}
catch (System.IO.IOException ex)
{
WindowLog.Error("ERROR_WITH_CUSTOM_MSG", DisplayName, ex.Message);
SetItemState(State.CriticalError);
}
});
SetItemState(ErrorList.Count > 0 ? State.ReadyWithErrors : State.Ready);
ActionProgress = 100;
WindowLog.Information("ETER_PACK_RESULT", DisplayName, new object[] { _successCounter, HashMismatchFiles.Count, ErrorList.Count });
AfterLongAction(param);
}
/// <summary>
/// Parse DocumentEventComponent
/// </summary>
public static Hl7.Fhir.Model.Document.DocumentEventComponent ParseDocumentEventComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Document.DocumentEventComponent existingInstance = null)
{
Hl7.Fhir.Model.Document.DocumentEventComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Document.DocumentEventComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element code
else if (atName == "code")
{
result.Code = new List <Hl7.Fhir.Model.CodeableConcept>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "code"))
{
result.Code.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
}
reader.LeaveArray();
}
// Parse element period
else if (atName == "period")
{
result.Period = PeriodParser.ParsePeriod(reader, errors);
}
// Parse element detail
else if (atName == "detail")
{
result.Detail = new List <Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "detail"))
{
result.Detail.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Action performed when Unpack file is hit
/// </summary>
/// <param name="param"></param>
private async void UnpackFileAction(object param)
{
QueueActionType = ActionType.Unpack;
if (!IsItemReady())
{
return;
}
FilesActionVm.Instance.CcFiles++;
SetItemState(State.Unpacking | State.LongAction);
await Task.Run(() =>
{
// Set state to unpacking
SetItemState(State.Unpacking);
// Clear lists
HashMismatchFiles.Clear();
ErrorList.Clear();
// Reset counters
_successCounter = 0;
double lastProgressValue = 0;
try
{
// Unpack file
EterFilesDal.UnpackFile(
new FileInfo(EterHelper.ReplaceWithEpkExt(Path.Combine(MainWindowVm.Instance.SelectedWorkingProfile.WorkingDirectory, Filename))),
MainWindowVm.Instance.SelectedWorkingProfile.UnpackDirectory,
MainWindowVm.Instance.SelectedWorkingProfile.IndexKey,
MainWindowVm.Instance.SelectedWorkingProfile.PackKey,
(operationResult, globalProgress) =>
{
if ((globalProgress - lastProgressValue) >= 5)
{
ActionProgress = globalProgress;
lastProgressValue = globalProgress;
}
if (operationResult == 0)
{
_successCounter++;
}
},
(error, hash) =>
{
if (error != null)
{
ErrorList.Add(error);
}
if (!String.IsNullOrWhiteSpace(hash))
{
HashMismatchFiles.Add(hash);
}
});
}
catch (ErrorReadingIndexException ex)
{
WindowLog.Error("ETER_WRONG_INDEX_KEY", DisplayName);
SetItemState(State.CriticalError);
}
catch (OutOfMemoryException ex)
{
WindowLog.Warning("FILE_TOO_BIG", DisplayName);
SetItemState(State.CriticalError);
}
catch (EterPackFileNotFoundException ex)
{
WindowLog.Error("ETER_EPK_FILE_NOT_FOUND", DisplayName);
SetItemState(State.CriticalError);
}
catch (FileNotFoundException ex)
{
WindowLog.Error("FILE_NOT_FOUND", DisplayName, new object[] { ex.FileName });
SetItemState(State.CriticalError);
}
catch (UnauthorizedAccessException ex)
{
WindowLog.Error("COULD_NOT_ACCESS_FILE", DisplayName, DisplayName);
SetItemState(State.CriticalError);
}
catch (System.IO.IOException ex)
{
WindowLog.Error("ERROR_WITH_CUSTOM_MSG", DisplayName, ex.Message);
SetItemState(State.CriticalError);
}
});
// If any file produced an error, set state accordingly
if (ErrorList.Count > 0 && ItemState != State.CriticalError)
{
SetItemState(State.ReadyWithErrors);
}
else if (ErrorList.Count == 0 && ItemState != State.CriticalError)
{
SetItemState(State.Ready);
}
// Make sure progress bar is at 100%
ActionProgress = 100;
// Logging stuff
if (ItemState != State.CriticalError)
{
// Get all failed items
int failedCount = ErrorList.Count;
// Were any unnamed files present?
var item = ErrorList.FirstOrDefault(x => x.ErrorMotive.Contains("(no name)"));
// If so, add it
if (item != null)
{
failedCount += Convert.ToInt32(item.Arg) - 1;
}
WindowLog.Information("ETER_UNPACK_RESULT", DisplayName, _successCounter, HashMismatchFiles.Count, failedCount);
}
AfterLongAction(param);
}
/// <summary>
/// 日報作成・修正時の入力が正しいかチェックをする
/// </summary>
/// <returns>result 正常ならtrueを返却</returns>
///
public Boolean InputCheck()
{
Boolean result = true;
if (startHour == null || startHour.Equals(""))
{
result = false;
errorList.Add("・日時のFrom（時間）が未入力です");
}
if (startMin == null || startMin.Equals(""))
{
result = false;
errorList.Add("・日時のFrom（分）が未入力です");
}
if (endHour == null || endHour.Equals(""))
{
result = false;
errorList.Add("・日時のTo（時間）が未入力です");
}
if (endMin == null || endMin.Equals(""))
{
result = false;
errorList.Add("・日時のTo（分）が未入力です");
}
if (result)
{
//日にち、時間、分をつなげてDateTime型をstartDateAllへ
int startH = int.Parse(startHour);
int startM = int.Parse(startMin);
startDateAll = DateTime.Parse(startDate + " " + startH + ":" + startM);
//日にち、時間、分をつなげてDateTime型をendDateAllへ
int endH = int.Parse(endHour);
int endM = int.Parse(endMin);
endDateAll = DateTime.Parse(endDate + " " + endH + ":" + endM);
//開始日時が未来にならないか
resultDate = DateTime.Compare(startDateAll, dt);
if (resultDate == 1)
{
result = false;
errorList.Add("・訪問日時は現在日時以前の時間を指定してください");
}
else
{
//終了が開始より前にならないか
if (endDateAll <= startDateAll)
{
result = false;
errorList.Add("・ToはFromより後の時間にしてください");
}
}
}
if (customerName == null || customerName.Equals(""))
{
result = false;
ErrorList.Add("・訪問先の顧客を選択してください");
}
if (visitType == null || visitType.Equals(""))
{
result = false;
ErrorList.Add("・訪問種別を選択してください");
}
if (detail == null || detail.Equals(""))
{
result = false;
ErrorList.Add("・内容を入力してください");
}
return(result);
}
// Group: Loading Functions
// __________________________________________________________________________
/* Function: Load
* Attempts to parse <Project.txt> and return it as a <ProjectConfig>. Any syntax errors found will be added to the
* <ErrorList>. The <ProjectConfig> object will always exist, even if all its properties are empty.
*/
public bool Load(Path path, out ProjectConfig projectConfig, ErrorList errorList)
{
projectConfig = new ProjectConfig(Source.ProjectFile);
this.errorList = errorList;
this.projectConfig = projectConfig;
int originalErrorCount = errorList.Count;
using (var configFile = new ConfigFile())
{
// We don't condense value whitespace because some things like title, subtitle, and copyright may want multiple spaces.
bool openResult = configFile.Open(path,
ConfigFile.FileFormatFlags.CondenseIdentifierWhitespace |
ConfigFile.FileFormatFlags.MakeIdentifiersLowercase,
errorList);
if (openResult == false)
{
return(false);
}
string lcIdentifier, value;
Targets.Base currentTarget = null;
ProjectInfo currentProjectInfo = projectConfig.ProjectInfo;
while (configFile.Get(out lcIdentifier, out value))
{
var propertyLocation = new PropertyLocation(Source.ProjectFile, configFile.FileName, configFile.LineNumber);
Targets.Base target = null;
if (GetGlobalProperty(lcIdentifier, value, propertyLocation))
{
currentTarget = null;
currentProjectInfo = projectConfig.ProjectInfo;
}
else if (GetTargetHeader(lcIdentifier, value, propertyLocation, out target))
{
currentTarget = target;
if (target is Targets.OutputBase)
{
currentProjectInfo = (target as Targets.OutputBase).ProjectInfo;
}
else
{
currentProjectInfo = projectConfig.ProjectInfo;
}
}
else if (GetProjectInfoProperty(lcIdentifier, value, propertyLocation, currentProjectInfo))
{
}
else if (currentTarget != null && GetTargetProperty(lcIdentifier, value, propertyLocation, currentTarget))
{
}
else
{
errorList.Add(
message: Locale.Get("NaturalDocs.Engine", "ConfigFile.NotAValidIdentifier(identifier)", lcIdentifier),
propertyLocation: propertyLocation
);
}
}
configFile.Close();
}
return(errorList.Count == originalErrorCount);
}
/// <summary>
/// Parse ValueSetExpansionComponent
/// </summary>
public static Hl7.Fhir.Model.ValueSet.ValueSetExpansionComponent ParseValueSetExpansionComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.ValueSet.ValueSetExpansionComponent existingInstance = null)
{
Hl7.Fhir.Model.ValueSet.ValueSetExpansionComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.ValueSet.ValueSetExpansionComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element timestamp
else if (atName == "timestamp")
{
result.TimestampElement = InstantParser.ParseInstant(reader, errors);
}
// Parse element contains
else if (atName == "contains")
{
result.Contains = new List <Hl7.Fhir.Model.ValueSet.ValueSetExpansionContainsComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contains"))
{
result.Contains.Add(ValueSetParser.ParseValueSetExpansionContainsComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
protected void NextButton_Click(object sender, EventArgs e)
{
ErrorList errors = new ErrorList();
if (StringUtils.IsBlank(FtpHostTextBox.Text))
{
errors.Add("Ftp host is required");
}
if (NumericUtils.ParseInt32(FtpPortTextBox.Text, 0) == 0)
{
errors.Add("Ftp host port must be a number");
}
if (StringUtils.IsBlank(FtpUsernameTextBox.Text))
{
errors.Add("Username is required");
}
if (errors.Count > 0)
{
FeedbackLabel1.SetErrorMessage("Please check the following and try again:", errors);
return;
}
// List of files to upload
List <FtpFile> assetFilePaths = new List <FtpFile>();
// Get all of the order items in the current order
foreach (OrderItem orderItem in SelectedOrder.OrderItemList)
{
// Get the order item id
int orderItemId = orderItem.OrderItemId.GetValueOrDefault();
// Check if the order item can be downloaded and is in the list of selected order items
if (ViewOrders.CanDownload(orderItem) && SelectedOrderItems.Contains(orderItemId))
{
// Get the asset
Asset asset = orderItem.Asset;
// Get the selected order item
SelectedOrderItem soi = SelectedOrderItems.Get(orderItemId);
// Initialise path and filename to FTP
string path, filename;
// Check if zip asset files is enabled and we're not doing any kind of transcoding.
// If so, we want to FTP the zipped asset file instead, so set the path and filename accordingly.
// However, if the zip file doesn't exist, then we want to FTP the original asset instead.
if (AssetFileManager.ZipAssetFiles && soi.AssetImageSizeId == 0)
{
// First get the path to the zipped asset file
ZippedAssetFileInfo zippedFileInfo = new ZippedAssetFileInfo(asset);
if (zippedFileInfo.FileExists)
{
// Ensure that a path was returned, and if so, set the filename accordingly
path = zippedFileInfo.FilePath;
filename = Path.GetFileNameWithoutExtension(asset.Filename) + ".zip";
}
else
{
// Otherwise, the zip file doesn't exist, so get the path to the original
// asset file, and set the filename to the asset filename
AssetFileInfo info = new AssetFileInfo(asset);
path = info.FilePath;
filename = asset.Filename;
}
}
else
{
// Get the file path to the asset
AssetFileInfo info = new AssetFileInfo(asset);
path = info.FilePath;
// For images, get the filepath to the resized image
if (AssetTypeChecker.IsImage(asset.FileExtension))
{
path = AssetImageManager.GetResizedAssetImage(asset, soi.AssetImageSizeId, soi.DownloadFormat, true);
}
// Construct the asset filename
filename = Path.GetFileNameWithoutExtension(asset.Filename) + Path.GetExtension(path);
}
// Add the file path to the list
FtpFile file = new FtpFile(path, filename);
assetFilePaths.Add(file);
}
}
try
{
// Instantiate FTP downloader
FtpDownloader ftpDownloader = new FtpDownloader
{
BackgroundTransfer = true,
Host = FtpHostTextBox.Text.Trim(),
Port = NumericUtils.ParseInt32(FtpPortTextBox.Text, 0),
PassiveMode = FtpPassiveModeCheckBox.Checked,
Username = FtpUsernameTextBox.Text.Trim(),
Password = FtpPasswordTextBox.Text.Trim(),
RemoteFolder = FtpRemoteFolderTextBox.Text.Trim(),
User = CurrentUser
};
// Specify files to send to FTP server
foreach (FtpFile file in assetFilePaths)
{
ftpDownloader.Files.Add(file);
}
// Wire up events
ftpDownloader.UploadComplete += new FtpDownloadCompleteEventHandler(NotifyEngine.FtpDownloadComplete);
// Go do it!
ftpDownloader.Go();
// Log the assets as downloaded
foreach (SelectedOrderItem soi in SelectedOrderItems)
{
OrderItem orderItem = OrderItem.Get(soi.OrderItemId);
Asset asset = orderItem.Asset;
AuditLogManager.LogAssetAction(asset, CurrentUser, AuditAssetAction.DownloadedAssetFile);
AuditLogManager.LogUserAction(CurrentUser, AuditUserAction.DownloadAsset, string.Format("Downloaded AssetId: {0} as part of FTP download to: {1} for OrderId: {2}", asset.AssetId, ftpDownloader.Host, orderItem.OrderId));
}
// Lets cookie the settings as well, so we can pre-populate
// the form when the user returns to download more assets
CookieManager.SetValue("FtpHost", ftpDownloader.Host);
CookieManager.SetValue("FtpPort", ftpDownloader.Port);
CookieManager.SetValue("FtpPassiveMode", FtpPassiveModeCheckBox.Checked ? "1" : "0");
CookieManager.SetValue("FtpUsername", ftpDownloader.Username);
// Update UI
FormPanel.Visible = false;
SuccessPanel.Visible = true;
}
catch (FtpDownloadException fdex)
{
// Remove the error code from the start of the error message
string message = Regex.Replace(fdex.Message, @"(\d+\s-\s)", string.Empty);
// Display the error to the user
FeedbackLabel1.SetErrorMessage("Error downloading assets", message);
// Log the error
m_Logger.Warn(string.Format("Error downloading files to FTP. User: {0}, Host: {1}. Error: {2}", CurrentUser.FullName, FtpHostTextBox.Text, message), fdex);
}
}
/// <summary>
/// Parse Group
/// </summary>
public static Hl7.Fhir.Model.Group ParseGroup(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Group existingInstance = null )
{
Hl7.Fhir.Model.Group result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Group();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( atName == "language" )
result.LanguageElement = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( atName == "text" )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( atName == "contained" )
{
result.Contained = new List<Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element identifier
else if( atName == "identifier" )
result.Identifier = IdentifierParser.ParseIdentifier(reader, errors);
// Parse element type
else if( atName == "type" )
result.TypeElement = CodeParser.ParseCode<Hl7.Fhir.Model.Group.GroupType>(reader, errors);
// Parse element actual
else if( atName == "actual" )
result.ActualElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element code
else if( atName == "code" )
result.Code = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element name
else if( atName == "name" )
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element quantity
else if( atName == "quantity" )
result.QuantityElement = IntegerParser.ParseInteger(reader, errors);
// Parse element characteristic
else if( atName == "characteristic" )
{
result.Characteristic = new List<Hl7.Fhir.Model.Group.GroupCharacteristicComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "characteristic") )
result.Characteristic.Add(GroupParser.ParseGroupCharacteristicComponent(reader, errors));
reader.LeaveArray();
}
// Parse element member
else if( atName == "member" )
{
result.Member = new List<Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "member") )
result.Member.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse PrescriptionDispenseComponent
/// </summary>
public static Prescription.PrescriptionDispenseComponent ParsePrescriptionDispenseComponent(IFhirReader reader, ErrorList errors, Prescription.PrescriptionDispenseComponent existingInstance = null)
{
Prescription.PrescriptionDispenseComponent result = existingInstance != null ? existingInstance : new Prescription.PrescriptionDispenseComponent();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element internalId
else if (reader.IsAtRefIdElement())
{
result.InternalId = Id.Parse(reader.ReadRefIdContents());
}
// Parse element repeats
else if (ParserUtils.IsAtFhirElement(reader, "repeats"))
{
result.Repeats = IntegerParser.ParseInteger(reader, errors);
}
// Parse element quantity
else if (ParserUtils.IsAtFhirElement(reader, "quantity"))
{
result.Quantity = QuantityParser.ParseQuantity(reader, errors);
}
// Parse element dispenser
else if (ParserUtils.IsAtFhirElement(reader, "dispenser"))
{
result.Dispenser = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
/// <summary>
/// Parse AnatomicalLocation
/// </summary>
public static AnatomicalLocation ParseAnatomicalLocation(IFhirReader reader, ErrorList errors, AnatomicalLocation existingInstance = null )
{
AnatomicalLocation result = existingInstance != null ? existingInstance : new AnatomicalLocation();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if( ParserUtils.IsAtFhirElement(reader, "extension") )
{
result.Extension = new List<Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( ParserUtils.IsAtFhirElement(reader, "language") )
result.Language = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( ParserUtils.IsAtFhirElement(reader, "text") )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( ParserUtils.IsAtFhirElement(reader, "contained") )
{
result.Contained = new List<Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element internalId
else if( reader.IsAtRefIdElement() )
result.InternalId = Id.Parse(reader.ReadRefIdContents());
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return result;
}
/// <summary>
/// Parse PrescriptionAdministrationRequestComponent
/// </summary>
public static Prescription.PrescriptionAdministrationRequestComponent ParsePrescriptionAdministrationRequestComponent(IFhirReader reader, ErrorList errors, Prescription.PrescriptionAdministrationRequestComponent existingInstance = null)
{
Prescription.PrescriptionAdministrationRequestComponent result = existingInstance != null ? existingInstance : new Prescription.PrescriptionAdministrationRequestComponent();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element internalId
else if (reader.IsAtRefIdElement())
{
result.InternalId = Id.Parse(reader.ReadRefIdContents());
}
// Parse element description
else if (ParserUtils.IsAtFhirElement(reader, "description"))
{
result.Description = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element totalPeriodicDose
else if (ParserUtils.IsAtFhirElement(reader, "totalPeriodicDose"))
{
result.TotalPeriodicDose = RatioParser.ParseRatio(reader, errors);
}
// Parse element start
else if (ParserUtils.IsAtFhirElement(reader, "start"))
{
result.Start = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
}
// Parse element end
else if (ParserUtils.IsAtFhirElement(reader, "end"))
{
result.End = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
}
// Parse element duration
else if (ParserUtils.IsAtFhirElement(reader, "duration"))
{
result.Duration = QuantityParser.ParseQuantity(reader, errors);
}
// Parse element numberOfAdministrations
else if (ParserUtils.IsAtFhirElement(reader, "numberOfAdministrations"))
{
result.NumberOfAdministrations = IntegerParser.ParseInteger(reader, errors);
}
// Parse element dosageInstruction
else if (ParserUtils.IsAtFhirElement(reader, "dosageInstruction"))
{
result.DosageInstruction = new List <Prescription.PrescriptionAdministrationRequestDosageInstructionComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "dosageInstruction"))
{
result.DosageInstruction.Add(PrescriptionParser.ParsePrescriptionAdministrationRequestDosageInstructionComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
/// <summary>
/// Parse Conformance
/// </summary>
public static Hl7.Fhir.Model.Conformance ParseConformance(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance existingInstance = null )
{
Hl7.Fhir.Model.Conformance result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( atName == "language" )
result.LanguageElement = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( atName == "text" )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( atName == "contained" )
{
result.Contained = new List<Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element identifier
else if( atName == "identifier" )
result.IdentifierElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element version
else if( atName == "version" )
result.VersionElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element name
else if( atName == "name" )
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element publisher
else if( atName == "publisher" )
result.PublisherElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element telecom
else if( atName == "telecom" )
{
result.Telecom = new List<Hl7.Fhir.Model.Contact>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "telecom") )
result.Telecom.Add(ContactParser.ParseContact(reader, errors));
reader.LeaveArray();
}
// Parse element description
else if( atName == "description" )
result.DescriptionElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element status
else if( atName == "status" )
result.StatusElement = CodeParser.ParseCode<Hl7.Fhir.Model.Conformance.ConformanceStatementStatus>(reader, errors);
// Parse element experimental
else if( atName == "experimental" )
result.ExperimentalElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element date
else if( atName == "date" )
result.DateElement = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
// Parse element software
else if( atName == "software" )
result.Software = ConformanceParser.ParseConformanceSoftwareComponent(reader, errors);
// Parse element implementation
else if( atName == "implementation" )
result.Implementation = ConformanceParser.ParseConformanceImplementationComponent(reader, errors);
// Parse element fhirVersion
else if( atName == "fhirVersion" )
result.FhirVersionElement = IdParser.ParseId(reader, errors);
// Parse element acceptUnknown
else if( atName == "acceptUnknown" )
result.AcceptUnknownElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element format
else if( atName == "format" )
{
result.FormatElement = new List<Hl7.Fhir.Model.Code>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "format") )
result.FormatElement.Add(CodeParser.ParseCode(reader, errors));
reader.LeaveArray();
}
// Parse element rest
else if( atName == "rest" )
{
result.Rest = new List<Hl7.Fhir.Model.Conformance.ConformanceRestComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "rest") )
result.Rest.Add(ConformanceParser.ParseConformanceRestComponent(reader, errors));
reader.LeaveArray();
}
// Parse element messaging
else if( atName == "messaging" )
{
result.Messaging = new List<Hl7.Fhir.Model.Conformance.ConformanceMessagingComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "messaging") )
result.Messaging.Add(ConformanceParser.ParseConformanceMessagingComponent(reader, errors));
reader.LeaveArray();
}
// Parse element document
else if( atName == "document" )
{
result.Document = new List<Hl7.Fhir.Model.Conformance.ConformanceDocumentComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "document") )
result.Document.Add(ConformanceParser.ParseConformanceDocumentComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse PrescriptionMedicineComponent
/// </summary>
public static Prescription.PrescriptionMedicineComponent ParsePrescriptionMedicineComponent(IFhirReader reader, ErrorList errors, Prescription.PrescriptionMedicineComponent existingInstance = null)
{
Prescription.PrescriptionMedicineComponent result = existingInstance != null ? existingInstance : new Prescription.PrescriptionMedicineComponent();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element internalId
else if (reader.IsAtRefIdElement())
{
result.InternalId = Id.Parse(reader.ReadRefIdContents());
}
// Parse element identification
else if (ParserUtils.IsAtFhirElement(reader, "identification"))
{
result.Identification = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element activeIngredient
else if (ParserUtils.IsAtFhirElement(reader, "activeIngredient"))
{
result.ActiveIngredient = new List <Prescription.PrescriptionMedicineActiveIngredientComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "activeIngredient"))
{
result.ActiveIngredient.Add(PrescriptionParser.ParsePrescriptionMedicineActiveIngredientComponent(reader, errors));
}
reader.LeaveArray();
}
// Parse element inactiveIngredient
else if (ParserUtils.IsAtFhirElement(reader, "inactiveIngredient"))
{
result.InactiveIngredient = new List <Prescription.PrescriptionMedicineInactiveIngredientComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "inactiveIngredient"))
{
result.InactiveIngredient.Add(PrescriptionParser.ParsePrescriptionMedicineInactiveIngredientComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
/// <summary>
/// Parse ConformanceSoftwareComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceSoftwareComponent ParseConformanceSoftwareComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceSoftwareComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceSoftwareComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceSoftwareComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element name
else if( atName == "name" )
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element version
else if( atName == "version" )
result.VersionElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element releaseDate
else if( atName == "releaseDate" )
result.ReleaseDateElement = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse Prescription
/// </summary>
public static Prescription ParsePrescription(IFhirReader reader, ErrorList errors, Prescription existingInstance = null)
{
Prescription result = existingInstance != null ? existingInstance : new Prescription();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (ParserUtils.IsAtFhirElement(reader, "language"))
{
result.Language = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (ParserUtils.IsAtFhirElement(reader, "text"))
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (ParserUtils.IsAtFhirElement(reader, "contained"))
{
result.Contained = new List <Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element internalId
else if (reader.IsAtRefIdElement())
{
result.InternalId = Id.Parse(reader.ReadRefIdContents());
}
// Parse element identifier
else if (ParserUtils.IsAtFhirElement(reader, "identifier"))
{
result.Identifier = new List <Identifier>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "identifier"))
{
result.Identifier.Add(IdentifierParser.ParseIdentifier(reader, errors));
}
reader.LeaveArray();
}
// Parse element status
else if (ParserUtils.IsAtFhirElement(reader, "status"))
{
result.Status = CodeParser.ParseCode <Prescription.PrescriptionStatus>(reader, errors);
}
// Parse element patient
else if (ParserUtils.IsAtFhirElement(reader, "patient"))
{
result.Patient = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element prescriber
else if (ParserUtils.IsAtFhirElement(reader, "prescriber"))
{
result.Prescriber = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element prescribed
else if (ParserUtils.IsAtFhirElement(reader, "prescribed"))
{
result.Prescribed = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
}
// Parse element dispense
else if (ParserUtils.IsAtFhirElement(reader, "dispense"))
{
result.Dispense = PrescriptionParser.ParsePrescriptionDispenseComponent(reader, errors);
}
// Parse element medicine
else if (ParserUtils.IsAtFhirElement(reader, "medicine"))
{
result.Medicine = PrescriptionParser.ParsePrescriptionMedicineComponent(reader, errors);
}
// Parse element administrationRequest
else if (ParserUtils.IsAtFhirElement(reader, "administrationRequest"))
{
result.AdministrationRequest = PrescriptionParser.ParsePrescriptionAdministrationRequestComponent(reader, errors);
}
// Parse element reason
else if (ParserUtils.IsAtFhirElement(reader, "reason"))
{
result.Reason = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
public void ShouldBeAbleToGetErrorInfoByFieldName()
{
ErrorList errors = new ErrorList();
errors.Add(new ErrorInfo("Name", "Can't be blank"));
Assert.AreEqual("Name can't be blank", errors["Name"].ToString());
}
/// <summary>
/// Parse HumanName
/// </summary>
public static Hl7.Fhir.Model.HumanName ParseHumanName(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.HumanName existingInstance = null )
{
Hl7.Fhir.Model.HumanName result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.HumanName();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element use
else if( atName == "use" )
result.UseElement = CodeParser.ParseCode<Hl7.Fhir.Model.HumanName.NameUse>(reader, errors);
// Parse element text
else if( atName == "text" )
result.TextElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element family
else if( atName == "family" )
{
result.FamilyElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "family") )
result.FamilyElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
// Parse element given
else if( atName == "given" )
{
result.GivenElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "given") )
result.GivenElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
// Parse element prefix
else if( atName == "prefix" )
{
result.PrefixElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "prefix") )
result.PrefixElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
// Parse element suffix
else if( atName == "suffix" )
{
result.SuffixElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "suffix") )
result.SuffixElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
// Parse element period
else if( atName == "period" )
result.Period = PeriodParser.ParsePeriod(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
public bool LoadDatabaseMetadata(string database_name, string connection_string)
{
if (string.IsNullOrEmpty(database_name))
{
throw new ArgumentException("Database name is null or empty");
}
Reset();
Name = database_name;
ConnectionString = connection_string;
// load and parse out table data
try
{
string sql_query = GetTableData();
DataTable dt = Database.ExecuteQuery(sql_query, null, ConnectionString);
if (dt != null && dt.Rows.Count != 0 && dt.Columns.Count != 0)
{
foreach (DataRow dr in dt.Rows)
{
string table_name = (string)dr["TableName"];
string column_name = (string)dr["ColumnName"];
if (!Tables.ContainsKey(table_name))
{
SqlTable sql_table = new SqlTable(this, table_name);
Tables.Add(table_name, sql_table);
}
SqlColumn sql_column = new SqlColumn();
sql_column.Table = Tables[table_name];
sql_column.Name = (string)dr["ColumnName"];
sql_column.DataType = (string)dr["DataType"];
sql_column.Length = Convert.ToInt32(dr["Length"]);
sql_column.Precision = Convert.ToInt32(dr["Precision"]);
sql_column.IsNullable = Convert.ToBoolean(dr["IsNullable"]);
sql_column.IsPk = Convert.ToBoolean(dr["IsPK"]);
sql_column.IsIdentity = Convert.ToBoolean(dr["IsIdentity"]);
sql_column.ColumnOrdinal = Convert.ToInt32(dr["ColumnOrdinal"]);
if (Tables[table_name].Columns.ContainsKey(column_name))
{
throw new Exception($"Column {column_name} already exists in table {Tables[table_name]}");
}
else
{
Tables[table_name].Columns.Add(column_name, sql_column);
}
}
}
}
catch (Exception ex)
{
ErrorList.Add(ex);
}
// get SP
try
{
string sql_query = GetStoredProcedures();
DataTable dt = Database.ExecuteQuery(sql_query, null, ConnectionString);
if (dt != null && dt.Rows.Count != 0 && dt.Columns.Count != 0)
{
foreach (DataRow dr in dt.Rows)
{
SqlScript sql_script = new SqlScript();
sql_script.Name = (string)dr["Name"];
sql_script.Body = (string)dr["Body"];
if (StoredProcedures.ContainsKey(sql_script.Name))
{
StoredProcedures[sql_script.Name].Body += sql_script.Body;
}
else
{
StoredProcedures.Add(sql_script.Name, sql_script);
}
}
}
}
catch (Exception ex)
{
ErrorList.Add(ex);
}
// get functions
try
{
string sql_query = GetFunctions();
DataTable dt = Database.ExecuteQuery(sql_query, null, ConnectionString);
if (dt != null && dt.Rows.Count != 0 && dt.Columns.Count != 0)
{
foreach (DataRow dr in dt.Rows)
{
SqlScript sql_script = new SqlScript();
sql_script.Name = (string)dr["Name"];
sql_script.Body = (string)dr["Body"];
if (Functions.ContainsKey(sql_script.Name))
{
Functions[sql_script.Name].Body += sql_script.Body;
}
else
{
Functions.Add(sql_script.Name, sql_script);
}
}
}
}
catch (Exception ex)
{
ErrorList.Add(ex);
}
// get constraints
try
{
string sql_query = GetConstraints();
DataTable dt = Database.ExecuteQuery(sql_query, null, ConnectionString);
if (dt != null && dt.Rows.Count != 0 && dt.Columns.Count != 0)
{
foreach (DataRow dr in dt.Rows)
{
SqlConstraint sql_constraint = new SqlConstraint();
sql_constraint.ConstraintName = (string)dr["ConstraintName"];
sql_constraint.FKTable = (string)dr["FKTable"];
sql_constraint.FKColumn = (string)dr["FKColumn"];
sql_constraint.PKTable = (string)dr["PKTable"];
sql_constraint.PKColumn = (string)dr["PKColumn"];
if (Constraints.ContainsKey(sql_constraint.ConstraintName))
{
throw new Exception(string.Format("Constraint {0} already exists.", sql_constraint.ConstraintName));
}
else
{
Constraints.Add(sql_constraint.ConstraintName, sql_constraint);
}
}
}
}
catch (Exception ex)
{
ErrorList.Add(ex);
}
// load default values
try
{
string sql_query = GetDefaultValues();
DataTable dt = Database.ExecuteQuery(sql_query, null, ConnectionString);
if (dt != null && dt.Rows.Count != 0 && dt.Columns.Count != 0)
{
foreach (DataRow dr in dt.Rows)
{
if (Tables.ContainsKey((string)dr["TableName"]))
{
if (Tables[(string)dr["TableName"]].Columns.ContainsKey((string)dr["ColumnName"]))
{
Tables[(string)dr["TableName"]].Columns[(string)dr["ColumnName"]].DefaultValue = RemoveWrappingCharacters((string)dr["DefaultValue"]);
}
}
}
}
}
catch (Exception ex)
{
ErrorList.Add(ex);
}
return(ErrorList.Count == 0);
}
/// <summary>
/// Parse EncounterParticipantComponent
/// </summary>
public static Hl7.Fhir.Model.Encounter.EncounterParticipantComponent ParseEncounterParticipantComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Encounter.EncounterParticipantComponent existingInstance = null )
{
Hl7.Fhir.Model.Encounter.EncounterParticipantComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Encounter.EncounterParticipantComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element type
else if( atName == "type" )
{
result.TypeElement = new List<Code<Hl7.Fhir.Model.Encounter.ParticipantType>>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "type") )
result.TypeElement.Add(CodeParser.ParseCode<Hl7.Fhir.Model.Encounter.ParticipantType>(reader, errors));
reader.LeaveArray();
}
// Parse element practitioner
else if( atName == "practitioner" )
result.Practitioner = ResourceReferenceParser.ParseResourceReference(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse ConceptSetComponent
/// </summary>
public static Hl7.Fhir.Model.ValueSet.ConceptSetComponent ParseConceptSetComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.ValueSet.ConceptSetComponent existingInstance = null)
{
Hl7.Fhir.Model.ValueSet.ConceptSetComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.ValueSet.ConceptSetComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element system
else if (atName == "system")
{
result.SystemElement = FhirUriParser.ParseFhirUri(reader, errors);
}
// Parse element version
else if (atName == "version")
{
result.VersionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element code
else if (atName == "code")
{
result.CodeElement = new List <Hl7.Fhir.Model.Code>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "code"))
{
result.CodeElement.Add(CodeParser.ParseCode(reader, errors));
}
reader.LeaveArray();
}
// Parse element filter
else if (atName == "filter")
{
result.Filter = new List <Hl7.Fhir.Model.ValueSet.ConceptSetFilterComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "filter"))
{
result.Filter.Add(ValueSetParser.ParseConceptSetFilterComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse CodeableConcept
/// </summary>
public static Hl7.Fhir.Model.CodeableConcept ParseCodeableConcept(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.CodeableConcept existingInstance = null )
{
Hl7.Fhir.Model.CodeableConcept result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.CodeableConcept();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element coding
else if( atName == "coding" )
{
result.Coding = new List<Hl7.Fhir.Model.Coding>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "coding") )
result.Coding.Add(CodingParser.ParseCoding(reader, errors));
reader.LeaveArray();
}
// Parse element text
else if( atName == "text" )
result.TextElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element primary
else if( atName == "primary" )
result.PrimaryElement = IdRefParser.ParseIdRef(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse PrescriptionAdministrationRequestDosageInstructionComponent
/// </summary>
public static Prescription.PrescriptionAdministrationRequestDosageInstructionComponent ParsePrescriptionAdministrationRequestDosageInstructionComponent(IFhirReader reader, ErrorList errors, Prescription.PrescriptionAdministrationRequestDosageInstructionComponent existingInstance = null)
{
Prescription.PrescriptionAdministrationRequestDosageInstructionComponent result = existingInstance != null ? existingInstance : new Prescription.PrescriptionAdministrationRequestDosageInstructionComponent();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element internalId
else if (reader.IsAtRefIdElement())
{
result.InternalId = Id.Parse(reader.ReadRefIdContents());
}
// Parse element precondition
else if (ParserUtils.IsAtFhirElement(reader, "precondition"))
{
result.Precondition = new List <CodeableConcept>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "precondition"))
{
result.Precondition.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
}
reader.LeaveArray();
}
// Parse element prn
else if (ParserUtils.IsAtFhirElement(reader, "prn"))
{
result.Prn = FhirBooleanParser.ParseFhirBoolean(reader, errors);
}
// Parse element additionalInstruction
else if (ParserUtils.IsAtFhirElement(reader, "additionalInstruction"))
{
result.AdditionalInstruction = new List <CodeableConcept>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "additionalInstruction"))
{
result.AdditionalInstruction.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
}
reader.LeaveArray();
}
// Parse element route
else if (ParserUtils.IsAtFhirElement(reader, "route"))
{
result.Route = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element dose
else if (ParserUtils.IsAtFhirElement(reader, "dose", true))
{
result.Dose = FhirParser.ParseElement(reader, errors);
}
// Parse element rate
else if (ParserUtils.IsAtFhirElement(reader, "rate"))
{
result.Rate = QuantityParser.ParseQuantity(reader, errors);
}
// Parse element schedule
else if (ParserUtils.IsAtFhirElement(reader, "schedule"))
{
result.Schedule = new List <Schedule>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "schedule"))
{
result.Schedule.Add(ScheduleParser.ParseSchedule(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
/// <summary>
/// Parse ValueSetDefineConceptComponent
/// </summary>
public static Hl7.Fhir.Model.ValueSet.ValueSetDefineConceptComponent ParseValueSetDefineConceptComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.ValueSet.ValueSetDefineConceptComponent existingInstance = null)
{
Hl7.Fhir.Model.ValueSet.ValueSetDefineConceptComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.ValueSet.ValueSetDefineConceptComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element code
else if (atName == "code")
{
result.CodeElement = CodeParser.ParseCode(reader, errors);
}
// Parse element abstract
else if (atName == "abstract")
{
result.AbstractElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
}
// Parse element display
else if (atName == "display")
{
result.DisplayElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element definition
else if (atName == "definition")
{
result.DefinitionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element concept
else if (atName == "concept")
{
result.Concept = new List <Hl7.Fhir.Model.ValueSet.ValueSetDefineConceptComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "concept"))
{
result.Concept.Add(ValueSetParser.ParseValueSetDefineConceptComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse EncounterHospitalizationComponent
/// </summary>
public static Hl7.Fhir.Model.Encounter.EncounterHospitalizationComponent ParseEncounterHospitalizationComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Encounter.EncounterHospitalizationComponent existingInstance = null )
{
Hl7.Fhir.Model.Encounter.EncounterHospitalizationComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Encounter.EncounterHospitalizationComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element preAdmissionIdentifier
else if( atName == "preAdmissionIdentifier" )
result.PreAdmissionIdentifier = IdentifierParser.ParseIdentifier(reader, errors);
// Parse element origin
else if( atName == "origin" )
result.Origin = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element admitSource
else if( atName == "admitSource" )
result.AdmitSource = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element period
else if( atName == "period" )
result.Period = PeriodParser.ParsePeriod(reader, errors);
// Parse element accomodation
else if( atName == "accomodation" )
{
result.Accomodation = new List<Hl7.Fhir.Model.Encounter.EncounterHospitalizationAccomodationComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "accomodation") )
result.Accomodation.Add(EncounterParser.ParseEncounterHospitalizationAccomodationComponent(reader, errors));
reader.LeaveArray();
}
// Parse element diet
else if( atName == "diet" )
result.Diet = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element specialCourtesy
else if( atName == "specialCourtesy" )
{
result.SpecialCourtesy = new List<Hl7.Fhir.Model.CodeableConcept>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "specialCourtesy") )
result.SpecialCourtesy.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
reader.LeaveArray();
}
// Parse element specialArrangement
else if( atName == "specialArrangement" )
{
result.SpecialArrangement = new List<Hl7.Fhir.Model.CodeableConcept>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "specialArrangement") )
result.SpecialArrangement.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
reader.LeaveArray();
}
// Parse element destination
else if( atName == "destination" )
result.Destination = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element dischargeDisposition
else if( atName == "dischargeDisposition" )
result.DischargeDisposition = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element reAdmission
else if( atName == "reAdmission" )
result.ReAdmissionElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse OperationOutcomeIssueComponent
/// </summary>
public static Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent ParseOperationOutcomeIssueComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent existingInstance = null)
{
Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element severity
else if (atName == "severity")
{
result.SeverityElement = CodeParser.ParseCode <Hl7.Fhir.Model.OperationOutcome.IssueSeverity>(reader, errors);
}
// Parse element type
else if (atName == "type")
{
result.Type = CodingParser.ParseCoding(reader, errors);
}
// Parse element details
else if (atName == "details")
{
result.DetailsElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element location
else if (atName == "location")
{
result.LocationElement = new List <Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "location"))
{
result.LocationElement.Add(FhirStringParser.ParseFhirString(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse Encounter
/// </summary>
public static Hl7.Fhir.Model.Encounter ParseEncounter(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Encounter existingInstance = null )
{
Hl7.Fhir.Model.Encounter result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Encounter();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( atName == "language" )
result.LanguageElement = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( atName == "text" )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( atName == "contained" )
{
result.Contained = new List<Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element identifier
else if( atName == "identifier" )
{
result.Identifier = new List<Hl7.Fhir.Model.Identifier>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "identifier") )
result.Identifier.Add(IdentifierParser.ParseIdentifier(reader, errors));
reader.LeaveArray();
}
// Parse element status
else if( atName == "status" )
result.StatusElement = CodeParser.ParseCode<Hl7.Fhir.Model.Encounter.EncounterState>(reader, errors);
// Parse element class
else if( atName == "class" )
result.ClassElement = CodeParser.ParseCode<Hl7.Fhir.Model.Encounter.EncounterClass>(reader, errors);
// Parse element type
else if( atName == "type" )
{
result.Type = new List<Hl7.Fhir.Model.CodeableConcept>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "type") )
result.Type.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
reader.LeaveArray();
}
// Parse element subject
else if( atName == "subject" )
result.Subject = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element participant
else if( atName == "participant" )
{
result.Participant = new List<Hl7.Fhir.Model.Encounter.EncounterParticipantComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "participant") )
result.Participant.Add(EncounterParser.ParseEncounterParticipantComponent(reader, errors));
reader.LeaveArray();
}
// Parse element fulfills
else if( atName == "fulfills" )
result.Fulfills = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element start
else if( atName == "start" )
result.StartElement = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
// Parse element length
else if( atName == "length" )
result.Length = DurationParser.ParseDuration(reader, errors);
// Parse element reason
else if( atName.StartsWith("reason") )
result.Reason = FhirParser.ParseElement(reader, errors);
// Parse element indication
else if( atName == "indication" )
result.Indication = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element priority
else if( atName == "priority" )
result.Priority = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element hospitalization
else if( atName == "hospitalization" )
result.Hospitalization = EncounterParser.ParseEncounterHospitalizationComponent(reader, errors);
// Parse element location
else if( atName == "location" )
{
result.Location = new List<Hl7.Fhir.Model.Encounter.EncounterLocationComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "location") )
result.Location.Add(EncounterParser.ParseEncounterLocationComponent(reader, errors));
reader.LeaveArray();
}
// Parse element serviceProvider
else if( atName == "serviceProvider" )
result.ServiceProvider = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element partOf
else if( atName == "partOf" )
result.PartOf = ResourceReferenceParser.ParseResourceReference(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse OperationOutcome
/// </summary>
public static Hl7.Fhir.Model.OperationOutcome ParseOperationOutcome(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.OperationOutcome existingInstance = null)
{
Hl7.Fhir.Model.OperationOutcome result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.OperationOutcome();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (atName == "language")
{
result.LanguageElement = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (atName == "text")
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (atName == "contained")
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element issue
else if (atName == "issue")
{
result.Issue = new List <Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "issue"))
{
result.Issue.Add(OperationOutcomeParser.ParseOperationOutcomeIssueComponent(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse GroupCharacteristicComponent
/// </summary>
public static Hl7.Fhir.Model.Group.GroupCharacteristicComponent ParseGroupCharacteristicComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Group.GroupCharacteristicComponent existingInstance = null )
{
Hl7.Fhir.Model.Group.GroupCharacteristicComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Group.GroupCharacteristicComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element type
else if( atName == "type" )
result.Type = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element value
else if( atName.StartsWith("value") )
result.Value = FhirParser.ParseElement(reader, errors);
// Parse element exclude
else if( atName == "exclude" )
result.ExcludeElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse ProblemRelatedItemComponent
/// </summary>
public static Hl7.Fhir.Model.Problem.ProblemRelatedItemComponent ParseProblemRelatedItemComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Problem.ProblemRelatedItemComponent existingInstance = null)
{
Hl7.Fhir.Model.Problem.ProblemRelatedItemComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Problem.ProblemRelatedItemComponent();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (ParserUtils.IsAtFhirElement(reader, "_id"))
{
result.LocalId = Id.Parse(reader.ReadPrimitiveContents("id"));
}
// Parse element type
else if (ParserUtils.IsAtFhirElement(reader, "type"))
{
result.Type = CodeParser.ParseCode <Hl7.Fhir.Model.Problem.ProblemRelationshipType>(reader, errors);
}
// Parse element code
else if (ParserUtils.IsAtFhirElement(reader, "code"))
{
result.Code = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element target
else if (ParserUtils.IsAtFhirElement(reader, "target"))
{
result.Target = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
public ErrorList Validate()
{
ErrorList result = new ErrorList();
if (Label == null)
result.Add("Tag label cannot be null");
return result;
}
/// <summary>
/// Parse Problem
/// </summary>
public static Hl7.Fhir.Model.Problem ParseProblem(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Problem existingInstance = null)
{
Hl7.Fhir.Model.Problem result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Problem();
try
{
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
// Parse element extension
if (ParserUtils.IsAtFhirElement(reader, "extension"))
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (ParserUtils.IsAtFhirElement(reader, "language"))
{
result.Language = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (ParserUtils.IsAtFhirElement(reader, "text"))
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (ParserUtils.IsAtFhirElement(reader, "contained"))
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (ParserUtils.IsAtFhirElement(reader, "_id"))
{
result.LocalId = Id.Parse(reader.ReadPrimitiveContents("id"));
}
// Parse element subject
else if (ParserUtils.IsAtFhirElement(reader, "subject"))
{
result.Subject = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element visit
else if (ParserUtils.IsAtFhirElement(reader, "visit"))
{
result.Visit = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element asserter
else if (ParserUtils.IsAtFhirElement(reader, "asserter"))
{
result.Asserter = ResourceReferenceParser.ParseResourceReference(reader, errors);
}
// Parse element dateAsserted
else if (ParserUtils.IsAtFhirElement(reader, "dateAsserted"))
{
result.DateAsserted = DateParser.ParseDate(reader, errors);
}
// Parse element code
else if (ParserUtils.IsAtFhirElement(reader, "code"))
{
result.Code = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element category
else if (ParserUtils.IsAtFhirElement(reader, "category"))
{
result.Category = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element status
else if (ParserUtils.IsAtFhirElement(reader, "status"))
{
result.Status = CodeParser.ParseCode <Hl7.Fhir.Model.Problem.ProblemStatus>(reader, errors);
}
// Parse element certainty
else if (ParserUtils.IsAtFhirElement(reader, "certainty"))
{
result.Certainty = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element severity
else if (ParserUtils.IsAtFhirElement(reader, "severity"))
{
result.Severity = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element onset
else if (ParserUtils.IsAtFhirElement(reader, "onset", true))
{
result.Onset = FhirParser.ParseElement(reader, errors);
}
// Parse element abatement
else if (ParserUtils.IsAtFhirElement(reader, "abatement", true))
{
result.Abatement = FhirParser.ParseElement(reader, errors);
}
// Parse element stage
else if (ParserUtils.IsAtFhirElement(reader, "stage"))
{
result.Stage = ProblemParser.ParseProblemStageComponent(reader, errors);
}
// Parse element evidence
else if (ParserUtils.IsAtFhirElement(reader, "evidence"))
{
result.Evidence = new List <Hl7.Fhir.Model.Problem.ProblemEvidenceComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "evidence"))
{
result.Evidence.Add(ProblemParser.ParseProblemEvidenceComponent(reader, errors));
}
reader.LeaveArray();
}
// Parse element location
else if (ParserUtils.IsAtFhirElement(reader, "location"))
{
result.Location = new List <Hl7.Fhir.Model.Problem.ProblemLocationComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "location"))
{
result.Location.Add(ProblemParser.ParseProblemLocationComponent(reader, errors));
}
reader.LeaveArray();
}
// Parse element relatedItem
else if (ParserUtils.IsAtFhirElement(reader, "relatedItem"))
{
result.RelatedItem = new List <Hl7.Fhir.Model.Problem.ProblemRelatedItemComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "relatedItem"))
{
result.RelatedItem.Add(ProblemParser.ParseProblemRelatedItemComponent(reader, errors));
}
reader.LeaveArray();
}
// Parse element notes
else if (ParserUtils.IsAtFhirElement(reader, "notes"))
{
result.Notes = FhirStringParser.ParseFhirString(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
}
catch (Exception ex)
{
errors.Add(ex.Message, reader);
}
return(result);
}
/// <summary>
/// Parse OperationOutcome
/// </summary>
public static Hl7.Fhir.Model.OperationOutcome ParseOperationOutcome(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.OperationOutcome existingInstance = null )
{
Hl7.Fhir.Model.OperationOutcome result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.OperationOutcome();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( atName == "language" )
result.LanguageElement = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( atName == "text" )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( atName == "contained" )
{
result.Contained = new List<Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element issue
else if( atName == "issue" )
{
result.Issue = new List<Hl7.Fhir.Model.OperationOutcome.OperationOutcomeIssueComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "issue") )
result.Issue.Add(OperationOutcomeParser.ParseOperationOutcomeIssueComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
public CustomError(ErrorType type)
: this()
{
ErrorList.Add(type);
}
/// <summary>
/// Parse ConformanceMessagingComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceMessagingComponent ParseConformanceMessagingComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceMessagingComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceMessagingComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceMessagingComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element endpoint
else if( atName == "endpoint" )
result.EndpointElement = FhirUriParser.ParseFhirUri(reader, errors);
// Parse element reliableCache
else if( atName == "reliableCache" )
result.ReliableCacheElement = IntegerParser.ParseInteger(reader, errors);
// Parse element documentation
else if( atName == "documentation" )
result.DocumentationElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element event
else if( atName == "event" )
{
result.Event = new List<Hl7.Fhir.Model.Conformance.ConformanceMessagingEventComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "event") )
result.Event.Add(ConformanceParser.ParseConformanceMessagingEventComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
public void Add(ErrorType type)
{
ErrorList.Add(type);
}
/// <summary>
/// Parse ConformanceRestComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceRestComponent ParseConformanceRestComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceRestComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceRestComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceRestComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element mode
else if( atName == "mode" )
result.ModeElement = CodeParser.ParseCode<Hl7.Fhir.Model.Conformance.RestfulConformanceMode>(reader, errors);
// Parse element documentation
else if( atName == "documentation" )
result.DocumentationElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element security
else if( atName == "security" )
result.Security = ConformanceParser.ParseConformanceRestSecurityComponent(reader, errors);
// Parse element resource
else if( atName == "resource" )
{
result.Resource = new List<Hl7.Fhir.Model.Conformance.ConformanceRestResourceComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "resource") )
result.Resource.Add(ConformanceParser.ParseConformanceRestResourceComponent(reader, errors));
reader.LeaveArray();
}
// Parse element batch
else if( atName == "batch" )
result.BatchElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element history
else if( atName == "history" )
result.HistoryElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element query
else if( atName == "query" )
{
result.Query = new List<Hl7.Fhir.Model.Conformance.ConformanceRestQueryComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "query") )
result.Query.Add(ConformanceParser.ParseConformanceRestQueryComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse Substance
/// </summary>
public static Hl7.Fhir.Model.Substance ParseSubstance(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Substance existingInstance = null)
{
Hl7.Fhir.Model.Substance result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Substance();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (atName == "language")
{
result.LanguageElement = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (atName == "text")
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (atName == "contained")
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element identifier
else if (atName == "identifier")
{
result.Identifier = IdentifierParser.ParseIdentifier(reader, errors);
}
// Parse element name
else if (atName == "name")
{
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element type
else if (atName == "type")
{
result.Type = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element description
else if (atName == "description")
{
result.DescriptionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element status
else if (atName == "status")
{
result.Status = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element effectiveTime
else if (atName == "effectiveTime")
{
result.EffectiveTime = PeriodParser.ParsePeriod(reader, errors);
}
// Parse element quantity
else if (atName == "quantity")
{
result.Quantity = QuantityParser.ParseQuantity(reader, errors);
}
// Parse element ingredient
else if (atName == "ingredient")
{
result.Ingredient = new List <Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "ingredient"))
{
result.Ingredient.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
}
reader.LeaveArray();
}
// Parse element quantityMode
else if (atName == "quantityMode")
{
result.QuantityMode = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse ConformanceRestResourceComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceRestResourceComponent ParseConformanceRestResourceComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceRestResourceComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceRestResourceComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceRestResourceComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element type
else if( atName == "type" )
result.TypeElement = CodeParser.ParseCode(reader, errors);
// Parse element profile
else if( atName == "profile" )
result.Profile = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element operation
else if( atName == "operation" )
{
result.Operation = new List<Hl7.Fhir.Model.Conformance.ConformanceRestResourceOperationComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "operation") )
result.Operation.Add(ConformanceParser.ParseConformanceRestResourceOperationComponent(reader, errors));
reader.LeaveArray();
}
// Parse element readHistory
else if( atName == "readHistory" )
result.ReadHistoryElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
// Parse element searchInclude
else if( atName == "searchInclude" )
{
result.SearchIncludeElement = new List<Hl7.Fhir.Model.FhirString>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "searchInclude") )
result.SearchIncludeElement.Add(FhirStringParser.ParseFhirString(reader, errors));
reader.LeaveArray();
}
// Parse element searchParam
else if( atName == "searchParam" )
{
result.SearchParam = new List<Hl7.Fhir.Model.Conformance.ConformanceRestResourceSearchParamComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "searchParam") )
result.SearchParam.Add(ConformanceParser.ParseConformanceRestResourceSearchParamComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
public static void ExecuteScript(IServerProcess process, string script, ScriptExecuteOption options, out ErrorList errors, out TimeSpan timeElapsed, ReportScriptProgressHandler reportScriptProgress, DebugLocator locator)
{
StringBuilder result = new StringBuilder();
errors = new ErrorList();
timeElapsed = TimeSpan.Zero;
bool attemptExecute = true;
DateTime startTime = DateTime.Now;
try
{
IServerScript localScript = process.PrepareScript(script, locator);
try
{
if (ConvertParserErrors(localScript.Messages, errors))
{
foreach (IServerBatch batch in localScript.Batches)
{
PlanStatistics statistics = null;
try
{
if (batch.IsExpression())
{
IServerExpressionPlan plan = batch.PrepareExpression(null);
try
{
attemptExecute &= ConvertCompilerErrors(plan.Messages, errors);
if (attemptExecute)
{
int rowCount = ReadResult(result, plan);
AppendStatistics(result, options, plan.PlanStatistics, plan.ProgramStatistics, rowCount);
statistics = plan.PlanStatistics;
}
}
finally
{
batch.UnprepareExpression(plan);
}
}
else
{
IServerStatementPlan plan = batch.PrepareStatement(null);
try
{
attemptExecute &= ConvertCompilerErrors(plan.Messages, errors);
if (attemptExecute)
{
plan.Execute(null);
AppendStatistics(result, options, plan.PlanStatistics, plan.ProgramStatistics, -1);
statistics = plan.PlanStatistics;
}
}
finally
{
batch.UnprepareStatement(plan);
}
}
}
finally
{
if (reportScriptProgress != null)
{
reportScriptProgress(statistics, result.ToString());
}
result.Length = 0;
}
} // foreach batch...
} // if (no parser errors)...
}
finally
{
process.UnprepareScript(localScript);
}
}
catch (Exception exception)
{
errors.Add(exception);
}
timeElapsed = DateTime.Now - startTime;
}
/// <summary>
/// Parse ConformanceRestSecurityComponent
/// </summary>
public static Hl7.Fhir.Model.Conformance.ConformanceRestSecurityComponent ParseConformanceRestSecurityComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Conformance.ConformanceRestSecurityComponent existingInstance = null )
{
Hl7.Fhir.Model.Conformance.ConformanceRestSecurityComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Conformance.ConformanceRestSecurityComponent();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element service
else if( atName == "service" )
{
result.Service = new List<Hl7.Fhir.Model.CodeableConcept>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "service") )
result.Service.Add(CodeableConceptParser.ParseCodeableConcept(reader, errors));
reader.LeaveArray();
}
// Parse element description
else if( atName == "description" )
result.DescriptionElement = FhirStringParser.ParseFhirString(reader, errors);
// Parse element certificate
else if( atName == "certificate" )
{
result.Certificate = new List<Hl7.Fhir.Model.Conformance.ConformanceRestSecurityCertificateComponent>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "certificate") )
result.Certificate.Add(ConformanceParser.ParseConformanceRestSecurityCertificateComponent(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/// <summary>
/// Parse Group
/// </summary>
public static Hl7.Fhir.Model.Group ParseGroup(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.Group existingInstance = null)
{
Hl7.Fhir.Model.Group result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.Group();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (atName == "language")
{
result.LanguageElement = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (atName == "text")
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (atName == "contained")
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element identifier
else if (atName == "identifier")
{
result.Identifier = IdentifierParser.ParseIdentifier(reader, errors);
}
// Parse element type
else if (atName == "type")
{
result.TypeElement = CodeParser.ParseCode <Hl7.Fhir.Model.Group.GroupType>(reader, errors);
}
// Parse element actual
else if (atName == "actual")
{
result.ActualElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
}
// Parse element code
else if (atName == "code")
{
result.Code = CodeableConceptParser.ParseCodeableConcept(reader, errors);
}
// Parse element name
else if (atName == "name")
{
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element quantity
else if (atName == "quantity")
{
result.QuantityElement = IntegerParser.ParseInteger(reader, errors);
}
// Parse element characteristic
else if (atName == "characteristic")
{
result.Characteristic = new List <Hl7.Fhir.Model.Group.GroupCharacteristicComponent>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "characteristic"))
{
result.Characteristic.Add(GroupParser.ParseGroupCharacteristicComponent(reader, errors));
}
reader.LeaveArray();
}
// Parse element member
else if (atName == "member")
{
result.Member = new List <Hl7.Fhir.Model.ResourceReference>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "member"))
{
result.Member.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
}
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
/// <summary>
/// Parse RelatedPerson
/// </summary>
public static Hl7.Fhir.Model.RelatedPerson ParseRelatedPerson(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.RelatedPerson existingInstance = null )
{
Hl7.Fhir.Model.RelatedPerson result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.RelatedPerson();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if( atName == "extension" )
{
result.Extension = new List<Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "extension") )
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
reader.LeaveArray();
}
// Parse element language
else if( atName == "language" )
result.LanguageElement = CodeParser.ParseCode(reader, errors);
// Parse element text
else if( atName == "text" )
result.Text = NarrativeParser.ParseNarrative(reader, errors);
// Parse element contained
else if( atName == "contained" )
{
result.Contained = new List<Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "contained") )
result.Contained.Add(ParserUtils.ParseContainedResource(reader,errors));
reader.LeaveArray();
}
// Parse element _id
else if( atName == "_id" )
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
// Parse element identifier
else if( atName == "identifier" )
{
result.Identifier = new List<Hl7.Fhir.Model.Identifier>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "identifier") )
result.Identifier.Add(IdentifierParser.ParseIdentifier(reader, errors));
reader.LeaveArray();
}
// Parse element patient
else if( atName == "patient" )
result.Patient = ResourceReferenceParser.ParseResourceReference(reader, errors);
// Parse element relationship
else if( atName == "relationship" )
result.Relationship = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element name
else if( atName == "name" )
result.Name = HumanNameParser.ParseHumanName(reader, errors);
// Parse element telecom
else if( atName == "telecom" )
{
result.Telecom = new List<Hl7.Fhir.Model.Contact>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "telecom") )
result.Telecom.Add(ContactParser.ParseContact(reader, errors));
reader.LeaveArray();
}
// Parse element gender
else if( atName == "gender" )
result.Gender = CodeableConceptParser.ParseCodeableConcept(reader, errors);
// Parse element address
else if( atName == "address" )
result.Address = AddressParser.ParseAddress(reader, errors);
// Parse element photo
else if( atName == "photo" )
{
result.Photo = new List<Hl7.Fhir.Model.Attachment>();
reader.EnterArray();
while( ParserUtils.IsAtArrayElement(reader, "photo") )
result.Photo.Add(AttachmentParser.ParseAttachment(reader, errors));
reader.LeaveArray();
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return result;
}
/* Function: ParseCommandLine
*
* Parses the command line and applies the relevant settings in in <NaturalDocs.Engine's> modules. If there were
* errors they will be placed on errorList and it will return <ParseCommandLineResult.Error>.
*
* Supported:
*
* - -i, --input, --source
* - -o, --output
* - -p, --project, --project-config --project-configuration
* - -w, --data, --working-data
* - -xi, --exclude-input, --exclude-source
* - -xip, --exclude-input-pattern, --exclude-source-pattern
* - -img, --images
* - -t, --tab, --tab-width, --tab-length
* - -do, --documented-only
* - -nag, --no-auto-group
* - -s, --style
* - -r, --rebuild
* - -ro, --rebuild-output
* - -q, --quiet
* - -v, --version
* - -vs, --versions, --all-versions
* - --benchmark
* - --worker-threads, --threads
* - --pause-before-exit, --pause
* - --pause-on-error
* - --dont-shrink-files
* - -h, --help
* - -?
*
* No Longer Supported:
*
* - -cs, --char-set, --charset, --character-set, --characterset
* - -ho, --headers-only, --headersonly
* - -ag, --auto-group, --autogroup
*/
private static ParseCommandLineResult ParseCommandLine(string[] commandLineSegments, out ProjectConfig commandLineConfig, ErrorList errorList)
{
int originalErrorCount = errorList.Count;
ParseCommandLineResult result = ParseCommandLineResult.Run;
Engine.CommandLine commandLine = new CommandLine(commandLineSegments);
commandLine.AddAliases("--input", "-i", "--source");
commandLine.AddAliases("--output", "-o");
commandLine.AddAliases("--project", "-p", "--project-config", "--projectconfig", "--project-configuration", "--projectconfiguration");
commandLine.AddAliases("--working-data", "-w", "--data", "--workingdata");
commandLine.AddAliases("--exclude-input", "-xi", "--excludeinput", "--exclude-source", "--excludesource");
commandLine.AddAliases("--exclude-input-pattern", "-xip", "--excludeinputpattern", "--exclude-source-pattern", "--excludesourcepattern");
commandLine.AddAliases("--images", "-img");
commandLine.AddAliases("--tab-width", "-t", "--tab", "--tabwidth", "--tab-length", "--tablength");
commandLine.AddAliases("--documented-only", "-do", "--documentedonly");
commandLine.AddAliases("--no-auto-group", "-nag", "--noautogroup");
commandLine.AddAliases("--style", "-s");
commandLine.AddAliases("--rebuild", "-r");
commandLine.AddAliases("--rebuild-output", "-ro", "--rebuildoutput");
commandLine.AddAliases("--quiet", "-q");
commandLine.AddAliases("--version", "-v");
commandLine.AddAliases("--all-versions", "-vs", "--versions", "--allversions");
commandLine.AddAliases("--pause-before-exit", "--pausebeforexit", "--pause");
commandLine.AddAliases("--pause-on-error", "--pauseonerror");
commandLine.AddAliases("--dont-shrink-files", "--dontshrinkfiles", "--dont-shrink-output", "--dontshrinkoutput", "--dont-shrink", "--dontshrink");
commandLine.AddAliases("--worker-threads", "--threads");
// no aliases for --benchmark
commandLine.AddAliases("--help", "-h", "-?");
// No longer supported
commandLine.AddAliases("--charset", "-cs", "--char-set", "--character-set", "--characterset");
commandLine.AddAliases("--headers-only", "-ho", "--headersonly");
commandLine.AddAliases("--auto-group", "-ag", "--autogroup");
commandLineConfig = new ProjectConfig(Source.CommandLine);
string parameter, parameterAsEntered;
bool isFirst = true;
while (commandLine.IsInBounds)
{
// If the first segment isn't a parameter, assume it's the project folder specified without -p.
if (isFirst && !commandLine.IsOnParameter)
{
parameter = "--project";
parameterAsEntered = parameter;
}
else
{
if (!commandLine.GetParameter(out parameter, out parameterAsEntered))
{
string bareWord;
commandLine.GetBareWord(out bareWord);
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.UnrecognizedParameter(param)", bareWord)
);
commandLine.SkipToNextParameter();
}
}
isFirst = false;
// Input folders
if (parameter == "--input")
{
Path folder;
if (!commandLine.GetPathValue(out folder))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
if (folder.IsRelative)
{
folder = System.Environment.CurrentDirectory + "/" + folder;
}
var target = new Engine.Config.Targets.SourceFolder(Source.CommandLine, Engine.Files.InputType.Source);
target.Folder = folder;
target.FolderPropertyLocation = Source.CommandLine;
commandLineConfig.InputTargets.Add(target);
}
}
// Output folders
else if (parameter == "--output")
{
string format;
Path folder;
if (!commandLine.GetBareWordAndPathValue(out format, out folder))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFormatAndFolder(param)", parameter)
);
commandLine.SkipToNextParameter();
}
else
{
if (folder.IsRelative)
{
folder = System.Environment.CurrentDirectory + "/" + folder;
}
format = format.ToLower();
if (format == "html" || format == "framedhtml")
{
var target = new Engine.Config.Targets.HTMLOutputFolder(Source.CommandLine);
target.Folder = folder;
target.FolderPropertyLocation = Source.CommandLine;
commandLineConfig.OutputTargets.Add(target);
}
else
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.UnrecognizedOutputFormat(format)", format)
);
commandLine.SkipToNextParameter();
}
}
}
// Project configuration folder
else if (parameter == "--project")
{
Path folder;
if (!commandLine.GetPathValue(out folder))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
if (folder.IsRelative)
{
folder = System.Environment.CurrentDirectory + "/" + folder;
}
// Accept the parameter being set to Project.txt instead of the folder.
if (folder.NameWithoutPath.ToLower() == "project.txt")
{
folder = folder.ParentFolder;
}
if (commandLineConfig.ProjectConfigFolderPropertyLocation.IsDefined)
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.OnlyOneProjectConfigFolder")
);
}
else
{
commandLineConfig.ProjectConfigFolder = folder;
commandLineConfig.ProjectConfigFolderPropertyLocation = Source.CommandLine;
}
}
}
// Working data folder
else if (parameter == "--working-data")
{
Path folder;
if (!commandLine.GetPathValue(out folder))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
if (folder.IsRelative)
{
folder = System.Environment.CurrentDirectory + "/" + folder;
}
if (commandLineConfig.WorkingDataFolderPropertyLocation.IsDefined)
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.OnlyOneWorkingDataFolder")
);
}
else
{
commandLineConfig.WorkingDataFolder = folder;
commandLineConfig.WorkingDataFolderPropertyLocation = Source.CommandLine;
}
}
}
// Ignored input folders
else if (parameter == "--exclude-input")
{
Path folder;
if (!commandLine.GetPathValue(out folder))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
if (folder.IsRelative)
{
folder = System.Environment.CurrentDirectory + "/" + folder;
}
var target = new Engine.Config.Targets.IgnoredSourceFolder(Source.CommandLine);
target.Folder = folder;
target.FolderPropertyLocation = Source.CommandLine;
commandLineConfig.FilterTargets.Add(target);
}
}
// Ignored input folder patterns
else if (parameter == "--exclude-input-pattern")
{
string pattern;
if (!commandLine.GetBareOrQuotedWordsValue(out pattern))
{
errorList.Add(
Engine.Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedPattern(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
var target = new Engine.Config.Targets.IgnoredSourceFolderPattern(Source.CommandLine);
target.Pattern = pattern;
target.PatternPropertyLocation = Source.CommandLine;
commandLineConfig.FilterTargets.Add(target);
}
}
// Image folders
else if (parameter == "--images")
{
Path folder;
if (!commandLine.GetPathValue(out folder))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
if (folder.IsRelative)
{
folder = System.Environment.CurrentDirectory + "/" + folder;
}
var target = new Engine.Config.Targets.SourceFolder(Source.CommandLine, Engine.Files.InputType.Image);
target.Folder = folder;
target.FolderPropertyLocation = Source.CommandLine;
commandLineConfig.InputTargets.Add(target);
}
}
// Tab Width
else if (parameter == "--tab-width")
{
int tabWidth;
if (!commandLine.GetIntegerValue(out tabWidth))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNumber(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else if (tabWidth < 1)
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.InvalidTabWidth")
);
commandLine.SkipToNextParameter();
}
else
{
commandLineConfig.TabWidth = tabWidth;
commandLineConfig.TabWidthPropertyLocation = Source.CommandLine;
}
}
// Support the -t4 form ini addition to -t 4. Doesn't support --tablength4.
else if (parameter.StartsWith("-t") && parameter.Length > 2 && parameter[2] >= '0' && parameter[2] <= '9')
{
string tabWidthString = parameter.Substring(2);
int tabWidth;
if (!Int32.TryParse(tabWidthString, out tabWidth))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNumber(param)", "-t")
);
commandLine.SkipToNextParameter();
}
else if (tabWidth < 1)
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.InvalidTabWidth")
);
commandLine.SkipToNextParameter();
}
else if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
commandLineConfig.TabWidth = tabWidth;
commandLineConfig.TabWidthPropertyLocation = Source.CommandLine;
}
}
// Documented Only
else if (parameter == "--documented-only")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
commandLineConfig.DocumentedOnly = true;
commandLineConfig.DocumentedOnlyPropertyLocation = Source.CommandLine;
}
}
// No Auto-Group
else if (parameter == "--no-auto-group")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
commandLineConfig.AutoGroup = false;
commandLineConfig.AutoGroupPropertyLocation = Source.CommandLine;
}
}
// Don't Shrink Files
else if (parameter == "--dont-shrink-files")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
commandLineConfig.ShrinkFiles = false;
commandLineConfig.ShrinkFilesPropertyLocation = Source.CommandLine;
}
}
// Style
else if (parameter == "--style")
{
string styleName;
if (!commandLine.GetBareOrQuotedWordsValue(out styleName))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedStyleName(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
commandLineConfig.ProjectInfo.StyleName = styleName;
commandLineConfig.ProjectInfo.StyleNamePropertyLocation = Source.CommandLine;
}
}
// Rebuild
else if (parameter == "--rebuild")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
EngineInstance.Config.ReparseEverything = true;
EngineInstance.Config.RebuildAllOutput = true;
}
}
else if (parameter == "--rebuild-output")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
EngineInstance.Config.RebuildAllOutput = true;
}
}
// Quiet
else if (parameter == "--quiet")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
quiet = true;
}
}
// Worker Threads
else if (parameter == "--worker-threads")
{
int value;
if (!commandLine.GetIntegerValue(out value))
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNumber(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else if (value < 1)
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.InvalidWorkerThreadCount")
);
commandLine.SkipToNextParameter();
}
else
{
workerThreadCount = value;
}
}
// Benchmark
else if (parameter == "--benchmark")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
benchmark = true;
}
}
// Pause Before Exit
else if (parameter == "--pause-before-exit")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
pauseBeforeExit = true;
}
}
// Pause on Error
else if (parameter == "--pause-on-error")
{
if (!commandLine.NoValue())
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
else
{
pauseOnError = true;
}
}
// Help
else if (parameter == "--help")
{
result = ParseCommandLineResult.ShowCommandLineReference;
}
// Version
else if (parameter == "--version")
{
result = ParseCommandLineResult.ShowVersion;
}
// All Versions
else if (parameter == "--all-versions")
{
result = ParseCommandLineResult.ShowAllVersions;
}
// No longer supported parameters
else if (parameter == "--charset" ||
parameter == "--headers-only" ||
parameter == "--auto-group")
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.NoLongerSupported(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
// Everything else
else
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.UnrecognizedParameter(param)", parameterAsEntered)
);
commandLine.SkipToNextParameter();
}
}
// Validation
if (!commandLineConfig.ProjectConfigFolderPropertyLocation.IsDefined)
{
errorList.Add(
Locale.Get("NaturalDocs.CLI", "CommandLine.NoProjectConfigFolder")
);
}
// Done.
if (result == ParseCommandLineResult.Run && errorList.Count != originalErrorCount)
{
result = ParseCommandLineResult.Error;
}
return(result);
}
public void ShouldBeAbleToAddErrorInfo()
{
ErrorList errors = new ErrorList();
errors.Add(new ErrorInfo("Name"));
Assert.AreEqual(1, errors.Count);
}
public override void RuntimeError(TemplateMessage msg)
{
ErrorList.Add(msg);
}
public void ShouldReturnNullIfFieldNameDoesntExists()
{
ErrorList errors = new ErrorList();
errors.Add(new ErrorInfo("Name", "Can't be blank"));
Assert.IsNull(errors["Age"]);
}
protected void BulkRegeneratePreviewsButton_Click(object sender, EventArgs e)
{
List <int> selectedIdList = GetSelectedAssetIdList();
if (selectedIdList.Count == 0)
{
MessageLabel1.SetErrorMessage("No assets selected");
return;
}
// Get the assets that we need to reprocess
AssetFinder finder = new AssetFinder();
finder.AssetIdList.Add(0);
finder.AssetIdList.AddRange(selectedIdList);
List <Asset> selectedAssets = Asset.FindMany(finder);
if (selectedAssets.Count == 0)
{
MessageLabel1.SetErrorMessage("Selected assets no longer exist");
return;
}
// Initialise error list for problems that might occur as assets are processed
ErrorList errors = new ErrorList();
// Counters
int successCount = 0;
int failCount = 0;
foreach (Asset asset in selectedAssets)
{
m_Logger.DebugFormat("Re-processing asset ID = {0}", asset.AssetId);
AssetFileInfo afi = new AssetFileInfo(asset);
if (!afi.FileExists)
{
errors.Add(string.Format("Asset file for asset with ID {0} is missing or unavailable", asset.AssetId));
m_Logger.Warn("Asset file does not exist. Cannot reprocess");
continue;
}
try
{
if (APSGateway.Instance.ProcessFile(asset, false, FileOutputs.All))
{
asset.IsProcessed = false;
Asset.Update(asset);
successCount++;
m_Logger.DebugFormat("Asset {0} resubmitted for processing successfully", asset.AssetId);
}
else
{
failCount++;
errors.Add(string.Format("#{0} : An error occured when submitting the asset to the processing service", asset.AssetId));
m_Logger.DebugFormat("Asset {0} not submitted to the processing service. An error occurred.", asset.AssetId);
}
}
catch (InvalidAssetException iaex)
{
failCount++;
m_Logger.Warn(string.Format("An error occured when processing the asset: {0}", asset.AssetId), iaex);
errors.Add(string.Format("#{0}: Error submitting asset for processing: {1}", asset.AssetId, iaex.Message));
}
catch (Exception ex)
{
failCount++;
m_Logger.Warn(string.Format("An unknown error occured when processing the asset: {0}", asset.AssetId), ex);
errors.Add(string.Format("#{0}: Error submitting asset for processing", asset.AssetId));
ExceptionHandler.HandleException(ex, "Error bulk regenerating previews");
}
}
m_Logger.DebugFormat("Asset processing result: {0} success, {1} failures, Errors: {2}", successCount, failCount, errors);
if (successCount == 0)
{
MessageLabel1.SetErrorMessage("The selected assets could not be submitted for processing", errors);
return;
}
if (failCount == 0)
{
MessageLabel1.SetSuccessMessage("All selected assets were resubmitted for reprocessing successfully");
return;
}
if (successCount > 0 && failCount > 0)
{
MessageLabel1.SetErrorMessage("Some of the selected assets could not be resubmitted for processing", errors);
return;
}
}
