public static AnalyzeTweet Map(ITweet tweet, string track)
 {
     return new AnalyzeTweet
     {
         Tweet = MapTweet(tweet, track)
     };
 }

 public MarkTweetAsReadCommand(ITweet tweet, ITweetSink tweetSink)
 {
     _tweet = tweet;
     _tweetSink = tweetSink;
     _observer = new PropertyObserver<ITweet>(_tweet).
         RegisterHandler(x => x.IsRead, 
                         x => CanExecuteChanged(this, EventArgs.Empty));
 }

 public SerializableTweet(ITweet tweet)
 {
     this.Creator = tweet.Creator.Name;
     this.CreatedAt = tweet.CreatedAt;
     this.IsRetweet = tweet.IsRetweet;
     this.Language = tweet.Language.ToString();
     this.Retweeted = tweet.Retweeted;
     this.Text = tweet.Text;
 }

 public void Add(ITweet tweet)
 {
     lock (_mutex)
         using (IDocumentSession session = _documentStore.OpenSession())
         {
             session.Store(tweet);
             session.SaveChanges();
         }
 }

        // Publish Tweet
        public string PublishTweet(ITweet tweet)
        {
            if (tweet == null)
            {
                throw new ArgumentException("Tweet cannot be null");
            }

            return PublishTweet(tweet.TweetDTO);
        }

 public static TweetReceived Map(ITweet tweet, string track, string endpointName, Guid sessionId)
 {
     return new TweetReceived
     {
         EndpointName = endpointName,
         SessionId = sessionId,
         Tweet = Map(tweet, track)
     };
 }

        public IEnumerable<ITweet> SearchRepliesTo(ITweet tweet, bool recursiveReplies)
        {
            if (tweet == null)
            {
                throw new ArgumentException("Tweet cannot be null");
            }

            var repliesDTO = _searchQueryExecutor.SearchRepliesTo(tweet.TweetDTO, recursiveReplies);
            return _tweetFactory.GenerateTweetsFromDTO(repliesDTO);
        }

        public TweetRating(IAuthorizer client, ITweet tweet)
        {
            _client = client;
            _tweet = tweet;

            _observer = new PropertyObserver<IAuthorizer>(_client).
                RegisterHandler(x => x.AuthenticatedUser,
                                x => UpdateIsMention());
            UpdateIsMention();
        }

 static string FormatTweet(ITweet tweet)
 {
     var builder = new StringBuilder();
     builder.AppendLine(string.Format("{0} (@{1}) - {2}",
                        tweet.CreatedBy.Name,
                        tweet.CreatedBy.ScreenName,
                        tweet.CreatedAt.ToLocalTime().ToString("MM/dd/yy h:mm:ss tt")));
     builder.AppendLine(tweet.Text);
     return builder.ToString();
 }

        // Publish Tweet InReplyTo
        public bool PublishTweetInReplyTo(ITweet tweetToPublish, ITweet tweetToReplyTo)
        {
            if (tweetToPublish == null || tweetToReplyTo == null)
            {
                throw new ArgumentException("Tweet cannot be null!");
            }

            var publishedTweetDTO = PublishTweetDTOInReplyTo(tweetToPublish.TweetDTO, tweetToReplyTo.TweetDTO);
            UpdateTweetIfTweetSuccessfullyBeenPublished(tweetToPublish, publishedTweetDTO);

            return tweetToPublish.IsTweetPublished;
        }

 public void FollowUserIfRequired(ITweet tweet)
 {
     if (FollowWords.Any(word => tweet.Text.IndexOf(word, StringComparison.OrdinalIgnoreCase) > -1))
     {
         try
         {
             User.GetLoggedUser().FollowUser(tweet.CreatedBy.Id);
         }
         catch (Exception)
         {
             // Ignore exceptions.
         }
     }
 }

 private static FSTweet InviTweetToPTTweet(ITweet t)
 {
     FSTweet ptTweet = new FSTweet();
     if (t.Coordinates != null)
     {
         ptTweet.Coordinates = t.Coordinates.Longitude.ToString() + ","
             + t.Coordinates.Latitude.ToString();
     }
     ptTweet.CreatedOn = t.CreatedAt;
     ptTweet.Id = t.Id.ToString();
     ptTweet.ReplyToId = t.InReplyToUserIdStr;
     ptTweet.Text = t.Text;
     return ptTweet;
 }

        public bool PublishTweet(ITweet tweet, IPublishTweetOptionalParameters optionalParameters = null)
        {
            if (tweet == null)
            {
                throw new ArgumentException("Tweet cannot be null!");
            }

            var parameters = new PublishTweetParameters(tweet.Text, optionalParameters);
            var tweetDTO = InternalPublishTweet(parameters);

            UpdateTweetIfTweetSuccessfullyBeenPublished(tweet, tweetDTO);

            return tweet.IsTweetPublished;
        }

        private void InsereRC(ref Nodo N, ITweet value)
        {
            if (N == null)
                {
                    Nodo novoNodo = new Nodo(value);
                    N = novoNodo;
                }
                else if (value.CreatedAt < N.valor.CreatedAt) // menor vai pra esquerda
                    InsereRC(ref N.esquerda, value);
                else //if (value >= N.valor) // maior ou igual vai pra direita
                    InsereRC(ref N.direita, value);

                return;
        }

        // find IDs of the search queries that correspond to the streamed tweet
        private List<string> GetTweetMatchingSearchIDs(ITweet tweet, string streamQueryID, List<ArrayList<ArrayList<QueryToken>>> searchTokens, List<string> searchQueryIDs)
        {
            List<int> matchingIdx = CompareStreamToSearchIDs(streamQueryID, searchQueryIDs);
            List<ArrayList<ArrayList<QueryToken>>> matchingSearchTokens = searchTokens.Where((x, idx) => matchingIdx.Contains(idx)).ToList();
           
            List<int> matchingIDsIndeces = new List<int>();
            foreach (var queryTokens in matchingSearchTokens.Select((value, idx) => new {idx, value}))
                if (IsMatch(tweet, queryTokens.value))
                    matchingIDsIndeces.Add(queryTokens.idx);

            matchingIdx = matchingIdx.Where((x, idx) => matchingIDsIndeces.Contains(idx)).ToList();
            List<string> matchingIDs = searchQueryIDs.Where((x, idx) => matchingIdx.Contains(idx)).ToList();

            return matchingIDs;
        }

 public void Add(ITweet tweet)
 {
     if (tweet.Media != null)
     {
         foreach (var media in tweet.Media)
         {
             this.SaveTweetPic(tweet, media.MediaURL, CreateFileName(tweet));
         }
     }
     else
     {
         // saves the tweet without a picture
         this.SaveTweet(tweet);
     }
 }

        void HandleTweet(ITweet tweet)
        {
            if ((from tag in tweet.Hashtags where tag.Text == HashtagTrigger select tag).Any())
            {
                Log.Info("Index rebuild triggered from Twitter by '{0}'".FormatWith(tweet.Creator.Name), this);
                CrawlingLog.Log.Info("Index rebuild triggered from Twitter by '{0}'".FormatWith(tweet.Creator.Name));

                if (IndexCustodian.IsIndexingPaused(m_index) || IndexCustodian.IsRebuilding(m_index))
                {
                    CrawlingLog.Log.Warn("Indexing call muted");
                    Log.Info("Indexing call muted", this);
                    return;
                }

                IndexCustodian.FullRebuild(m_index);
            }
        }

        public TweetItem(ITweet tweet)
        {
            Text = tweet.Text;
            CreationDate = tweet.CreatedAt;
            User = tweet.Creator.ScreenName;
            if (tweet.Creator != null)
            {
                Language = tweet.Creator.Lang;
                if (tweet.Creator.FollowersCount.HasValue)
                {
                    Followers = tweet.Creator.FollowersCount.Value;
                }

                if (tweet.Creator.FriendsCount.HasValue)
                {
                    Friends = tweet.Creator.FriendsCount.Value;
                }
            }
        }

 public TweetSentimentData(ITweet tweet)
 {
     this.Id = tweet.IdStr;
     this.Text = tweet.Text;
     if (tweet.InReplyToStatusIdStr != null)
     {
         this.ReplyToId = tweet.InReplyToStatusIdStr;
     }
     else
     {
         this.ReplyToId = "";
     }
     this.CreatedOn = tweet.CreatedAt;
     if (tweet.Coordinates != null)
     {
         this.Coordinates = tweet.Coordinates.Longitude.ToString() + ","
             + tweet.Coordinates.Latitude.ToString();
     }
     this.Sentiment = SentimentEngine.CalculateSentiment(this.Text);
 }

 private static Tweet MapTweet(ITweet tweet, string track)
 {
     return tweet == null
         ? null
         : new Tweet
         {
             CreatedAt = tweet.CreatedAt,
             CreatedById = tweet.CreatedBy.Id,
             CreatedByIdStr = tweet.CreatedBy.IdStr,
             CreatedByName = tweet.CreatedBy.Name,
             CreatedByScreenName = tweet.CreatedBy.ScreenName,
             Hashtags = tweet.Hashtags
                 .Select(hashtag =>
                     new Hashtag
                     {
                         Text = hashtag.Text,
                         Indices = hashtag.Indices,
                     })
                 .ToList(),
             Id = tweet.Id,
             RetweetedTweet = MapTweet(tweet.RetweetedTweet, track),
             Text = tweet.Text,
             Track = track,
             UserMentions = tweet.UserMentions
                 .Where(userMention => userMention.Id.HasValue)
                 .Select(userMention =>
                     new UserMention
                     {
                         Id = userMention.Id.Value,
                         IdStr = userMention.IdStr,
                         Indices = userMention.Indices,
                         Name = userMention.Name,
                         ScreenName = userMention.ScreenName,
                     })
                 .ToList(),
         };
 }