/// <summary>
        /// Reads an XML Object From An Existing DOM
        /// </summary>
        /// <param name="rootNode">Node Containing the root Object element</param>
        internal void ReadXML(XmlNode rootNode)
        {
            foreach (XmlNode node in rootNode.ChildNodes)
            {
                if (string.IsNullOrEmpty(node.InnerText))
                {
                    continue;
                }

                switch (node.LocalName)
                {
                case "RadioType":
                    this.radioType = new EDXLSharp.ValueList();
                    this.radioType.ReadXML(node);
                    break;

                case "RadioChannel":
                    this.radioChannel = node.InnerText;
                    break;

                case "#comment":
                    break;

                default:
                    throw new ArgumentException("Unexpected node name: " + node.Name + " in RadioInformationType");
                }
            }

            this.Validate();
        }
        /// <summary>
        /// Reads an XML Object From An Existing DOM
        /// </summary>
        /// <param name="rootNode">Node Containing the root Object element</param>
        internal void ReadXML(XmlNode rootNode)
        {
            foreach (XmlNode node in rootNode.ChildNodes)
            {
                string tmpQuantityText;

                if (string.IsNullOrEmpty(node.InnerText))
                {
                    continue;
                }

                switch (node.LocalName)
                {
                case "QuantityText":
                    if (this.quantityText == null)
                    {
                        this.quantityText = new List <string>();
                    }

                    tmpQuantityText = node.InnerText;
                    this.quantityText.Add(tmpQuantityText);
                    break;

                case "MeasuredQuantity":
                    foreach (XmlNode subnode in node.ChildNodes)
                    {
                        switch (subnode.LocalName)
                        {
                        case "Amount":
                            this.amount = double.Parse(subnode.InnerText);
                            break;

                        case "UnitOfMeasure":
                            this.unitOfMeasure = new EDXLSharp.ValueList();
                            this.unitOfMeasure.ReadXML(subnode);
                            break;

                        default:
                            throw new ArgumentException("Unexpected subnode name: " + subnode.Name + " in QuantityType");
                        }
                    }

                    break;

                case "#comment":
                    break;

                default:
                    throw new ArgumentException("Unexpected node name: " + node.Name + " in QuantityType");
                }
            }

            this.Validate();
        }
        /// <summary>
        /// Reads an XML Object From An Existing DOM
        /// </summary>
        /// <param name="rootNode">Node Containing the root Object element</param>
        /// <param name="messageContent">MessageType of this RM Message</param>
        internal void ReadXML(XmlNode rootNode, MessageType?messageContent)
        {
            foreach (XmlNode node in rootNode.ChildNodes)
            {
                if (string.IsNullOrEmpty(node.InnerText))
                {
                    continue;
                }

                switch (node.LocalName)
                {
                case "InventoryRefreshDateTime":
                    this.inventoryRefreshDateTime = DateTime.Parse(node.InnerText);
                    if (this.inventoryRefreshDateTime.Kind == DateTimeKind.Unspecified)
                    {
                        this.inventoryRefreshDateTime = DateTime.MinValue;
                        throw new ArgumentException("TimeZone Information Must Be Specified");
                    }

                    this.inventoryRefreshDateTime = this.inventoryRefreshDateTime.ToUniversalTime();
                    break;

                case "DeploymentStatus":
                    this.deploymentStatus = new EDXLSharp.ValueList();
                    this.deploymentStatus.ReadXML(node);
                    break;

                case "Availability":
                    this.availability = node.InnerText;
                    break;

                case "#comment":
                    break;

                default:
                    throw new ArgumentException("Unexpected node name: " + node.Name + " in ResourceStatusType");
                }
            }

            this.Validate(messageContent);
        }
Beispiel #4
0
        /// <summary>
        /// Reads an XML Object From An Existing DOM
        /// </summary>
        /// <param name="rootNode">Node Containing the root Object element</param>
        internal void ReadXML(XmlNode rootNode)
        {
            foreach (XmlNode node in rootNode.ChildNodes)
            {
                if (string.IsNullOrEmpty(node.InnerText))
                {
                    continue;
                }

                switch (node.LocalName)
                {
                case "PrecedingResourceInfoElementID":
                    this.precedingResourceInfoElementID = node.InnerText;
                    break;

                case "ResponseType":
                    this.responseType = (ResponseTypeType)Enum.Parse(typeof(ResponseTypeType), node.InnerText);
                    break;

                case "ReasonCode":
                    this.reasonCode = new EDXLSharp.ValueList();
                    this.reasonCode.ReadXML(node);
                    break;

                case "ResponseReason":
                    this.responseReason = node.InnerText;
                    break;

                case "#comment":
                    break;

                default:
                    throw new ArgumentException("Unexpected node name: " + node.Name + " in ResponseInformationType");
                }
            }

            this.Validate();
        }
        /// <summary>
        /// Reads an XML Object From An Existing DOM
        /// </summary>
        /// <param name="rootNode">Node Containing the root Object element</param>
        /// <param name="messageContent">MessageType of this RM Message</param>
        internal void ReadXML(XmlNode rootNode, MessageType?messageContent)
        {
            if (this.keyword == null)
            {
                this.keyword = new EDXLSharp.VLList("Keyword");
            }

            this.keyword.ReadXML(rootNode);

            foreach (XmlNode node in rootNode.ChildNodes)
            {
                if (string.IsNullOrEmpty(node.InnerText))
                {
                    continue;
                }

                switch (node.LocalName)
                {
                case "ResourceID":
                    this.resourceID = node.InnerText;
                    break;

                case "Name":
                    this.name = node.InnerText;
                    break;

                case "TypeStructure":
                    this.typeStructure = new EDXLSharp.ValueList();
                    this.typeStructure.ReadXML(node);
                    break;

                case "TypeInfo":
                    this.typeInfo = XElement.Load(new XmlNodeReader(node));
                    break;

                case "Keyword":
                    break;

                case "Description":
                    this.description = node.InnerText;
                    break;

                case "Credentials":
                    this.credentials = node.InnerText;
                    break;

                case "Certifications":
                    this.certifications = node.InnerText;
                    break;

                case "SpecialRequirements":
                    this.specialRequirements = node.InnerText;
                    break;

                case "ResponsibleParty":
                    this.responsibleParty = new ContactInformationType();
                    this.responsibleParty.ReadXML(node);
                    break;

                case "OwnershipInformation":
                    this.ownershipInformation = new OwnershipInformationType();
                    this.ownershipInformation.ReadXML(node, messageContent);
                    break;

                case "ResourceStatus":
                    this.resourceStatus = new ResourceStatusType();
                    this.resourceStatus.ReadXML(node, messageContent);
                    break;

                case "#comment":
                    break;

                default:
                    throw new ArgumentException("Unexpected node name: " + node.Name + " in ResourceType");
                }
            }

            this.Validate(messageContent);
        }