using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml;
using System.Xml.XPath;
using System.Text; 

/// <summary>
/// Summary description for Class1
/// </summary>
public class HelperMethods
{
    public HelperMethods()
	{
		//
		// TODO: Add constructor logic here
		//
	}

    public static String getCourtOrderDesignatedLocation(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNode addressNode = parentNode.SelectSingleNode("./j:CourtOrderDesignatedLocation/j:LocationAddress", nsmgr);

        return HelperMethods.getLocationAddress(addressNode, nsmgr); 

    }

    public static String getCourtOrderIssuingJudicialOfficial(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNode personNameNode = parentNode.SelectSingleNode("./j:CourtOrderIssuingJudicialOfficial/j:PersonName", nsmgr);

        String personName = HelperMethods.getPersonName(personNameNode, nsmgr); 

        return personName;
    }

    public static String getCourtOrderRestrictedPerson(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNodeList restrictedPersonNodes = parentNode.SelectNodes("./j:ProtectionOrderRestrictedPerson", nsmgr);
        StringBuilder stringToReturn = new StringBuilder();

        foreach (XmlNode restrictedPersonNode in restrictedPersonNodes)
        {
            stringToReturn.AppendLine("Court Order Restricted Person: ");

            string id = restrictedPersonNode.SelectSingleNode("./@j:id", nsmgr).InnerText;
            stringToReturn.AppendLine("\tRestricted Person id: " + id);

            XmlNode personNameNode = restrictedPersonNode.SelectSingleNode("./j:PersonName", nsmgr);
            String personName = HelperMethods.getPersonName(personNameNode, nsmgr);
            stringToReturn.AppendLine(personName);

            XmlNode residenceNode = restrictedPersonNode.SelectSingleNode("./j:Residence", nsmgr);
            if (residenceNode != null)
            {
                XmlNode locationAddress = residenceNode.SelectSingleNode("./j:LocationAddress", nsmgr);
                string locationAddressStr = HelperMethods.getLocationAddress(locationAddress, nsmgr);

                stringToReturn.AppendLine(locationAddressStr);
            }

            stringToReturn.AppendLine(HelperMethods.getPersonBirthdate(restrictedPersonNode, nsmgr));

            XmlNode physicalDetails = restrictedPersonNode.SelectSingleNode("./j:PersonPhysicalDetails", nsmgr);
            stringToReturn.AppendLine(HelperMethods.getPhysicalDetails(physicalDetails, nsmgr));
        }
        return stringToReturn.ToString();
    }

    public static String getProtectionOrderStatus(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNode protectionOrderStatusNode = parentNode.SelectSingleNode("./protection-order:ProtectionOrderStatus", nsmgr);

        StringBuilder stringToReturn = new StringBuilder();
        String protectionOrderAction = protectionOrderStatusNode.SelectSingleNode("./protection-order:ProtectionOrderAction", nsmgr).InnerText;
        stringToReturn.AppendLine("\tProtection Order Action: " + protectionOrderAction);

        XmlNode protectionOrderActionDescNode = protectionOrderStatusNode.SelectSingleNode("./protection-order:ProtectionOrderActionDescription", nsmgr);
        if (protectionOrderActionDescNode != null)
        {
            stringToReturn.AppendLine("\tProtection Order Action Description: " + protectionOrderActionDescNode.InnerText.Trim());
        }

        return stringToReturn.ToString();
    }

    public static String getProtectionOrderSubject(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNodeList protectionOrderSubjectNodes = parentNode.SelectNodes("./protection-order:ProtectionOrderSubject", nsmgr);

        StringBuilder stringToReturn = new StringBuilder();

        foreach (XmlNode protectionOrderSubjectNode in protectionOrderSubjectNodes)
        {

            stringToReturn.AppendLine("Protection Order Subject: ");

            string id = protectionOrderSubjectNode.SelectSingleNode("./@j:id", nsmgr).InnerText;
            stringToReturn.AppendLine("\tSubject id: " + id);

            XmlNode personNameNode = protectionOrderSubjectNode.SelectSingleNode("./j:PersonName", nsmgr);
            String personName = HelperMethods.getPersonName(personNameNode, nsmgr);
            stringToReturn.AppendLine(personName);

            XmlNode residenceNode = protectionOrderSubjectNode.SelectSingleNode("./j:Residence", nsmgr);
            if (residenceNode != null)
            {
                XmlNode locationAddress = residenceNode.SelectSingleNode("./j:LocationAddress", nsmgr);
                string locationAddressStr = HelperMethods.getLocationAddress(locationAddress, nsmgr);

                stringToReturn.AppendLine(locationAddressStr);
            }

            XmlNode primaryContactInfo = protectionOrderSubjectNode.SelectSingleNode("./j:PrimaryContactInformation", nsmgr);

            stringToReturn.AppendLine(HelperMethods.getContactInfo(primaryContactInfo, nsmgr));

            stringToReturn.AppendLine(HelperMethods.getPersonBirthdate(protectionOrderSubjectNode, nsmgr));

            XmlNode physicalDetails = protectionOrderSubjectNode.SelectSingleNode("./j:PersonPhysicalDetails", nsmgr);
            stringToReturn.AppendLine(HelperMethods.getPhysicalDetails(physicalDetails, nsmgr));
            stringToReturn.AppendLine(HelperMethods.getPersonRelationship(protectionOrderSubjectNode, nsmgr)); 
            stringToReturn.AppendLine(HelperMethods.getVehicle(protectionOrderSubjectNode, nsmgr));
            stringToReturn.AppendLine(HelperMethods.getPersonAlias(protectionOrderSubjectNode, nsmgr));
            stringToReturn.AppendLine(HelperMethods.getProtectionOrderRestrictions(protectionOrderSubjectNode, nsmgr));
        }

        return stringToReturn.ToString();
    }

    public static string getProtectionOrderRestrictions(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {

        string stringToReturn = String.Empty; 

        XmlNode restrictionsNode = parentNode.SelectSingleNode("./protection-order:ProtectionOrderRestrictions", nsmgr);
        if (restrictionsNode != null)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("\tProtectionOrderRestrictions:");
            XmlNode firearmProhibitedCodeNode = restrictionsNode.SelectSingleNode("./protection-order:PersonFirearmProhibitedCode", nsmgr);
            if (firearmProhibitedCodeNode != null)
            {
                sb.AppendLine("\t\tFire Arm Prohibited Code: " + firearmProhibitedCodeNode.InnerText); 
            }
            XmlNode miscellaneousTextNode = restrictionsNode.SelectSingleNode("./protection-order:MiscellaneousText", nsmgr);
            if (miscellaneousTextNode != null)
            {
                sb.AppendLine("\t\tMiscellaneous Text: " + miscellaneousTextNode.InnerText.Trim()); 
            }
            stringToReturn = sb.ToString(); 
        }

        return stringToReturn; 
    }

    public static String getPersonAlias(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNodeList personAliasNodes = parentNode.SelectNodes("./protection-order:PersonAlias", nsmgr);
        StringBuilder stringToReturn = new StringBuilder();

        foreach (XmlNode personAliasNode in personAliasNodes)
        {
            stringToReturn.AppendLine("\tPerson Alias:");
            
            XmlNode aliasCodeNode = personAliasNode.SelectSingleNode("./protection-order:AliasCode", nsmgr);
            stringToReturn.AppendLine("\t\tAlias Code: " + aliasCodeNode.InnerText); 

            XmlNode aliasCodeDescNode = personAliasNode.SelectSingleNode("./protection-order:AliasCodeDescription", nsmgr);
            if (aliasCodeDescNode != null)
            {
                stringToReturn.AppendLine("\t\tAlias Code Description: " + aliasCodeDescNode.InnerText); 
            }
            stringToReturn.AppendLine(HelperMethods.getPersonBirthdate(personAliasNode, nsmgr)); 
        }

        return stringToReturn.ToString();
    }

    public static string getPersonBirthdate(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNode birthDate = parentNode.SelectSingleNode("./j:PersonBirthDate", nsmgr);
        if (birthDate != null)
        {
            return ("\tBirthdate: " + birthDate.InnerText);
        }
        else
            return ""; 
    }

    public static string getProtectionOrderDocuments(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        StringBuilder stringToReturn = new StringBuilder();
        XmlNodeList protectionOrderDocumentNodes =
            parentNode.SelectNodes("./protection-order:ProtectionOrderDocument", nsmgr);

        foreach (XmlNode protectionOrderDocumentNode in protectionOrderDocumentNodes)
        {
            stringToReturn.AppendLine("Protection Order Document: ");
            stringToReturn.AppendLine("\tDocumentBinary: ");

            XmlNode binaryIDNode = protectionOrderDocumentNode.SelectSingleNode(".//j:BinaryID/j:ID", nsmgr);
            if (binaryIDNode != null)
            {
                stringToReturn.AppendLine("\t\tBinary ID: " +
                    binaryIDNode.InnerText);
            }

            XmlNode binaryObjectBase64Node = protectionOrderDocumentNode.SelectSingleNode(".//j:BinaryObject.Base64", nsmgr);
            if (binaryObjectBase64Node != null)
            {
                stringToReturn.AppendLine("\t\tBinaryObject.Base64: " + binaryObjectBase64Node.InnerText);
            }

            XmlNode binaryDescriptionTextNode = protectionOrderDocumentNode.SelectSingleNode(".//j:BinaryDescriptionText", nsmgr);
            if (binaryDescriptionTextNode != null)
            {
                stringToReturn.AppendLine("\t\tBinaryDescriptionText: " + binaryDescriptionTextNode.InnerText);
            }

            XmlNode binaryReferrenceIDNode = protectionOrderDocumentNode.SelectSingleNode(".//j:BinaryReferenceID", nsmgr);
            if (binaryReferrenceIDNode != null)
            {
                stringToReturn.AppendLine("\t\tBinaryReferenceID: " + binaryReferrenceIDNode.InnerText.Trim());
            }
        }

        return stringToReturn.ToString(); 
    }
    public static String getVehicle(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        XmlNodeList vehicleNodes = parentNode.SelectNodes("./j:Vehicle", nsmgr);
        StringBuilder stringToReturn = new StringBuilder();

        foreach (XmlNode vehicleNode in vehicleNodes)
        {
            stringToReturn.AppendLine("\tVehicle:");
            stringToReturn.AppendLine("\t\tRegistration:");

            XmlNode jurisdictionNameNode = vehicleNode.SelectSingleNode(".//j:RegistrationJurisdictionName", nsmgr);
            if (jurisdictionNameNode != null)
            {
                stringToReturn.AppendLine("\t\t\tJurisdiction Name: " +
                    jurisdictionNameNode.InnerText);
            }

            stringToReturn.AppendLine("\t\t\tRegistrationJurisdictionCode.ncicLIS: " +
                vehicleNode.SelectSingleNode(".//j:RegistrationJurisdictionCode.ncicLIS", nsmgr).InnerText);
            stringToReturn.AppendLine("\t\t\tVehicleRegistrationPlateID: " +
                vehicleNode.SelectSingleNode(".//j:VehicleRegistrationPlateID/j:ID", nsmgr).InnerText); 
            stringToReturn.AppendLine("\t\t\tVehicleRegistrationPlateTypeText: " + 
                vehicleNode.SelectSingleNode(".//j:VehicleRegistrationPlateTypeText", nsmgr).InnerText); 
            stringToReturn.AppendLine("\t\t\tVehicleRegistrationPlateTypeCode: " + 
                vehicleNode.SelectSingleNode(".//j:VehicleRegistrationPlateTypeCode", nsmgr).InnerText); 
            stringToReturn.AppendLine("\t\t\tVehicleRegistrationDecal: " + 
                vehicleNode.SelectSingleNode(".//j:DecalYearDate", nsmgr)==null?"":vehicleNode.SelectSingleNode(".//j:DecalYearDate", nsmgr).InnerText);
            stringToReturn.AppendLine("\t\tVehicle ID: " + 
                vehicleNode.SelectSingleNode("./j:VehicleID/j:ID", nsmgr).InnerText.Trim()); 
        }

        return stringToReturn.ToString(); 
    }


    public static String getPersonName(XmlNode personNameNode, XmlNamespaceManager nsmgr)
    {
        String personGivenName = personNameNode.SelectSingleNode("./j:PersonGivenName", nsmgr).InnerText;
        StringBuilder stringToReturn = new StringBuilder();
        stringToReturn.AppendLine("\tPersonName:"); 
        stringToReturn.AppendLine("\tGiven Name: " + personGivenName);

        XmlNodeList middleNameNodes = personNameNode.SelectNodes("./j:PersonMiddleName", nsmgr);
        foreach (XmlNode middleNameNode in middleNameNodes)
        {
            stringToReturn.AppendLine("\tMiddle Name: " + middleNameNode.InnerText);
        }

        String personSurName = personNameNode.SelectSingleNode("./j:PersonSurName", nsmgr).InnerText;
        stringToReturn.AppendLine("\tSur Name: " + personSurName);

        XmlNode personSuffixName = personNameNode.SelectSingleNode("./j:PersonSuffixName", nsmgr);
        if (personSuffixName != null)
        {
            stringToReturn.AppendLine("\tSuffix Name: " + personSuffixName.InnerText);
        }

        return stringToReturn.ToString();
    }

    public static String getContactInfo(XmlNode contactInfoNode, XmlNamespaceManager nsmgr)
    {
        if (contactInfoNode == null)
            return ""; 

        XmlNode teleponeNumber = contactInfoNode.SelectSingleNode("./j:ContactTelephoneNumber", nsmgr);
        
        StringBuilder stringToReturn = new StringBuilder();
        stringToReturn.AppendLine("\tContact Info:");

        if (teleponeNumber != null)
        {
            XmlNodeList fullIdNodes = teleponeNumber.SelectNodes("./j:TelephoneNumberFullID", nsmgr); 
            foreach (XmlNode fullIdNode in fullIdNodes) 
            {
                stringToReturn.AppendLine("\tTelephone Number:" + fullIdNode.InnerText.Trim()); 
            }
        }
        return stringToReturn.ToString();
    }

    public static String getPersonRelationship(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        StringBuilder stringToReturn = new StringBuilder();
        XmlNodeList relationshipNodes = parentNode.SelectNodes("./protection-order:PersonRelationship", nsmgr);

        foreach (XmlNode relationshipNode in relationshipNodes)
        {
            stringToReturn.AppendLine("\tPerson Relationship: ");
            XmlNode relationshipCodeNode = relationshipNode.SelectSingleNode("./protection-order:RelationshipCode", nsmgr); 
            if (relationshipCodeNode != null) 
            {
                stringToReturn.AppendLine("\t\tRelationship Code: " + relationshipCodeNode.InnerText); 
            }
            XmlNode relationshipCodeDescNode = relationshipNode.SelectSingleNode("./protection-order:RelationshipCodeDescription", nsmgr); 
            if (relationshipCodeDescNode != null) 
            {
                stringToReturn.AppendLine("\t\tRelationship Code Description: " + relationshipCodeDescNode.InnerText); 
            }
        }

        return stringToReturn.ToString(); 
    }

    public static String getCharges(XmlNode parentNode, XmlNamespaceManager nsmgr)
    {
        StringBuilder stringToReturn = new StringBuilder();

        XmlNodeList chargeNodes = parentNode.SelectNodes("./j:Charge", nsmgr); 
        
        foreach (XmlNode chargeNode in chargeNodes) 
        {
            stringToReturn.AppendLine("Charge:");
            stringToReturn.AppendLine("\tCharge ID: " +
                chargeNode.SelectSingleNode("./j:ChargeID/j:ID", nsmgr).InnerText);
            stringToReturn.AppendLine("\tChargeOriginator.Organization: " +
                chargeNode.SelectSingleNode(".//j:OrganizationName", nsmgr).InnerText);
            stringToReturn.AppendLine("\tChargeStatute:");
            stringToReturn.AppendLine("\t\tStatute Code ID: " +
                chargeNode.SelectSingleNode(".//j:StatuteCodeID/j:ID", nsmgr).InnerText);
            stringToReturn.AppendLine("\t\tStatute Description Text: " +
                chargeNode.SelectSingleNode(".//j:StatuteDescriptionText", nsmgr).InnerText); 
        }

        return stringToReturn.ToString(); 
    }
    public static String getPhysicalDetails(XmlNode physicalDetailsNode, XmlNamespaceManager nsmgr)
    {
        StringBuilder stringToReturn = new StringBuilder();
        if (physicalDetailsNode != null)
        {
            stringToReturn.AppendLine("\tPhysicalDetails:");

            XmlNode heightMeasure = physicalDetailsNode.SelectSingleNode("./j:PersonHeightMeasure", nsmgr);
            if (heightMeasure != null)
            {
                stringToReturn.AppendLine("\t\tHeight Measure: " + heightMeasure.InnerText + "\tUnit Code: " + heightMeasure.SelectSingleNode("./@j:personHeightUnitCode",nsmgr).InnerText);
            }

            XmlNode weightMeasure = physicalDetailsNode.SelectSingleNode("./j:PersonWeightMeasure", nsmgr);
            if (weightMeasure != null)
            {
                stringToReturn.AppendLine("\t\tWeight Measure: " + weightMeasure.InnerText + "\tUnit Code: " + weightMeasure.SelectSingleNode("./@j:personWeightUnitCode", nsmgr).InnerText);
            }

            XmlNode eyeColorText = physicalDetailsNode.SelectSingleNode("./j:PersonEyeColorText", nsmgr);
            if (eyeColorText != null)
            {
                stringToReturn.AppendLine("\t\tEye Color Text: " + eyeColorText.InnerText);
            }

            XmlNode eyeColorCode = physicalDetailsNode.SelectSingleNode("./j:PersonEyeColorCode", nsmgr);
            if (eyeColorCode != null)
            {
                stringToReturn.AppendLine("\t\tEye Color Code: " + eyeColorCode.InnerText);
            }

            XmlNode hairColorText = physicalDetailsNode.SelectSingleNode("./j:PersonHairColorText", nsmgr);
            if (hairColorText != null)
            {
                stringToReturn.AppendLine("\t\tHair Color Text: " + hairColorText.InnerText);
            }

            XmlNode hairColorCode = physicalDetailsNode.SelectSingleNode("./j:PersonHairColorCode", nsmgr);
            if (hairColorCode != null)
            {
                stringToReturn.AppendLine("\t\tHair Color Code: " + hairColorCode.InnerText);
            }
            
            XmlNode sexText = physicalDetailsNode.SelectSingleNode("./j:PersonSexText", nsmgr);
            if (sexText != null)
            {
                stringToReturn.AppendLine("\t\tSex Text: " + sexText.InnerText);
            }

            XmlNode sexCode = physicalDetailsNode.SelectSingleNode("./j:PersonSexCode", nsmgr);
            if (sexCode != null)
            {
                stringToReturn.AppendLine("\t\tSex Code: " + sexCode.InnerText);
            }
            
            XmlNode raceText = physicalDetailsNode.SelectSingleNode("./j:PersonRaceText", nsmgr);
            if (raceText != null)
            {
                stringToReturn.AppendLine("\t\tRace Text: " + raceText.InnerText);
            }

            XmlNode raceCode = physicalDetailsNode.SelectSingleNode("./j:PersonRaceCode", nsmgr);
            if (raceCode != null)
            {
                stringToReturn.AppendLine("\t\tRace Code: " + raceCode.InnerText);
            }
            
            XmlNode skinToneText = physicalDetailsNode.SelectSingleNode("./j:PersonSkinToneText", nsmgr);
            if (skinToneText != null)
            {
                stringToReturn.AppendLine("\t\tSkin Tone Text: " + skinToneText.InnerText);
            }

            XmlNode skinToneCode = physicalDetailsNode.SelectSingleNode("./j:PersonSkinToneCode", nsmgr);
            if (skinToneCode != null)
            {
                stringToReturn.AppendLine("\t\tSkin Tone Code: " + skinToneCode.InnerText);
            }

            XmlNodeList physicalFeatureNodes = physicalDetailsNode.SelectNodes("./j:PersonPhysicalFeature", nsmgr);
            foreach (XmlNode physicalFeatureNode in physicalFeatureNodes)
            {
                stringToReturn.AppendLine("\t\tPhysical Feature: ");
                stringToReturn.AppendLine("\t\t\tFeture Type Code: " +
                    physicalFeatureNode.SelectSingleNode("./j:PhysicalFeatureTypeCode", nsmgr).InnerText);

                XmlNode physicalFeatureDescTextNode = physicalFeatureNode.SelectSingleNode("./j:PhysicalFeatureDescriptionText", nsmgr);
                if (physicalFeatureDescTextNode != null)
                {
                    stringToReturn.AppendLine("\t\t\tFeature Description Text: " +
                        physicalFeatureDescTextNode.InnerText);
                }
            }
        }
        return stringToReturn.ToString();
    }

    public static String getLocationAddress(XmlNode locationAddressNode, XmlNamespaceManager nsmgr)
    {

        StringBuilder stringToReturn = new StringBuilder();
        if (locationAddressNode != null)
        {
            stringToReturn.AppendLine("\tLocation Address: ");

            XmlNode locationStreet = locationAddressNode.SelectSingleNode("./j:LocationStreet", nsmgr);
            if (locationStreet != null)
            {
                stringToReturn.AppendLine("\tStreet: " + locationStreet.InnerText.Trim());
            }

            XmlNodeList secondaryUnitTextNodes = locationAddressNode.SelectNodes("./j:LocationSecondaryUnitText", nsmgr);
            foreach (XmlNode secondaryUnitTextNode in secondaryUnitTextNodes)
            {
                stringToReturn.AppendLine("\tSecondary Unit Text: " + secondaryUnitTextNode.InnerText);
            }

            XmlNode cityName = locationAddressNode.SelectSingleNode("./j:LocationCityName", nsmgr);
            if (cityName != null)
            {
                stringToReturn.AppendLine("\tCity Name : " + cityName.InnerText);
            }

            XmlNode stateCode = locationAddressNode.SelectSingleNode("./j:LocationStateCode.USPostalService", nsmgr);
            if (stateCode != null)
            {
                stringToReturn.AppendLine("\tState Code: " + stateCode.InnerText);
            }

            XmlNode zipCode = locationAddressNode.SelectSingleNode("./j:LocationPostalCodeID/j:ID", nsmgr);
            if (zipCode != null)
            {
                stringToReturn.AppendLine("\tZip Code: " + zipCode.InnerText); 
            }

            XmlNode countyName = locationAddressNode.SelectSingleNode("./j:LocationCountyName", nsmgr);
            if (countyName != null)
            {
                stringToReturn.AppendLine("\tCounty Name : " + countyName);
            }

            XmlNode countyCode = locationAddressNode.SelectSingleNode("./j:LocationCountyCode", nsmgr);

            if (countyCode != null)
            {
                stringToReturn.AppendLine("\tCounty Name : " + countyCode.InnerText);
            }
        }
        return stringToReturn.ToString();
    }

    public static string getElementValues(XmlNode headNode, XmlNamespaceManager nsmgr)
    {
        StringBuilder stringBuilder = new StringBuilder();

        // POIssueDocument id
        String docId = headNode.SelectSingleNode("./@j:id", nsmgr).InnerText;

        // PO Node. 
        XmlNode poNode = headNode.SelectSingleNode("./protection-order:ProtectionOrder", nsmgr);

        stringBuilder.AppendLine("Document Id :" + docId);

        String poId = poNode.SelectSingleNode("./@j:id", nsmgr).InnerText;
        stringBuilder.AppendLine("Protection Order Id :" + poId);

        // CourtOrderDesignatedLocation 
        string courtOrderDesignatedLocationStr = HelperMethods.getCourtOrderDesignatedLocation(poNode, nsmgr);
        stringBuilder.AppendLine("\nCourtOrderDesignatedLocation: \n" + courtOrderDesignatedLocationStr);

        // CourtOrderIssuingJudicialOfficial 
        string courtOrderIssuingJudicialOfficial = HelperMethods.getCourtOrderIssuingJudicialOfficial(poNode, nsmgr);
        stringBuilder.AppendLine("CourtOrderIssuingJudicialOfficial: \n" + courtOrderIssuingJudicialOfficial);

        // CourtOrderIssuingDate
        string courtOrderIssuingDate = poNode.SelectSingleNode("./j:CourtOrderIssuingDate", nsmgr).InnerText;
        stringBuilder.AppendLine("CourtOrderIssuingDate: " + courtOrderIssuingDate);

        //ProtectionOrderRestrictedPerson
        string courtOrderRestrictedPerson = HelperMethods.getCourtOrderRestrictedPerson(poNode, nsmgr);
        stringBuilder.AppendLine(courtOrderRestrictedPerson);

        // CaseDocketID
        string caseDocketID = poNode.SelectSingleNode(".//j:CaseDocketID/j:ID", nsmgr).InnerText;
        stringBuilder.AppendLine("Case:\n\tCase Docket ID: " + caseDocketID);

        // CourtOrderExpirationDate
        string courtOrderExpirationDate = poNode.SelectSingleNode("./protection-order:CourtOrderExpirationDate", nsmgr).InnerText;
        stringBuilder.AppendLine("CourtOrderExpirationDate: " + courtOrderExpirationDate);

        // ProtectionOrderStatus 
        string protectionOrderStatus = HelperMethods.getProtectionOrderStatus(poNode, nsmgr);
        stringBuilder.AppendLine("ProtectionOrderActionStatus: \n " + protectionOrderStatus);

        // ProtectionOrderClassCode
        XmlNode protectionOrderClassCodeNode = poNode.SelectSingleNode("./protection-order:ProtectionOrderClassCode", nsmgr);
        stringBuilder.AppendLine("Class Code : " + protectionOrderClassCodeNode.InnerText.Trim());

        // ProtectionOrderClassCodeDescription
        XmlNode classCodeDescNode = poNode.SelectSingleNode("./protection-order:ProtectionOrderClassCodeDescription", nsmgr);
        if (classCodeDescNode != null)
        {
            stringBuilder.AppendLine("Class Code Description:" + classCodeDescNode.InnerText); 
        }

        //ProtectionOrderCategory
        XmlNode categoryNode = poNode.SelectSingleNode("./protection-order:ProtectionOrderCategory", nsmgr);
        stringBuilder.AppendLine("Category: " + categoryNode.InnerText.Trim()); 

        XmlNode categoryDescNode = poNode.SelectSingleNode("./protection-order:ProtectionOrderCategoryDescription", nsmgr);
        if (categoryDescNode != null)
        {
            stringBuilder.AppendLine("Category Description: " + categoryDescNode.InnerText.Trim()); 
        }

        // ProtectionOrderSubject
        string protectionOrderSubject = HelperMethods.getProtectionOrderSubject(poNode, nsmgr);
        stringBuilder.AppendLine(protectionOrderSubject);

        //ProtectionOrderDocuments
        stringBuilder.AppendLine(HelperMethods.getProtectionOrderDocuments(poNode, nsmgr));

        return stringBuilder.ToString(); 

    }
}