private void FillSessionsXmlNodeText(IList <CompletionSet> completionSets, ITrackingSpan applicableTo, ConnectionData connectionData, XElement doc, XElement currentXmlNode)
        {
            if (string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.FetchRoot, StringComparison.InvariantCultureIgnoreCase) ||
                string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.SavedQueryRoot, StringComparison.InvariantCultureIgnoreCase)
                )
            {
                var repository = ConnectionIntellisenseDataRepository.GetRepository(connectionData);

                HashSet <string> usedEntities = GetUsedEntities(doc);

                if (usedEntities.Any())
                {
                    repository.GetEntityDataForNamesAsync(usedEntities);
                }

                if (string.Equals(currentXmlNode.Name.LocalName, "value", StringComparison.InvariantCultureIgnoreCase))
                {
                    var nodeCondition = currentXmlNode.Parent;

                    if (nodeCondition != null && string.Equals(nodeCondition.Name.LocalName, "condition", StringComparison.InvariantCultureIgnoreCase))
                    {
                        Dictionary <string, string> aliases = GetEntityAliases(doc);

                        FillEntityAttributeValuesInList(completionSets, applicableTo, repository, nodeCondition, aliases);
                    }
                }
            }
        }
예제 #2
0
        public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
        {
            if (_isDisposed)
            {
                return;
            }

            var connectionConfig = ConnectionConfiguration.Get();

            if (connectionConfig?.CurrentConnectionData == null)
            {
                return;
            }

            ITextSnapshot snapshot     = _buffer.CurrentSnapshot;
            var           triggerPoint = session.GetTriggerPoint(snapshot);

            if (triggerPoint == null)
            {
                return;
            }

            var repository = ConnectionIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

            SnapshotSpan extent = FindTokenSpanAtPosition(session).GetSpan(snapshot);

            ITrackingSpan applicableTo = null;

            if (extent.GetText() == ".")
            {
                extent = new SnapshotSpan(extent.Start + 1, extent.End);
            }

            var line = triggerPoint.Value.GetContainingLine().Extent;

            var relativePath = string.Empty;

            if (line.Start <= extent.Start)
            {
                relativePath = new SnapshotSpan(line.Start, extent.Start).GetText().TrimEnd('.');
            }

            applicableTo = snapshot.CreateTrackingSpan(extent, SpanTrackingMode.EdgeInclusive);

            var intellisenseData = repository.GetEntitiesIntellisenseData();

            if (intellisenseData == null ||
                intellisenseData.Entities == null
                )
            {
                return;
            }

            try
            {
                if (string.IsNullOrEmpty(relativePath))
                {
                    FillEntityNamesInList(completionSets, applicableTo, intellisenseData, false);
                }
                else
                {
                    var usedEntities = GetUsedEntitiesFromPath(relativePath, intellisenseData);

                    if (usedEntities.Any())
                    {
                        repository.GetEntityDataForNamesAsync(usedEntities);
                    }

                    var entityNameHash = GetEntityNameFromPath(relativePath, intellisenseData, out bool isGuid);

                    if (entityNameHash != null)
                    {
                        if (entityNameHash.Count == 1)
                        {
                            var entityName = entityNameHash.First();

                            var entityData = repository.GetEntityAttributeIntellisense(entityName);

                            if (entityData != null)
                            {
                                FillEntityIntellisenseDataAttributes(completionSets, applicableTo, entityData);

                                FillMultiLinkForEntity(completionSets, applicableTo, intellisenseData, entityData);
                            }
                        }
                        else if (entityNameHash.Count > 0)
                        {
                            FillMultiLinkEntityForEntities(completionSets, applicableTo, entityNameHash, intellisenseData);
                        }
                        else if (isGuid)
                        {
                            FillMultiLinkEntityForAll(completionSets, applicableTo, intellisenseData);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                DTEHelper.WriteExceptionToOutput(connectionConfig.CurrentConnectionData, ex);
            }
        }
        public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
        {
            if (_isDisposed)
            {
                return;
            }

            var connectionConfig = ConnectionConfiguration.Get();

            if (connectionConfig?.CurrentConnectionData == null)
            {
                return;
            }

            ITextSnapshot snapshot     = _buffer.CurrentSnapshot;
            var           triggerPoint = session.GetTriggerPoint(snapshot);

            if (triggerPoint == null)
            {
                return;
            }

            XElement doc = ReadXmlDocument(snapshot.GetText());

            if (doc == null)
            {
                return;
            }

            if (string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.RootFetch, StringComparison.InvariantCultureIgnoreCase))
            {
                var repository = ConnectionIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

                FillSessionForFetchXml(session, completionSets, snapshot, doc, connectionConfig.CurrentConnectionData, repository);
            }
            else if (string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.RootGrid, StringComparison.InvariantCultureIgnoreCase))
            {
                var repository = ConnectionIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

                FillSessionForGridXml(session, completionSets, snapshot, doc, connectionConfig.CurrentConnectionData, repository);
            }
            else if (string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.RootSavedQuery, StringComparison.InvariantCultureIgnoreCase))
            {
                var repository = ConnectionIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

                FillSessionForFetchXml(session, completionSets, snapshot, doc, connectionConfig.CurrentConnectionData, repository);

                FillSessionForGridXml(session, completionSets, snapshot, doc, connectionConfig.CurrentConnectionData, repository);
            }
            else if (string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.RootSiteMap, StringComparison.InvariantCultureIgnoreCase))
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);
                var repositorySiteMap     = SiteMapIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

                FillSessionForSiteMap(triggerPoint.Value, session, completionSets, snapshot, doc, connectionConfig.CurrentConnectionData, repositoryEntities, repositorySiteMap, repositoryWebResource);
            }
            else if (string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.RootRibbonDiffXml, StringComparison.InvariantCultureIgnoreCase) ||
                     string.Equals(doc.Name.ToString(), Commands.AbstractDynamicCommandXsdSchemas.RootRibbonDefinitions, StringComparison.InvariantCultureIgnoreCase)
                     )
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

                var repositoryRibbon = RibbonIntellisenseDataRepository.GetRepository(connectionConfig.CurrentConnectionData);

                FillSessionForRibbonDiffXml(triggerPoint.Value, session, completionSets, snapshot, doc, connectionConfig.CurrentConnectionData, repositoryEntities, repositoryWebResource, repositoryRibbon);
            }
        }
        private void FillSessionsXmlAttribute(IList <CompletionSet> completionSets, ITrackingSpan applicableTo, ConnectionData connectionData, ITextSnapshot snapshot, SnapshotSpan extent, XElement doc, XElement currentXmlNode, string currentNodeName, string currentAttributeName)
        {
            if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.FetchRoot, StringComparison.InvariantCultureIgnoreCase))
            {
                var repository = ConnectionIntellisenseDataRepository.GetRepository(connectionData);

                HashSet <string> usedEntities = GetUsedEntities(doc);

                if (usedEntities.Any())
                {
                    repository.GetEntityDataForNamesAsync(usedEntities);
                }

                FillSessionForFetchXmlCompletionSet(completionSets, doc, connectionData, repository, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);
            }
            else if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.GridRoot, StringComparison.InvariantCultureIgnoreCase))
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionData);

                HashSet <int> usedEntityCodes = GetUsedEntityObjectTypeCodes(doc);

                if (usedEntityCodes.Any())
                {
                    repositoryEntities.GetEntityDataForObjectTypeCodesAsync(usedEntityCodes);
                }

                FillSessionForGridXmlCompletionSet(completionSets, connectionData, repositoryEntities, repositoryWebResource, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);
            }
            else if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.SavedQueryRoot, StringComparison.InvariantCultureIgnoreCase))
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionData);

                HashSet <string> usedEntities = GetUsedEntities(doc);

                if (usedEntities.Any())
                {
                    repositoryEntities.GetEntityDataForNamesAsync(usedEntities);
                }

                HashSet <int> usedEntityCodes = GetUsedEntityObjectTypeCodes(doc);

                if (usedEntityCodes.Any())
                {
                    repositoryEntities.GetEntityDataForObjectTypeCodesAsync(usedEntityCodes);
                }

                FillSessionForFetchXmlCompletionSet(completionSets, doc, connectionData, repositoryEntities, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);

                FillSessionForGridXmlCompletionSet(completionSets, connectionData, repositoryEntities, repositoryWebResource, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);
            }
            else if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.SiteMapXmlRoot, StringComparison.InvariantCultureIgnoreCase))
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionData);
                var repositorySiteMap     = SiteMapIntellisenseDataRepository.GetRepository(connectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionData);

                HashSet <string> usedEntities = GetUsedEntities(doc);

                if (usedEntities.Any())
                {
                    repositoryEntities.GetEntityDataForNamesAsync(usedEntities);
                }

                FillSessionForSiteMapCompletionSet(completionSets, snapshot, connectionData, repositoryEntities, repositorySiteMap, repositoryWebResource, extent, currentNodeName, currentAttributeName, applicableTo);
            }
            else if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.RibbonDiffXmlRoot, StringComparison.InvariantCultureIgnoreCase) ||
                     string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.RibbonXmlRoot, StringComparison.InvariantCultureIgnoreCase)
                     )
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionData);

                var repositoryRibbon = RibbonIntellisenseDataRepository.GetRepository(connectionData);

                FillSessionForRibbonDiffXmlCompletionSet(completionSets, doc, connectionData, repositoryEntities, repositoryWebResource, repositoryRibbon, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);
            }
            else if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.WebResourceDependencyXmlRoot, StringComparison.InvariantCultureIgnoreCase))
            {
                var repositoryEntities    = ConnectionIntellisenseDataRepository.GetRepository(connectionData);
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionData);

                FillSessionForWebResourceDependencyXmlCompletionSet(completionSets, doc, connectionData, repositoryEntities, repositoryWebResource, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);
            }
            else if (string.Equals(doc.Name.LocalName, Commands.AbstractDynamicCommandXsdSchemas.FormXmlRoot, StringComparison.InvariantCultureIgnoreCase))
            {
                var repositoryWebResource = WebResourceIntellisenseDataRepository.GetRepository(connectionData);

                FillSessionForFormXmlCompletionSet(completionSets, doc, connectionData, repositoryWebResource, currentXmlNode, currentNodeName, currentAttributeName, applicableTo);
            }
        }