コード例 #1
0
        //*************************************************************************
        //  Method: AppendVertexXmlNodes()
        //
        /// <summary>
        /// Appends a vertex XML node for each video that matches a specified
        /// search term.
        /// </summary>
        ///
        /// <param name="sSearchTerm">
        /// The term to search for.
        /// </param>
        ///
        /// <param name="eWhatToInclude">
        /// Specifies what should be included in the network.
        /// </param>
        ///
        /// <param name="iMaximumVideos">
        /// Maximum number of videos to request, or Int32.MaxValue for no limit.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// The GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oRequestStatistics">
        /// A <see cref="RequestStatistics" /> object that is keeping track of
        /// requests made while getting the network.
        /// </param>
        ///
        /// <param name="oVideoIDs">
        /// Where the set of unique video IDs gets stored.
        /// </param>
        ///
        /// <param name="oTagDictionary">
        /// If an edge should be included for each pair of videos that share the
        /// same tag, this gets set to a Dictionary for which the key is a
        /// lower-case tag and the value is a LinkedList of the video IDs that have
        /// the tag.  Otherwise, it gets set to null.
        /// </param>
        //*************************************************************************
        protected void AppendVertexXmlNodes(
            String sSearchTerm,
            WhatToInclude eWhatToInclude,
            Int32 iMaximumVideos,
            GraphMLXmlDocument oGraphMLXmlDocument,
            RequestStatistics oRequestStatistics,
            out HashSet<String> oVideoIDs,
            out Dictionary< String, LinkedList<String> > oTagDictionary
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sSearchTerm) );
            Debug.Assert(iMaximumVideos> 0);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oRequestStatistics != null);
            AssertValid();

            ReportProgress("Getting a list of videos.");

            // This is used to skip duplicate videos in the results returned by
            // YouTube.  (I'm not sure why YouTube sometimes returns duplicates,
            // but it does.)

            oVideoIDs = new HashSet<String>();

            // If an edge should be included for each pair of videos that share the
            // same tag, the key is a lower-case tag and the value is a LinkedList
            // of the video IDs that have the tag.

            if ( WhatToIncludeFlagIsSet(eWhatToInclude,
            WhatToInclude.SharedTagEdges) )
            {
            oTagDictionary = new Dictionary< String, LinkedList<String> >();
            }
            else
            {
            oTagDictionary = null;
            }

            String sUrl = String.Format(

            "http://gdata.youtube.com/feeds/api/videos?q={0}"
            ,
            EncodeUrlParameter(sSearchTerm)
            );

            // The document consists of an "entry" XML node for each video.

            foreach ( XmlNode oEntryXmlNode in EnumerateXmlNodes(sUrl,
            "a:feed/a:entry", iMaximumVideos, false, oRequestStatistics) )
            {
            XmlNamespaceManager oXmlNamespaceManager =
                CreateXmlNamespaceManager(oEntryXmlNode.OwnerDocument);

            // Use the video ID as the GraphML vertex name.  The video title
            // can't be used because it is not unique.

            String sVideoID;

            if (
                !XmlUtil2.TrySelectSingleNodeAsString(oEntryXmlNode,
                    "media:group/yt:videoid/text()", oXmlNamespaceManager,
                    out sVideoID)
                ||
                oVideoIDs.Contains(sVideoID)
                )
            {
                continue;
            }

            oVideoIDs.Add(sVideoID);

            XmlNode oVertexXmlNode = oGraphMLXmlDocument.AppendVertexXmlNode(
                sVideoID);

            AppendStringGraphMLAttributeValue(oEntryXmlNode,
                "a:title/text()", oXmlNamespaceManager, oGraphMLXmlDocument,
                oVertexXmlNode, TitleID);

            AppendDoubleGraphMLAttributeValue(oEntryXmlNode,
                "gd:rating/@average", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, RatingID);

            AppendInt32GraphMLAttributeValue(oEntryXmlNode,
                "yt:statistics/@viewCount", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, ViewsID);

            AppendInt32GraphMLAttributeValue(oEntryXmlNode,
                "yt:statistics/@favoriteCount", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, FavoritedID);

            AppendInt32GraphMLAttributeValue(oEntryXmlNode,
                "gd:comments/gd:feedLink/@countHint", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, CommentsID);

            AppendYouTubeDateGraphMLAttributeValue(oEntryXmlNode,
                "a:published/text()", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, CreatedDateUtcID);

            AppendStringGraphMLAttributeValue(oEntryXmlNode,
                "media:group/media:thumbnail/@url", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, ImageFileID);

            if ( AppendStringGraphMLAttributeValue(oEntryXmlNode,
                    "media:group/media:player/@url", oXmlNamespaceManager,
                    oGraphMLXmlDocument, oVertexXmlNode, MenuActionID) )
            {
                oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
                    MenuTextID, "Play Video in Browser");
            }

            if (oTagDictionary != null)
            {
                CollectTags(oEntryXmlNode, sVideoID, oXmlNamespaceManager,
                    oTagDictionary);
            }
            }
        }
コード例 #2
0
        //*************************************************************************
        //  Method: AppendSampleThumbnails()
        //
        /// <summary>
        /// Appends sample thumbnails to the GraphMLXmlDocument being populated.
        /// </summary>
        ///
        /// <param name="oTagDictionary">
        /// The key is the tag name and the value is the corresponding GraphML XML
        /// node that represents the tag.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="sApiKey">
        /// Flickr API key.
        /// </param>
        ///
        /// <param name="oRequestStatistics">
        /// A <see cref="RequestStatistics" /> object that is keeping track of
        /// requests made while getting the network.
        /// </param>
        //*************************************************************************
        protected void AppendSampleThumbnails(
            Dictionary<String, XmlNode> oTagDictionary,
            GraphMLXmlDocument oGraphMLXmlDocument,
            String sApiKey,
            RequestStatistics oRequestStatistics
            )
        {
            Debug.Assert(oTagDictionary != null);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert( !String.IsNullOrEmpty(sApiKey) );
            Debug.Assert(oRequestStatistics != null);
            AssertValid();

            foreach (KeyValuePair<String, XmlNode> oKeyValuePair in oTagDictionary)
            {
            String sTag = oKeyValuePair.Key;

            ReportProgress("Getting sample image file for \"" + sTag + "\".");

            String sSampleImageUrl;

            if ( TryGetSampleImageUrl(sTag, sApiKey, oRequestStatistics,
                out sSampleImageUrl) )
            {
                oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                    oKeyValuePair.Value, ImageFileID, sSampleImageUrl);
            }
            }
        }
コード例 #3
0
        //*************************************************************************
        //  Method: AppendVertexXmlNode()
        //
        /// <summary>
        /// Appends a vertex XML node to the document for a tag if such a node
        /// doesn't already exist.
        /// </summary>
        ///
        /// <param name="sTag">
        /// Tag to add a vertex XML node for.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oTagDictionary">
        /// The key is the tag name and the value is the corresponding GraphML XML
        /// node that represents the tag.
        /// </param>
        //*************************************************************************
        protected void AppendVertexXmlNode(
            String sTag,
            GraphMLXmlDocument oGraphMLXmlDocument,
            Dictionary<String, XmlNode> oTagDictionary
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sTag) );
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oTagDictionary != null);

            if ( !oTagDictionary.ContainsKey(sTag) )
            {
            XmlNode oVertexXmlNode = oGraphMLXmlDocument.AppendVertexXmlNode(
                sTag);

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
                LabelID, sTag);

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
                MenuTextID, "Open Flickr Page for This Tag");

            oGraphMLXmlDocument.AppendGraphMLAttributeValue( oVertexXmlNode,
                MenuActionID,

                String.Format(
                    "http://www.flickr.com/photos/tags/{0}/"
                    ,
                    UrlUtil.EncodeUrlParameter(sTag)
                ) );

            oTagDictionary.Add(sTag, oVertexXmlNode);
            }
        }
コード例 #4
0
        //*************************************************************************
        //  Method: TryAppendVertexXmlNode()
        //
        /// <summary>
        /// Appends a vertex XML node to the GraphML document for a user if such a
        /// node doesn't already exist.
        /// </summary>
        ///
        /// <param name="sUserName">
        /// User name to add a vertex XML node for.
        /// </param>
        ///
        /// <param name="oEntryXmlNode">
        /// The "entry" XML node returned by YouTube, or null if an entry node
        /// isn't available.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oUserNameDictionary">
        /// The key is the user name and the value is the corresponding GraphML XML
        /// node that represents the user.
        /// </param>
        ///
        /// <returns>
        /// true if a vertex XML node was added, false if a vertex XML node already
        /// exists.
        /// </returns>
        //*************************************************************************
        protected Boolean TryAppendVertexXmlNode(
            String sUserName,
            XmlNode oEntryXmlNode,
            GraphMLXmlDocument oGraphMLXmlDocument,
            Dictionary<String, XmlNode> oUserNameDictionary
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sUserName) );
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oUserNameDictionary != null);

            XmlNode oVertexXmlNode;

            if ( oUserNameDictionary.TryGetValue(sUserName, out oVertexXmlNode) )
            {
            return (false);
            }

            oVertexXmlNode = oGraphMLXmlDocument.AppendVertexXmlNode(sUserName);
            oUserNameDictionary.Add(sUserName, oVertexXmlNode);

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
            MenuTextID, "Open YouTube Page for This Person");

            oGraphMLXmlDocument.AppendGraphMLAttributeValue( oVertexXmlNode,
            MenuActionID, String.Format(WebPageUrlPattern, sUserName) );

            return (true);
        }
コード例 #5
0
        //*************************************************************************
        //  Method: AppendVertexXmlNodes()
        //
        /// <summary>
        /// Appends a vertex XML node for each person who has tweeted a specified
        /// search term.
        /// </summary>
        ///
        /// <param name="sSearchTerm">
        /// The term to search for.
        /// </param>
        ///
        /// <param name="eWhatToInclude">
        /// Specifies what should be included in the network.
        /// </param>
        ///
        /// <param name="iMaximumPeoplePerRequest">
        /// Maximum number of people to request for each query, or Int32.MaxValue
        /// for no limit.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// The GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oScreenNameDictionary">
        /// The key is the screen name in lower case and the value is the
        /// corresponding TwitterVertex.
        /// </param>
        ///
        /// <param name="oRequestStatistics">
        /// A <see cref="RequestStatistics" /> object that is keeping track of
        /// requests made while getting the network.
        /// </param>
        //*************************************************************************
        protected void AppendVertexXmlNodes(
            String sSearchTerm,
            WhatToInclude eWhatToInclude,
            Int32 iMaximumPeoplePerRequest,
            GraphMLXmlDocument oGraphMLXmlDocument,
            Dictionary<String, TwitterVertex> oScreenNameDictionary,
            RequestStatistics oRequestStatistics
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sSearchTerm) );
            Debug.Assert(iMaximumPeoplePerRequest > 0);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oScreenNameDictionary != null);
            Debug.Assert(oRequestStatistics != null);
            AssertValid();

            // Convert spaces in the search term to a plus sign.
            //
            // (Note: Don't try to use Twitter's "show_user" URL parameter in an
            // attempt to get a "user" XML node for each author.  That's not what
            // the URL parameter does.)

            String sUrl = String.Format(

            "http://search.twitter.com/search.atom?q={0}&rpp=100"
            ,
            UrlUtil.EncodeUrlParameter(sSearchTerm).Replace("%20", "+")
            );

            ReportProgress("Getting a list of tweets.");

            Boolean bIncludeStatistics = WhatToIncludeFlagIsSet(
            eWhatToInclude, WhatToInclude.Statistics);

            Boolean bIncludeStatuses = WhatToIncludeFlagIsSet(
            eWhatToInclude, WhatToInclude.Statuses);

            // The document consists of an "entry" XML node for each tweet that
            // contains the search term.  Multiple tweets may have the same author,
            // so we have to enumerate until the requested maximum number of unique
            // authors is reached.

            foreach ( XmlNode oAuthorNameXmlNode in EnumerateXmlNodes(
            sUrl, "a:feed/a:entry/a:author/a:name", "a", AtomNamespaceUri,
            15, Int32.MaxValue, true, false, oRequestStatistics) )
            {
            if (oScreenNameDictionary.Count == iMaximumPeoplePerRequest)
            {
                break;
            }

            // The author name is in this format:
            //
            // james_laker (James Laker)

            String sAuthorName;

            if ( !XmlUtil2.TrySelectSingleNodeAsString(oAuthorNameXmlNode,
                "text()", null, out sAuthorName) )
            {
                continue;
            }

            Int32 iIndexOfSpace = sAuthorName.IndexOf(' ');
            String sScreenName = sAuthorName;

            if (iIndexOfSpace != -1)
            {
                sScreenName = sAuthorName.Substring(0, iIndexOfSpace);
            }

            sScreenName = sScreenName.ToLower();

            TwitterVertex oTwitterVertex;

            if ( !TryAppendVertexXmlNode(sScreenName, null,
                oGraphMLXmlDocument, oScreenNameDictionary, bIncludeStatistics,
                false, out oTwitterVertex) )
            {
                // A tweet for the author has already been found.

                continue;
            }

            XmlNode oVertexXmlNode = oTwitterVertex.VertexXmlNode;
            XmlNode oEntryXmlNode = oAuthorNameXmlNode.ParentNode.ParentNode;

            XmlNamespaceManager oXmlNamespaceManager = new XmlNamespaceManager(
                oEntryXmlNode.OwnerDocument.NameTable);

            oXmlNamespaceManager.AddNamespace("a", AtomNamespaceUri);

            // Get the image URL and status for the tweet's author.

            AppendStringGraphMLAttributeValue(oEntryXmlNode,
                "a:link[@rel='image']/@href", oXmlNamespaceManager,
                oGraphMLXmlDocument, oVertexXmlNode, ImageFileID);

            String sStatus;

            if ( XmlUtil2.TrySelectSingleNodeAsString(oEntryXmlNode,
                "a:title/text()", oXmlNamespaceManager, out sStatus) )
            {
                String sStatusDateUtc;

                if ( XmlUtil2.TrySelectSingleNodeAsString(oEntryXmlNode,
                    "a:published/text()", oXmlNamespaceManager,
                    out sStatusDateUtc) )
                {
                    sStatusDateUtc = TwitterDateParser.ParseTwitterDate(
                        sStatusDateUtc);
                }

                oTwitterVertex.StatusForAnalysis = sStatus;
                oTwitterVertex.StatusForAnalysisDateUtc = sStatusDateUtc;

                if (bIncludeStatuses)
                {
                    oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                        oVertexXmlNode, StatusID, sStatus);

                    if ( !String.IsNullOrEmpty(sStatusDateUtc) )
                    {
                        oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                            oVertexXmlNode, StatusDateUtcID, sStatusDateUtc);
                    }
                }
            }
            }
        }
コード例 #6
0
        //*************************************************************************
        //  Method: AppendEdgeXmlNode()
        //
        /// <summary>
        /// Appends an edge XML node to a GraphML document.
        /// </summary>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="sVertex1ID">
        /// ID of the edge's first vertex.
        /// </param>
        ///
        /// <param name="sVertex2ID">
        /// ID of the edge's second vertex.
        /// </param>
        ///
        /// <param name="sRelationship">
        /// The value of the edge's RelationshipID GraphML-attribute.
        /// </param>
        ///
        /// <returns>
        /// The new edge XML node.
        /// </returns>
        //*************************************************************************
        protected XmlNode AppendEdgeXmlNode(
            GraphMLXmlDocument oGraphMLXmlDocument,
            String sVertex1ID,
            String sVertex2ID,
            String sRelationship
            )
        {
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert( !String.IsNullOrEmpty(sVertex1ID) );
            Debug.Assert( !String.IsNullOrEmpty(sVertex2ID) );
            Debug.Assert( !String.IsNullOrEmpty(sRelationship) );
            AssertValid();

            XmlNode oEdgeXmlNode = oGraphMLXmlDocument.AppendEdgeXmlNode(
            sVertex1ID, sVertex2ID);

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oEdgeXmlNode,
            RelationshipID, sRelationship);

            return (oEdgeXmlNode);
        }
コード例 #7
0
        //*************************************************************************
        //  Method: AppendStringGraphMLAttributeValue()
        //
        /// <summary>
        /// Appends a String GraphML-Attribute value to an edge or vertex XML node. 
        /// </summary>
        ///
        /// <param name="oXmlNodeToSelectFrom">
        /// Node to select from.
        /// </param>
        /// 
        /// <param name="sXPath">
        /// XPath expression to a String descendant of <paramref
        /// name="oXmlNodeToSelectFrom" />.
        /// </param>
        ///
        /// <param name="oXmlNamespaceManager">
        /// NamespaceManager to use, or null to not use one.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oEdgeOrVertexXmlNode">
        /// The edge or vertex XML node from <paramref
        /// name="oGraphMLXmlDocument" /> to add the GraphML attribute value to.
        /// </param>
        ///
        /// <param name="sGraphMLAttributeID">
        /// GraphML ID of the attribute.
        /// </param>
        ///
        /// <returns>
        /// true if the GraphML-Attribute was appended.
        /// </returns>
        ///
        /// <remarks>
        /// This method selects from <paramref name="oXmlNodeToSelectFrom" /> using
        /// the <paramref name="sXPath" /> expression.  If the selection is
        /// successful, the specified String value gets stored on <paramref
        /// name="oEdgeOrVertexXmlNode" /> as a Graph-ML Attribute.
        /// </remarks>
        //*************************************************************************
        protected Boolean AppendStringGraphMLAttributeValue(
            XmlNode oXmlNodeToSelectFrom,
            String sXPath,
            XmlNamespaceManager oXmlNamespaceManager,
            GraphMLXmlDocument oGraphMLXmlDocument,
            XmlNode oEdgeOrVertexXmlNode,
            String sGraphMLAttributeID
            )
        {
            Debug.Assert(oXmlNodeToSelectFrom != null);
            Debug.Assert( !String.IsNullOrEmpty(sXPath) );
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oEdgeOrVertexXmlNode != null);
            Debug.Assert( !String.IsNullOrEmpty(sGraphMLAttributeID) );
            AssertValid();

            String sAttributeValue;

            if ( XmlUtil2.TrySelectSingleNodeAsString(oXmlNodeToSelectFrom, sXPath,
            oXmlNamespaceManager, out sAttributeValue) )
            {
            oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                oEdgeOrVertexXmlNode, sGraphMLAttributeID, sAttributeValue);

            return (true);
            }

            return (false);
        }
コード例 #8
0
        //*************************************************************************
        //  Method: AppendRepliesToAndMentionsXmlNodes()
        //
        /// <summary>
        /// Appends edge XML nodes for replies-to and mentions relationships.
        /// </summary>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oScreenNameDictionary">
        /// The key is the screen name in lower case and the value is the
        /// corresponding TwitterVertex.
        /// </param>
        ///
        /// <param name="bIncludeRepliesToEdges">
        /// true to append edges for replies-to relationships.
        /// </param>
        ///
        /// <param name="bIncludeMentionsEdges">
        /// true to append edges for mentions relationships.
        /// </param>
        //*************************************************************************
        protected void AppendRepliesToAndMentionsXmlNodes(
            GraphMLXmlDocument oGraphMLXmlDocument,
            Dictionary<String, TwitterVertex> oScreenNameDictionary,
            Boolean bIncludeRepliesToEdges,
            Boolean bIncludeMentionsEdges
            )
        {
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oScreenNameDictionary != null);
            AssertValid();

            if (!bIncludeRepliesToEdges && !bIncludeMentionsEdges)
            {
            return;
            }

            XmlNamespaceManager oGraphMLXmlNamespaceManager =
            oGraphMLXmlDocument.CreateXmlNamespaceManager("g");

            ReportProgress("Examining relationships.");

            // "Starts with a screen name," which means it's a "reply-to".

            Regex oReplyToRegex = new Regex(@"^@(?<ScreenName>\w+)");

            // "Contains a screen name," which means it's a "mentions".
            //
            // Note that a "reply-to" is also a "mentions."

            Regex oMentionsRegex = new Regex(@"(^|\s)@(?<ScreenName>\w+)");

            foreach (KeyValuePair<String, TwitterVertex> oKeyValuePair in
            oScreenNameDictionary)
            {
            String sScreenName = oKeyValuePair.Key;
            TwitterVertex oTwitterVertex = oKeyValuePair.Value;
            String sStatusForAnalysis = oTwitterVertex.StatusForAnalysis;

            String sStatusForAnalysisDateUtc =
                oTwitterVertex.StatusForAnalysisDateUtc;

            if ( String.IsNullOrEmpty(sStatusForAnalysis) )
            {
                continue;
            }

            if (bIncludeRepliesToEdges)
            {
                Match oReplyToMatch = oReplyToRegex.Match(sStatusForAnalysis);

                if (oReplyToMatch.Success)
                {
                    String sReplyToScreenName =
                        oReplyToMatch.Groups["ScreenName"].Value.ToLower();

                    if (
                        sReplyToScreenName != sScreenName
                        &&
                        oScreenNameDictionary.ContainsKey(sReplyToScreenName)
                        )
                    {
                        XmlNode oEdgeXmlNode = AppendEdgeXmlNode(
                            oGraphMLXmlDocument, sScreenName,
                            sReplyToScreenName, "Replies to");

                        if ( !String.IsNullOrEmpty(sStatusForAnalysisDateUtc) )
                        {
                            oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                                oEdgeXmlNode, RelationshipDateUtcID,
                                sStatusForAnalysisDateUtc);
                        }
                    }
                }
            }

            if (bIncludeMentionsEdges)
            {
                Match oMentionsMatch =
                    oMentionsRegex.Match(sStatusForAnalysis);

                while (oMentionsMatch.Success)
                {
                    String sMentionsScreenName =
                        oMentionsMatch.Groups["ScreenName"].Value.ToLower();

                    if (
                        sMentionsScreenName != sScreenName
                        &&
                        oScreenNameDictionary.ContainsKey(sMentionsScreenName)
                        )
                    {
                        XmlNode oEdgeXmlNode = AppendEdgeXmlNode(
                            oGraphMLXmlDocument, sScreenName,
                            sMentionsScreenName, "Mentions");

                        if ( !String.IsNullOrEmpty(sStatusForAnalysisDateUtc) )
                        {
                            oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                                oEdgeXmlNode, RelationshipDateUtcID,
                                sStatusForAnalysisDateUtc);
                        }
                    }

                    oMentionsMatch = oMentionsMatch.NextMatch();
                }
            }
            }
        }
コード例 #9
0
        //*************************************************************************
        //  Method: AppendGraphMLAttributeValues()
        //
        /// <summary>
        /// Appends Graph-ML attribute values to a vertex or edge XML node while
        /// saving a graph.
        /// </summary>
        ///
        /// <param name="oEdgeOrVertex">
        /// The edge or vertex to read metadata from.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// The GraphML document being populated.
        /// </param>
        ///
        /// <param name="oEdgeOrVertexXmlNode">
        /// The edge or vertex XML node in the GraphML document that corresponds to
        /// <paramref name="oEdgeOrVertex" />.
        /// </param>
        ///
        /// <param name="asAttributeNames">
        /// Array of all possible Graph-ML attribute names for the edge or vertex.
        /// </param>
        ///
        /// <param name="AttributeIDPrefix">
        /// The prefix to use for each Graph-ML attribute ID.
        /// </param>
        //*************************************************************************
        protected void AppendGraphMLAttributeValues(
            IMetadataProvider oEdgeOrVertex,
            GraphMLXmlDocument oGraphMLXmlDocument,
            XmlNode oEdgeOrVertexXmlNode,
            String [] asAttributeNames,
            String AttributeIDPrefix
            )
        {
            Debug.Assert(oEdgeOrVertex != null);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oEdgeOrVertexXmlNode != null);
            Debug.Assert(asAttributeNames != null);
            Debug.Assert( !String.IsNullOrEmpty(AttributeIDPrefix) );
            AssertValid();

            foreach (String sAttributeName in asAttributeNames)
            {
            Object oAttributeValue;

            // Note that the value type isn't checked.  Whatever type it is,
            // it gets converted to a string.

            if (oEdgeOrVertex.TryGetValue(sAttributeName,
                out oAttributeValue) && oAttributeValue != null)
            {
                oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                    oEdgeOrVertexXmlNode, AttributeIDPrefix + sAttributeName,
                    oAttributeValue.ToString() );
            }
            }
        }
コード例 #10
0
        //*************************************************************************
        //  Method: AppendRelationshipDateUtcGraphMLAttributeValue()
        //
        /// <summary>
        /// Appends a GraphML attribute value for the relationship date to an edge
        /// XML node.
        /// </summary>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oEdgeXmlNode">
        /// The edge XML node to add the Graph-ML attribute value to.
        /// </param>
        ///
        /// <param name="oRequestStatistics">
        /// A <see cref="RequestStatistics" /> object that is keeping track of
        /// requests made while getting the network.
        /// </param>
        ///
        /// <remarks>
        /// The Graph-ML attribute value is set to the start time of the network
        /// request.
        /// </remarks>
        //*************************************************************************
        protected void AppendRelationshipDateUtcGraphMLAttributeValue(
            GraphMLXmlDocument oGraphMLXmlDocument,
            XmlNode oEdgeXmlNode,
            RequestStatistics oRequestStatistics
            )
        {
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oEdgeXmlNode != null);
            Debug.Assert(oRequestStatistics != null);
            AssertValid();

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oEdgeXmlNode,
            RelationshipDateUtcID,

            TwitterDateParser.ToCultureInvariantString(
                oRequestStatistics.StartTimeUtc)
            );
        }
コード例 #11
0
        //*************************************************************************
        //  Method: AppendFromUserXmlNode()
        //
        /// <summary>
        /// Appends GraphML-Attribute values from a "user" XML node returned by
        /// Twitter to a vertex XML node.
        /// </summary>
        ///
        /// <param name="oUserXmlNode">
        /// The "user" XML node returned by Twitter.  Can't be null.
        /// </param>
        /// 
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oTwitterVertex">
        /// Contains the vertex XML node from <paramref
        /// name="oGraphMLXmlDocument" /> to add the GraphML attribute values to.
        /// </param>
        ///
        /// <param name="bIncludeStatistics">
        /// true to include the user's statistics.
        /// </param>
        ///
        /// <param name="bIncludeLatestStatus">
        /// true to include a latest status attribute value.
        /// </param>
        ///
        /// <remarks>
        /// This method reads information from a "user" XML node returned by
        /// Twitter and appends the information to a vertex XML node in the GraphML
        /// document.
        /// </remarks>
        //*************************************************************************
        protected void AppendFromUserXmlNode(
            XmlNode oUserXmlNode,
            GraphMLXmlDocument oGraphMLXmlDocument,
            TwitterVertex oTwitterVertex,
            Boolean bIncludeStatistics,
            Boolean bIncludeLatestStatus
            )
        {
            Debug.Assert(oUserXmlNode != null);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oTwitterVertex != null);
            AssertValid();

            XmlNode oVertexXmlNode = oTwitterVertex.VertexXmlNode;

            if (bIncludeStatistics)
            {
            AppendInt32GraphMLAttributeValue(oUserXmlNode,
                "friends_count/text()", null, oGraphMLXmlDocument,
                oVertexXmlNode, FollowedID);

            AppendInt32GraphMLAttributeValue(oUserXmlNode,
                "followers_count/text()", null, oGraphMLXmlDocument,
                oVertexXmlNode, FollowersID);

            AppendInt32GraphMLAttributeValue(oUserXmlNode,
                "statuses_count/text()", null, oGraphMLXmlDocument,
                oVertexXmlNode, StatusesID);

            AppendInt32GraphMLAttributeValue(oUserXmlNode,
                "favourites_count/text()", null, oGraphMLXmlDocument,
                oVertexXmlNode, FavoritesID);

            AppendStringGraphMLAttributeValue(oUserXmlNode,
                "description/text()", null, oGraphMLXmlDocument,
                oVertexXmlNode, DescriptionID);

            AppendStringGraphMLAttributeValue(oUserXmlNode,
                "time_zone/text()", null, oGraphMLXmlDocument, oVertexXmlNode,
                TimeZoneID);

            AppendStringGraphMLAttributeValue(oUserXmlNode,
                "utc_offset/text()", null, oGraphMLXmlDocument, oVertexXmlNode,
                UtcOffsetID);

            String sJoinedDateUtc;

            if ( XmlUtil2.TrySelectSingleNodeAsString(oUserXmlNode,
                "created_at/text()", null, out sJoinedDateUtc) )
            {
                oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                    oVertexXmlNode, JoinedDateUtcID,
                    TwitterDateParser.ParseTwitterDate(sJoinedDateUtc) );
            }
            }

            String sLatestStatus;

            if ( XmlUtil2.TrySelectSingleNodeAsString(oUserXmlNode,
            "status/text/text()", null, out sLatestStatus) )
            {
            String sLatestStatusDateUtc;

            if ( XmlUtil2.TrySelectSingleNodeAsString(oUserXmlNode,
                "status/created_at/text()", null, out sLatestStatusDateUtc) )
            {
                sLatestStatusDateUtc = TwitterDateParser.ParseTwitterDate(
                    sLatestStatusDateUtc);
            }

            // Don't overwrite any status the derived class may have already
            // stored on the TwitterVertex object.

            if (oTwitterVertex.StatusForAnalysis == null)
            {
                oTwitterVertex.StatusForAnalysis = sLatestStatus;
                oTwitterVertex.StatusForAnalysisDateUtc = sLatestStatusDateUtc;
            }

            if (bIncludeLatestStatus)
            {
                oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
                    LatestStatusID, sLatestStatus);

                if ( !String.IsNullOrEmpty(sLatestStatusDateUtc) )
                {
                    oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                        oVertexXmlNode, LatestStatusDateUtcID,
                        sLatestStatusDateUtc);
                }
            }
            }

            // Add an image URL GraphML-attribute if it hasn't already been added.
            // (It might have been added from an "entry" node by
            // TwitterSearchNetworkAnalyzer.)

            if (oVertexXmlNode.SelectSingleNode(
            "a:data[@key='" + ImageFileID + "']",
            oGraphMLXmlDocument.CreateXmlNamespaceManager("a") ) == null)
            {
            AppendStringGraphMLAttributeValue(oUserXmlNode,
                "profile_image_url/text()", null, oGraphMLXmlDocument,
                oVertexXmlNode, ImageFileID);
            }
        }
コード例 #12
0
        //*************************************************************************
        //  Method: TryAppendVertexXmlNode()
        //
        /// <overloads>
        /// Appends a vertex XML node to the GraphML document for a person if such
        /// a node doesn't already exist.
        /// </overloads>
        ///
        /// <summary>
        /// Appends a vertex XML node to the GraphML document for a person if such
        /// a node doesn't already exist and provides the TwitterVertex for the
        /// node.
        /// </summary>
        ///
        /// <param name="sScreenName">
        /// Screen name to add a vertex XML node for.
        /// </param>
        ///
        /// <param name="oUserXmlNode">
        /// The "user" XML node returned by Twitter, or null if a user node isn't
        /// available.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oScreenNameDictionary">
        /// The key is the screen name in lower case and the value is the
        /// corresponding TwitterVertex.
        /// </param>
        ///
        /// <param name="bIncludeStatistics">
        /// true to include the user's statistics if <paramref
        /// name="oUserXmlNode" /> is not null.
        /// </param>
        ///
        /// <param name="bIncludeLatestStatus">
        /// true to include a latest status attribute value if <paramref
        /// name="oUserXmlNode" /> is not null.
        /// </param>
        ///
        /// <param name="oTwitterVertex">
        /// Where the TwitterVertex that wraps the vertex XML node gets stored.
        /// This gets set regardless of whether the node already existed.
        /// </param>
        ///
        /// <returns>
        /// true if a vertex XML node was added, false if a vertex XML node already
        /// existed.
        /// </returns>
        //*************************************************************************
        protected Boolean TryAppendVertexXmlNode(
            String sScreenName,
            XmlNode oUserXmlNode,
            GraphMLXmlDocument oGraphMLXmlDocument,
            Dictionary<String, TwitterVertex> oScreenNameDictionary,
            Boolean bIncludeStatistics,
            Boolean bIncludeLatestStatus,
            out TwitterVertex oTwitterVertex
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sScreenName) );
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oScreenNameDictionary != null);

            oTwitterVertex = null;

            if ( oScreenNameDictionary.TryGetValue(sScreenName,
            out oTwitterVertex) )
            {
            return (false);
            }

            XmlNode oVertexXmlNode = oGraphMLXmlDocument.AppendVertexXmlNode(
            sScreenName);

            oTwitterVertex = new TwitterVertex(oVertexXmlNode);
            oScreenNameDictionary.Add(sScreenName, oTwitterVertex);

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
            MenuTextID, "Open Twitter Page for This Person");

            oGraphMLXmlDocument.AppendGraphMLAttributeValue( oVertexXmlNode,
            MenuActionID, String.Format(WebPageUrlPattern, sScreenName) );

            if (oUserXmlNode != null)
            {
            AppendFromUserXmlNode(oUserXmlNode, oGraphMLXmlDocument,
                oTwitterVertex, bIncludeStatistics, bIncludeLatestStatus);
            }

            return (true);
        }
コード例 #13
0
        //*************************************************************************
        //  Method: GetUserNetworkRecursive()
        //
        /// <summary>
        /// Recursively gets a network of Flickr users.
        /// </summary>
        ///
        /// <param name="sUserID">
        /// Flickr user ID.
        /// </param>
        ///
        /// <param name="sScreenName">
        /// Flickr screen name.
        /// </param>
        ///
        /// <param name="eWhatToInclude">
        /// Specifies what should be included in the network.
        /// </param>
        ///
        /// <param name="bIncludeContactsThisCall">
        /// true to include the user's contacts, false to include the people who
        /// have commented on the user's photos.
        /// </param>
        ///
        /// <param name="eNetworkLevel">
        /// Network level to include.  Must be NetworkLevel.One, OnePointFive, or
        /// Two.
        /// </param>
        ///
        /// <param name="iMaximumPerRequest">
        /// Maximum number of people or photos to request for each query, or
        /// Int32.MaxValue for no limit.
        /// </param>
        ///
        /// <param name="sApiKey">
        /// Flickr API key.
        /// </param>
        ///
        /// <param name="iRecursionLevel">
        /// Recursion level for this call.  Must be 1 or 2.  Gets incremented when
        /// recursing.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="oUserIDDictionary">
        /// The key is the user ID and the value is the corresponding GraphML XML
        /// node that represents the user.
        /// </param>
        ///
        /// <param name="oRequestStatistics">
        /// A <see cref="RequestStatistics" /> object that is keeping track of
        /// requests made while getting the network.
        /// </param>
        //*************************************************************************
        protected void GetUserNetworkRecursive(
            String sUserID,
            String sScreenName,
            WhatToInclude eWhatToInclude,
            Boolean bIncludeContactsThisCall,
            NetworkLevel eNetworkLevel,
            Int32 iMaximumPerRequest,
            String sApiKey,
            Int32 iRecursionLevel,
            GraphMLXmlDocument oGraphMLXmlDocument,
            Dictionary<String, XmlNode> oUserIDDictionary,
            RequestStatistics oRequestStatistics
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sUserID) );
            Debug.Assert( !String.IsNullOrEmpty(sScreenName) );

            Debug.Assert(eNetworkLevel == NetworkLevel.One ||
            eNetworkLevel == NetworkLevel.OnePointFive ||
            eNetworkLevel == NetworkLevel.Two);

            Debug.Assert(iMaximumPerRequest > 0);
            Debug.Assert( !String.IsNullOrEmpty(sApiKey) );
            Debug.Assert(iRecursionLevel == 1 || iRecursionLevel == 2);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert(oUserIDDictionary != null);
            Debug.Assert(oRequestStatistics != null);
            AssertValid();

            /*
            Here is what this method should do, based on the eNetworkLevel and
            iRecursionLevel parameters.

                eNetworkLevel

               |One               | OnePointFive      | Two
            ---|------------------| ------------------| -----------------
            i   1  |Add all vertices. | Add all vertices. | Add all vertices.
            R      |                  |                   |
            e      |Add all edges.    | Add all edges.    | Add all edges.
            c      |                  |                   |
            u      |Do not recurse.   | Recurse.          | Recurse.
            r      |                  |                   |
            s   ---|------------------|-------------------|------------------
            i   2  |Impossible.       | Do not add        | Add all vertices.
            o      |                  | vertices.         |
            n      |                  |                   |
            L      |                  | Add edges only if | Add all edges.
            e      |                  | vertices are      |
            v      |                  | already included. |
            e      |                  |                   |
            l      |                  | Do not recurse.   | Do not recurse.
               |                  |                   |
            ---|------------------|-------------------|------------------
            */

            Boolean bNeedToRecurse = GetNeedToRecurse(eNetworkLevel,
            iRecursionLevel);

            Boolean bNeedToAppendVertices = GetNeedToAppendVertices(eNetworkLevel,
            iRecursionLevel);

            List<String> oUserIDsToRecurse = new List<String>();

            ReportProgressForContactsOrCommenters(sScreenName,
            bIncludeContactsThisCall);

            Boolean bThisUserAppended = false;

            foreach ( XmlNode oChildXmlNode in GetContactsOrCommentersEnumerator(
            sUserID, bIncludeContactsThisCall, iMaximumPerRequest,
            oGraphMLXmlDocument, sApiKey, oRequestStatistics) )
            {
            String sOtherScreenName, sOtherUserID;

            if (
                !XmlUtil2.TrySelectSingleNodeAsString(oChildXmlNode,
                    bIncludeContactsThisCall ? "@username" : "@authorname",
                    null, out sOtherScreenName)
                ||
                !XmlUtil2.TrySelectSingleNodeAsString(oChildXmlNode,
                    bIncludeContactsThisCall ? "@nsid" : "@author",
                    null, out sOtherUserID)
                )
            {
                continue;
            }

            if (!bThisUserAppended)
            {
                // Append a vertex node for this request's user.
                //
                // This used to be done after the foreach loop, which avoided
                // the need for a "bThisUserAppended" flag.  That caused the
                // following bug: If a YouTube error occurred within
                // EnumerateXmlNodes() after some edges had been added, and the
                // user decided to import the resulting partial network, the
                // GraphML might contain edges that referenced "this user"
                // without containing a vertex for "this user."  That is an
                // illegal state for GraphML, which the ExcelTemplate project
                // caught and reported as an error.

                TryAppendVertexXmlNode(sUserID, sScreenName,
                    oGraphMLXmlDocument, oUserIDDictionary);

                bThisUserAppended = true;
            }

            if (bNeedToAppendVertices)
            {
                if (
                    TryAppendVertexXmlNode(sOtherUserID, sOtherScreenName,
                        oGraphMLXmlDocument, oUserIDDictionary)
                    &&
                    bNeedToRecurse
                    )
                {
                    oUserIDsToRecurse.Add(sOtherUserID);
                }
            }

            if ( bNeedToAppendVertices ||
                oUserIDDictionary.ContainsKey(sOtherUserID) )
            {
                // Append an edge node and optional attributes.

                XmlNode oEdgeXmlNode;

                if (bIncludeContactsThisCall)
                {
                    oEdgeXmlNode = AppendEdgeXmlNode(oGraphMLXmlDocument,
                        sScreenName, sOtherScreenName, "Contact");
                }
                else
                {
                    // (Note the swapping of screen names in the commenter
                    // case.)

                    oEdgeXmlNode = AppendEdgeXmlNode(oGraphMLXmlDocument,
                        sOtherScreenName, sScreenName, "Commenter");

                    UInt32 uCommentDateUtc;

                    if ( XmlUtil2.TrySelectSingleNodeAsUInt32(oChildXmlNode,
                            "@datecreate", null, out uCommentDateUtc) )
                    {
                        DateTime oCommentDateUtc =
                            DateTimeUtil2.UnixTimestampToDateTimeUtc(
                                uCommentDateUtc);

                        oGraphMLXmlDocument.AppendGraphMLAttributeValue(
                            oEdgeXmlNode, CommentDateUtcID,

                            ExcelDateTimeUtil.DateTimeToStringLocale1033(
                                oCommentDateUtc, ExcelColumnFormat.DateAndTime)
                            );
                    }

                    AppendStringGraphMLAttributeValue(oChildXmlNode,
                        "@permalink", null, oGraphMLXmlDocument, oEdgeXmlNode,
                        CommentUrlID);
                }
            }
            }

            if (bNeedToRecurse)
            {
            foreach (String sUserIDToRecurse in oUserIDsToRecurse)
            {
                XmlNode oVertexXmlNode = oUserIDDictionary[sUserIDToRecurse];

                String sScreenNameToRecurse = GetScreenNameFromVertexXmlNode(
                    oVertexXmlNode);

                GetUserNetworkRecursive(sUserIDToRecurse, sScreenNameToRecurse,
                    eWhatToInclude, bIncludeContactsThisCall, eNetworkLevel,
                    iMaximumPerRequest, sApiKey, 2, oGraphMLXmlDocument,
                    oUserIDDictionary, oRequestStatistics);
            }
            }
        }
コード例 #14
0
        //*************************************************************************
        //  Method: AppendUserInformationGraphMLAttributeValues()
        //
        /// <summary>
        /// Appends user information GraphML attribute values to the GraphML
        /// document for one user in the network.
        /// </summary>
        ///
        /// <param name="sUserID">
        /// The user ID.
        /// </param>
        ///
        /// <param name="oVertexXmlNode">
        /// The GraphML XML node corresponding to the user.
        /// </param>
        ///
        /// <param name="oGraphMLXmlDocument">
        /// GraphMLXmlDocument being populated.
        /// </param>
        ///
        /// <param name="sApiKey">
        /// Flickr API key.
        /// </param>
        ///
        /// <param name="oRequestStatistics">
        /// A <see cref="RequestStatistics" /> object that is keeping track of
        /// requests made while getting the network.
        /// </param>
        //*************************************************************************
        protected void AppendUserInformationGraphMLAttributeValues(
            String sUserID,
            XmlNode oVertexXmlNode,
            GraphMLXmlDocument oGraphMLXmlDocument,
            String sApiKey,
            RequestStatistics oRequestStatistics
            )
        {
            Debug.Assert( !String.IsNullOrEmpty(sUserID) );
            Debug.Assert(oVertexXmlNode != null);
            Debug.Assert(oGraphMLXmlDocument != null);
            Debug.Assert( !String.IsNullOrEmpty(sApiKey) );
            Debug.Assert(oRequestStatistics != null);
            AssertValid();

            String sUrl = GetFlickrMethodUrl( "flickr.people.getInfo",
            sApiKey, GetUserIDUrlParameter(sUserID) );

            XmlDocument oXmlDocument;

            if ( !TryGetXmlDocument(sUrl, oRequestStatistics, out oXmlDocument) )
            {
            // Ignore errors.  The user information isn't critical.

            return;
            }

            const String XPathRoot = "rsp/person/";

            AppendStringGraphMLAttributeValue(oXmlDocument,
            XPathRoot + "realname/text()", null, oGraphMLXmlDocument,
            oVertexXmlNode, RealNameID);

            AppendInt32GraphMLAttributeValue(oXmlDocument,
            XPathRoot + "photos/count/text()", null, oGraphMLXmlDocument,
            oVertexXmlNode, TotalPhotosID);

            String sIsProfessional;

            if ( XmlUtil2.TrySelectSingleNodeAsString(oXmlDocument,
            XPathRoot + "@ispro", null, out sIsProfessional) )
            {
            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
                IsProfessionalID,
                (sIsProfessional == "0") ? "No" : "Yes"
                );
            }

            // Get the URL to the user's buddy icon, which is explained here:
            //
            // http://www.flickr.com/services/api/misc.buddyicons.html

            Int32 iIconServer, iIconFarm;
            String sBuddyIconUrl;

            if (
            XmlUtil2.TrySelectSingleNodeAsInt32(oXmlDocument,
                XPathRoot + "@iconserver", null, out iIconServer)
            &&
            XmlUtil2.TrySelectSingleNodeAsInt32(oXmlDocument,
                XPathRoot + "@iconfarm", null, out iIconFarm)
            &&
            iIconServer > 0
            )
            {
            sBuddyIconUrl = String.Format(

                "http://farm{0}.static.flickr.com/{1}/buddyicons/{2}.jpg"
                ,
                iIconFarm,
                iIconServer,
                sUserID
                );
            }
            else
            {
            sBuddyIconUrl = "http://www.flickr.com/images/buddyicon.jpg";
            }

            oGraphMLXmlDocument.AppendGraphMLAttributeValue(
            oVertexXmlNode, ImageFileID, sBuddyIconUrl);

            if ( AppendStringGraphMLAttributeValue(oXmlDocument,
            XPathRoot + "photosurl/text()", null, oGraphMLXmlDocument,
            oVertexXmlNode, MenuActionID) )
            {
            oGraphMLXmlDocument.AppendGraphMLAttributeValue(oVertexXmlNode,
                MenuTextID, "Open Flickr Page for This Person");
            }
        }