Ejemplo n.º 1
0
        /// <summary>
        /// Validate the essence alias between two facts referenced in a definition arc using
        /// the set of all facts in the fragment.
        /// </summary>
        /// <param name="EssenceAliasDefinitionArc">
        /// The definition arc defining the essence alias.
        /// </param>
        /// <param name="FactList">
        /// A collection of <see cref="Fact"/> objects defined in the fragment.
        /// </param>
        private void ValidateEssenceAliasedFacts(DefinitionArc EssenceAliasDefinitionArc, FactCollection FactList)
        {
            Locator CurrentFromLocator = EssenceAliasDefinitionArc.FromLocator;

            if (CurrentFromLocator == null)
            {
                throw new NullReferenceException("FromLocator is NULL in ValidateEssenceAliasedFacts()");
            }
            Locator CurrentToLocator = EssenceAliasDefinitionArc.ToLocator;

            foreach (Fact CurrentFact in FactList)
            {
                if (CurrentFact is Item)
                {
                    var CurrentItem = CurrentFact as Item;
                    if (CurrentItem.Name.Equals(CurrentFromLocator.HrefResourceId) == true)
                    {
                        ValidateEssenceAliasedFacts(CurrentItem, FactList, CurrentToLocator.HrefResourceId);
                    }
                }
                else if (CurrentFact is Tuple)
                {
                    var CurrentTuple = CurrentFact as Tuple;
                    ValidateEssenceAliasedFacts(EssenceAliasDefinitionArc, CurrentTuple.Facts);
                }
            }
        }
Ejemplo n.º 2
0
        //-------------------------------------------------------------------------------
        // Validate the "requires element" connection between two facts referenced in a
        // definition arc.
        //-------------------------------------------------------------------------------
        private void ValidateRequiresElementFacts(DefinitionArc RequiresElementDefinitionArc)
        {
            Locator CurrentFromLocator = RequiresElementDefinitionArc.FromLocator;
            Locator CurrentToLocator   = RequiresElementDefinitionArc.ToLocator;
            int     FromFactCount      = CountFactInstances(CurrentFromLocator.HrefResourceId);
            int     ToFactCount        = CountFactInstances(CurrentToLocator.HrefResourceId);

            if (FromFactCount > ToFactCount)
            {
                StringBuilder MessageBuilder = new StringBuilder();
                string        StringFormat   = AssemblyResources.GetName("NotEnoughToFactsInRequiresElementRelationship");
                MessageBuilder.AppendFormat(StringFormat, CurrentFromLocator.HrefResourceId, CurrentToLocator.HrefResourceId);
                validatingFragment.AddValidationError(new DefinitionArcValidationError(RequiresElementDefinitionArc, MessageBuilder.ToString()));
            }
        }
Ejemplo n.º 3
0
 /// <summary>
 /// Validate the essence alias between two facts referenced in a definition arc using
 /// the set of all facts in the fragment.
 /// </summary>
 /// <param name="EssenceAliasDefinitionArc">
 /// The definition arc defining the essence alias.
 /// </param>
 private void ValidateEssenceAliasedFacts(DefinitionArc EssenceAliasDefinitionArc)
 {
     ValidateEssenceAliasedFacts(EssenceAliasDefinitionArc, validatingFragment.Facts);
 }
Ejemplo n.º 4
0
        private Linkbase CreateDefinitionLinkbase(Taxonomy taxonomy, DiscoverableTaxonomySet dts)
        {
            var linkbase = new Linkbase(GetLinkbaseFileName(taxonomy, "def"));

            var memberItems = ExtensionItems.OfType <ExtensionMember>().ToList();

            var groupedByHypercube = memberItems.SelectMany(i => i.Locations.Select(l =>
                                                                                    new { l.HypercubeName, Location = l, Item = i }))
                                     .GroupBy(d => d.HypercubeName)
                                     .ToList();

            foreach (var groupByHypercube in groupedByHypercube)
            {
                var hypercubeNode = dts.GetAllLinks()
                                    .Where(l => l.ElementName == LinkbaseXNames.Definition)
                                    .SelectMany(l => l.NodesMap.Values)
                                    .OfType <LocatorNode>()
                                    .SingleOrDefault(ln => ln.Item.Name == groupByHypercube.Key);
                if (hypercubeNode == null)
                {
                    throw new InvalidOperationException($"Could not find a hypercube (aka table) {groupByHypercube.Key} in the DTS.");
                }

                var definitionLink = new DefinitionLink(LinkbaseXNames.Definition, hypercubeNode.Link.Role);
                linkbase.AddLink(definitionLink, dts);

                var locCount = 0;
                foreach (var locationAndItem in groupByHypercube)
                {
                    var dimensionLocationNode = hypercubeNode.FromArcs
                                                .OfType <DefinitionArc>()
                                                .Select(da => da.ToLocator)
                                                .SingleOrDefault(ln => ln.Item.Name == locationAndItem.Location.DimensionName);

                    if (dimensionLocationNode == null)
                    {
                        throw new InvalidOperationException($"Could not find a dimension (aka axis) {locationAndItem.Location.DimensionName} in the hypercube (aka table) {groupByHypercube.Key}.");
                    }

                    var parentNodeInBaseTaxonomy = FindParentNode(dimensionLocationNode, locationAndItem.Location.ParentName);
                    if (parentNodeInBaseTaxonomy == null)
                    {
                        throw new InvalidOperationException($"There is no member {locationAndItem.Location.ParentName} in the dimension {groupByHypercube.Key}.");
                    }

                    var siblingArcs = parentNodeInBaseTaxonomy.GetOrderedOutgoingHierarchicalArcs <DefinitionArc>();

                    double newOrder;
                    try
                    {
                        newOrder = DetermineOrder(locationAndItem.Location.PrecedingSiblingName, siblingArcs);
                    }
                    catch (InvalidOperationException ex)
                    {
                        throw new InvalidOperationException($"The sibling {locationAndItem.Location.PrecedingSiblingName} was not found as a child of {locationAndItem.Location.ParentName} in the dimension {groupByHypercube.Key}.", ex);
                    }

                    var parentLocLabel = $"loc_{locCount}";
                    locCount += 1;
                    var parentNode = new LocatorNode(parentLocLabel, parentNodeInBaseTaxonomy.Item);
                    definitionLink.AddNode(parentNode);

                    var locLabel = $"loc_{locCount}";
                    locCount += 1;
                    var locNode = CreateLocatorNode(locLabel, locationAndItem.Item, dts);
                    definitionLink.AddNode(locNode);

                    var arc = new DefinitionArc(parentNode, locNode, newOrder);
                    definitionLink.AddArc(arc);
                }
            }

            return(linkbase);
        }