Exemple #1
0
 //------------------------------------------------------------------------------------
 //------------------------------------------------------------------------------------
 private void GetSchemaElementFromSchema()
 {
     thisSchema = thisParentFragment.Schemas.GetSchemaFromTargetNamespace(this.Namespace, thisParentFragment);
     if (thisSchema == null)
     {
         if (thisParentFragment.Schemas.Count == 0)
         {
             string        MessageFormat        = AssemblyResources.GetName("NoSchemasForFragment");
             StringBuilder MessageFormatBuilder = new StringBuilder();
             MessageFormatBuilder.AppendFormat(MessageFormat);
             thisParentFragment.AddValidationError(new ItemValidationError(this, MessageFormatBuilder.ToString()));
         }
         else
         {
             string        MessageFormat        = AssemblyResources.GetName("NoSchemasForNamespace");
             StringBuilder MessageFormatBuilder = new StringBuilder();
             MessageFormatBuilder.AppendFormat(MessageFormat, this.Name, this.Namespace);
             thisParentFragment.AddValidationError(new ItemValidationError(this, MessageFormatBuilder.ToString()));
         }
     }
     this.SchemaElement = thisParentFragment.Schemas.GetElement(this.Name);
     if (this.SchemaElement == null)
     {
         string        MessageFormat        = AssemblyResources.GetName("CannotFindFactElementInSchema");
         StringBuilder MessageFormatBuilder = new StringBuilder();
         MessageFormatBuilder.AppendFormat(MessageFormat, this.Name, thisSchema.SchemaReferencePath);
         thisParentFragment.AddValidationError(new ItemValidationError(this, MessageFormatBuilder.ToString()));
     }
 }
Exemple #2
0
 private void ValidateScenarioNode(INode ScenarioNode)
 {
     if (ScenarioNode.NamespaceURI.Equals(XbrlDocument.XbrlNamespaceUri) == true)
     {
         string        MessageFormat  = AssemblyResources.GetName("ScenarioNodeUsingXBRLNamespace");
         StringBuilder MessageBuilder = new StringBuilder();
         MessageBuilder.AppendFormat(MessageFormat, this.Id, ScenarioNode.Name);
         this.Fragment.AddValidationError(new ContextValidationError(this, MessageBuilder.ToString()));
     }
     if (ScenarioNode.Prefix.Length > 0)
     {
         XbrlSchema NodeSchema = this.Fragment.GetXbrlSchemaForPrefix(ScenarioNode.Prefix);
         if (NodeSchema != null)
         {
             Element NodeElement = NodeSchema.GetElement(ScenarioNode.LocalName);
             if (NodeElement != null)
             {
                 if (NodeElement.SubstitutionGroup != Element.ElementSubstitutionGroup.Unknown)
                 {
                     string        MessageFormat  = AssemblyResources.GetName("ScenarioNodeUsingSubGroupInXBRLNamespace");
                     StringBuilder MessageBuilder = new StringBuilder();
                     MessageBuilder.AppendFormat(MessageFormat, this.Id, ScenarioNode.Name, NodeSchema.Path);
                     this.Fragment.AddValidationError(new ContextValidationError(this, MessageBuilder.ToString()));
                 }
             }
         }
     }
     foreach (INode CurrentChild in ScenarioNode.ChildNodes)
     {
         ValidateScenarioNode(CurrentChild);
     }
 }
        /// <summary>
        /// Returns the label stored in a label linkbase for a given locator.
        /// </summary>
        /// <param name="schema">
        /// The compiled schema which whose elements should be searched.
        /// </param>
        /// <param name="labelLocator">
        /// The locator of the label to be returned.
        /// </param>
        /// <param name="labelLink">
        /// The link label to be searched.
        /// </param>
        /// <returns>
        /// The label for the given locator, or an empty string if there is no
        /// label.
        /// </returns>
        private string GetLabel(XbrlSchema schema, Locator labelLocator, LabelLink labelLink)
        {
            var labelLinkbase = schema.LabelLinkbase;

            if (labelLinkbase == null)
            {
                return(string.Empty);
            }

            // Find label locator with href matching labelLocator.Href
            // Find label arc with from matching label locator.Label
            // find label with label matching label arc.To
            // grab innerText ... GET HYPE

            var labelLinkLocator = labelLink.GetLocator(labelLocator.Href);

            if (labelLinkLocator == null)
            {
                return(string.Empty);
            }
            var labelArc = labelLink.GetLabelArc(labelLinkLocator.Label);

            if (labelArc == null)
            {
                return(string.Empty);
            }
            var finalLabel = labelLink.GetLabel(labelArc.ToId);

            if (finalLabel == null)
            {
                return(string.Empty);
            }
            return(finalLabel.Text);
        }
Exemple #4
0
 //------------------------------------------------------------------------------------
 //------------------------------------------------------------------------------------
 private void GetSchemaElementFromSchema()
 {
     foreach (XbrlSchema CurrentSchema in thisParentFragment.Schemas)
     {
         if (CurrentSchema.TargetNamespace == this.Namespace)
         {
             thisSchema = CurrentSchema;
         }
     }
     if (thisSchema == null)
     {
         if (thisParentFragment.Schemas.Count == 0)
         {
             string        MessageFormat        = AssemblyResources.GetName("NoSchemasForFragment");
             StringBuilder MessageFormatBuilder = new StringBuilder();
             MessageFormatBuilder.AppendFormat(MessageFormat);
             thisParentFragment.AddValidationError(new ItemValidationError(this, MessageFormatBuilder.ToString()));
         }
         thisSchema = thisParentFragment.Schemas[0];
     }
     this.SchemaElement = thisSchema.GetElement(this.Name);
     if (this.SchemaElement == null)
     {
         string        MessageFormat        = AssemblyResources.GetName("CannotFindFactElementInSchema");
         StringBuilder MessageFormatBuilder = new StringBuilder();
         MessageFormatBuilder.AppendFormat(MessageFormat, this.Name, thisSchema.Path);
         thisParentFragment.AddValidationError(new ItemValidationError(this, MessageFormatBuilder.ToString()));
     }
 }
Exemple #5
0
        private void ProcessSchemaNamespaceAndLocation(string schemaNamespace, string schemaLocation)
        {
            var newSchema = new XbrlSchema(this, schemaLocation, string.Empty);

            if (newSchema.SchemaRootNode != null)
            {
                AddSchemaToSchemaList(newSchema);
            }
        }
Exemple #6
0
        //-------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------
        private void ReadTaxonomySchemaReference(INode SchemaRefNode)
        {
            string HrefAttributeValue = SchemaRefNode.GetAttributeValue(Xlink.XlinkNode.xlinkNamespace, "href");
            string Base      = SchemaRefNode.GetAttributeValue(XbrlDocument.XmlNamespaceUri, "base");
            var    newSchema = new XbrlSchema(this, HrefAttributeValue, Base);

            if (newSchema.SchemaRootNode != null)
            {
                AddSchemaToSchemaList(newSchema);
            }
        }
 //------------------------------------------------------------------------------------
 //------------------------------------------------------------------------------------
 internal LinkbaseDocument(XbrlSchema ContainingXbrlSchema, string DocumentPath)
 {
     this.Schema      = ContainingXbrlSchema;
     thisLinkbasePath = GetFullLinkbasePath(DocumentPath);
     thisXmlDocument  = Container.Resolve <IDocument>();
     thisXmlDocument.Load(thisLinkbasePath);
     thisNamespaceManager          = Container.Resolve <INamespaceManager>();
     thisNamespaceManager.Document = thisXmlDocument;
     thisNamespaceManager.AddNamespace("default", XbrlDocument.XbrlLinkbaseNamespaceUri);
     thisLinkbaseNode = thisXmlDocument.SelectSingleNode("//default:linkbase", thisNamespaceManager);
 }
 internal PresentationLinkbaseDocument(XbrlSchema ContainingXbrlSchema, string DocumentPath)
     : base(ContainingXbrlSchema, DocumentPath)
 {
     PresentationLinks = new List <PresentationLink>();
     foreach (INode CurrentChild in thisLinkbaseNode.ChildNodes)
     {
         if (CurrentChild.LocalName.Equals("presentationLink") == true)
         {
             this.PresentationLinks.Add(new PresentationLink(CurrentChild));
         }
     }
 }
Exemple #9
0
        /// <summary>
        /// Validates all summation concepts defined in the current schema.
        /// </summary>
        /// <param name="CurrentSchema">
        /// The schema whose containing summation concepts should be validated.
        /// </param>
        private void Validate(XbrlSchema CurrentSchema)
        {
            var calculationLinkbase = CurrentSchema.CalculationLinkbase;

            if (calculationLinkbase == null)
            {
                return;
            }
            foreach (CalculationLink CurrentCalculationLink in calculationLinkbase.CalculationLinks)
            {
                Validate(CurrentCalculationLink);
            }
        }
        internal PresentableFactTree(XbrlSchema schema, FactCollection facts)
        {
            TopLevelNodes = new List <PresentableFactTreeNode>();
            var presentationLinkbase = schema.PresentationLinkbase;

            foreach (var presentationLink in presentationLinkbase.PresentationLinks)
            {
                var unorderedPresentationArcs = presentationLink.PresentationArcs;
                var orderedPresentationArcs   = unorderedPresentationArcs.OrderBy(o => o.Order).ToList();
                var newTreeNode = new PresentableFactTreeNode();
                TopLevelNodes.Add(newTreeNode);
                foreach (var orderedPresentationArc in orderedPresentationArcs)
                {
                    // Set the tree node's node fact, if it is not already set.
                    //
                    // This code is making an assumption that each arc in the link is set up with
                    // the same "from" locator, so locating the "from" fact only needs to be done
                    // if it is not already set. If it is already set, the code assumes that it
                    // was set from a previous arc and doesn't not need to be set again (presumably
                    // with the same information it would get this time if it did all of the work
                    // again).
                    //
                    // If the locator references an abstract element, then there will be no fact
                    // and the value will remain null.

                    if (newTreeNode.NodeFact == null)
                    {
                        var fromLocator = GetLocator(orderedPresentationArc.From, presentationLink);
                        newTreeNode.PresentationLinkbaseLocator = fromLocator;
                        newTreeNode.NodeLabel = GetLabel(schema, fromLocator);
                        var fromElement = GetElement(schema, fromLocator.HrefResourceId);
                        if (fromElement.IsAbstract == false)
                        {
                            var fromFact = facts.GetFactByName(fromElement.Name);
                            newTreeNode.NodeFact = fromFact;
                        }
                    }
                    var toLocator        = GetLocator(orderedPresentationArc.To, presentationLink);
                    var newChildTreeNode = new PresentableFactTreeNode();
                    newTreeNode.ChildNodes.Add(newChildTreeNode);
                    newTreeNode.NodeLabel = GetLabel(schema, toLocator);
                    newChildTreeNode.PresentationLinkbaseLocator = toLocator;
                    var toElement = GetElement(schema, toLocator.HrefResourceId);
                    if (toElement.IsAbstract == false)
                    {
                        var toFact = facts.GetFactByName(toElement.Name);
                        newChildTreeNode.NodeFact = toFact;
                    }
                }
            }
        }
 /// <summary>
 /// Finds an element in the given schema with the given ID.
 /// </summary>
 /// <param name="schema">
 /// The compiled schema which whose elements should be searched.
 /// </param>
 /// <param name="id">
 /// The ID of the element to return.
 /// </param>
 /// <returns>
 /// The element whose ID matches the given ID, or null if no element can be found.
 /// </returns>
 private Element GetElement(XbrlSchema schema, string id)
 {
     foreach (var candidateElement in schema.Elements)
     {
         if (string.IsNullOrEmpty(candidateElement.Id) == false)
         {
             if (candidateElement.Id.Equals(id) == true)
             {
                 return(candidateElement);
             }
         }
     }
     return(null);
 }
        /// <summary>
        /// Adds a schema to the schema collection.
        /// </summary>
        /// <remarks>
        /// The supplied schema will not be added if its target namespace is already in the list. This will help
        /// with some of the XBRL instance documents in the XBRL Conformance Suite which uses both the "schemaLocation"
        /// attribute as well as a "schemaRef" node to specify the same schema. The "301-01-IdScopeValid.xml"
        /// instance document in the XBRL-CONF-CR5-2012-01-24 suite is one such example.
        /// </remarks>
        /// <param name="schemaToAdd">
        /// The schema to be added.
        /// </param>
        internal void Add(XbrlSchema schemaToAdd)
        {
            var targetNamespaceAlreadyInList = false;

            foreach (var currentSchema in SchemaList)
            {
                if (schemaToAdd.TargetNamespace.Equals(currentSchema.TargetNamespace) == true)
                {
                    targetNamespaceAlreadyInList = true;
                }
            }
            if (targetNamespaceAlreadyInList == false)
            {
                SchemaList.Add(schemaToAdd);
            }
        }
Exemple #13
0
 //------------------------------------------------------------------------------------
 //------------------------------------------------------------------------------------
 internal RoleType(XbrlSchema ContainingXbrlSchema, INode roleTypeNode)
 {
     this.Schema           = ContainingXbrlSchema;
     this.UsedOnReferences = new List <string>();
     this.RoleUri          = new Uri(roleTypeNode.GetAttributeValue("roleURI"));
     this.Id = roleTypeNode.GetAttributeValue("id");
     foreach (INode currentChild in roleTypeNode.ChildNodes)
     {
         if (currentChild.LocalName.Equals("definition") == true)
         {
             this.Definition = currentChild.InnerText;
         }
         if (currentChild.LocalName.Equals("usedOn") == true)
         {
             this.UsedOnReferences.Add(currentChild.InnerText);
         }
     }
 }
        /// <summary>
        /// Returns the label stored in a label linkbase for a given locator.
        /// </summary>
        /// <param name="schema">
        /// The compiled schema which whose elements should be searched.
        /// </param>
        /// <param name="labelLocator">
        /// The locator of the label to be returned.
        /// </param>
        /// <returns>
        /// The label for the given locator, or an empty string if there is no
        /// label.
        /// </returns>
        private string GetLabel(XbrlSchema schema, Locator labelLocator)
        {
            var labelLinkbase = schema.LabelLinkbase;

            if (labelLinkbase == null)
            {
                return(string.Empty);
            }
            foreach (var labelLink in labelLinkbase.LabelLinks)
            {
                var foundLabel = GetLabel(schema, labelLocator, labelLink);
                if (string.IsNullOrEmpty(foundLabel) == false)
                {
                    return(foundLabel);
                }
            }
            return(string.Empty);
        }
Exemple #15
0
        private static void ProcessSchemaNamespaceAndLocation(string schemaNamespace, string schemaLocation, XbrlFragment containingFragment)
        {
            foreach (var currentSchema in containingFragment.Schemas)
            {
                if (currentSchema.TargetNamespace.Equals(schemaNamespace) == true)
                {
                    return;
                }
                if (currentSchema.TargetNamespaceAlias.Equals(schemaNamespace) == true)
                {
                    return;
                }
            }
            var newSchema = new XbrlSchema(containingFragment, schemaLocation, string.Empty);

            if (newSchema.SchemaRootNode != null)
            {
                containingFragment.Schemas.Add(newSchema);
            }
        }
Exemple #16
0
 private void ValidateSegmentNodePrefix(INode SegmentNode)
 {
     if (SegmentNode.Prefix.Length > 0)
     {
         XbrlSchema NodeSchema = this.Fragment.GetXbrlSchemaForPrefix(SegmentNode.Prefix);
         if (NodeSchema != null)
         {
             Element NodeElement = NodeSchema.GetElement(SegmentNode.LocalName);
             if (NodeElement != null)
             {
                 if (NodeElement.SubstitutionGroup != Element.ElementSubstitutionGroup.Unknown)
                 {
                     string        MessageFormat  = AssemblyResources.GetName("SegmentNodeUsingSubGroupInXBRLNamespace");
                     StringBuilder MessageBuilder = new StringBuilder();
                     MessageBuilder.AppendFormat(MessageFormat, this.Id, SegmentNode.Name, NodeSchema.Path);
                     this.Fragment.AddValidationError(new ContextValidationError(this, MessageBuilder.ToString()));
                 }
             }
         }
     }
 }
Exemple #17
0
 /// <summary>
 /// Class constructor. This constructor will store a message and an exception.
 /// </summary>
 /// <param name="schema">
 /// The schema containing the error being reported.
 /// </param>
 /// <param name="message">
 /// The message to be stored in the validation error.
 /// </param>
 /// <param name="exception">
 /// The exception to be stored in the validation error.
 /// </param>
 internal SchemaValidationError(XbrlSchema schema, string message, Exception exception)
     : base(message, exception)
 {
     this.Schema = schema;
 }
Exemple #18
0
 /// <summary>
 /// Class constructor. This constructor will store a message and will automatically set the
 /// Exception property to a null value.
 /// </summary>
 /// <param name="schema">
 /// The schema containing the error being reported.
 /// </param>
 /// <param name="message">
 /// The message to be stored in the validation error.
 /// </param>
 internal SchemaValidationError(XbrlSchema schema, string message)
     : base(message)
 {
     this.Schema = schema;
 }
Exemple #19
0
 /// <summary>
 /// Adds a schema to the schema collection.
 /// </summary>
 /// <remarks>
 /// The supplied schema will not be added if its target namespace is already in the list. This will help
 /// with some of the XBRL instance documents in the XBRL Conformance Suite which uses both the "schemaLocation"
 /// attribute as well as a "schemaRef" node to specify the same schema. The "301-01-IdScopeValid.xml"
 /// instance document in the XBRL-CONF-CR5-2012-01-24 suite is one such example.
 /// </remarks>
 /// <param name="schemaToAdd">
 /// The schema to be added.
 /// </param>
 private void AddSchemaToSchemaList(XbrlSchema schemaToAdd)
 {
     this.Schemas.Add(schemaToAdd);
 }