Exemplo n.º 1
0
def query_twitter_api():
    """Query Elon's twitter for references to keywords."""

    print("Query Initiating...")
    auth = tweepy.OAuthHandler(
        CONSUMER_KEY,
        CONSUMER_SECRET_KEY
    )

    auth.set_access_token(
        KEY,
        SECRET_KEY
    )

    api = tweepy.API(auth)

    twitter_status = api.user_timeline(
        id="elonmusk", count=1, tweet_mode="extended"
    )[0]._json

    tweet_text = twitter_status["full_text"]

    if re.search(r'\bbitcoin\b', tweet_text):
        obj = {
            "twitter_handle": "elonmusk",
            "created_at": twitter_status["created_at"],
            "text": tweet_text
        }

        print("Tweet mentioning bitcoin found")
        tweet = Tweet(**obj)
        tweet.save()
    else:
        print("No tweet mentioning bitcoin found")
Exemplo n.º 2
0
def post_tweet_view(request):
    if request.user.is_authenticated:
        current_user = request.user
        notes = len(
            Notification.objects.filter(notify_user=current_user).filter(
                is_seen=False))
    else:
        notes = 0
    if request.method == "POST":
        form = PostTweetForm(request.POST)
        if form.is_valid():
            data = form.cleaned_data
            new_tweet = Tweet(
                user_tweeted=current_user,
                content=data.get('content'),
                #date_and_time=data.get('date_and_time')
            )
            new_tweet.save()
            # Either gets after "@" or returns false
            notify = read_reggie(data.get('content'))
            if notify:
                # Gets user being "@" @ by the username in the mention
                #note_user = MyTwitterUser.objects.get(username=notify)
                for name in notify:
                    Notification.objects.create(
                        # Attributes user
                        notify_user=MyTwitterUser.objects.get(username=name),
                        # Gets tweet obj
                        tweet=new_tweet,
                        is_seen=False)
            return HttpResponseRedirect(reverse('home'))
    form = PostTweetForm()
    return render(request, 'tweet_form.html', {'form': form, 'notes': notes})
Exemplo n.º 3
0
def twitter(request):
	if 'currentUser' in request.session:
		currentUser = request.session['currentUser']
		myTweets = Tweet.objects.filter(username=currentUser)
		theirTweetList = []

		getFollowedUsers = userFollowing.objects.filter(username=currentUser)
		for f in getFollowedUsers:
			followedTweets = Tweet.objects.filter(username=f.userFollowed)
			for t in followedTweets:
				theirTweetList.insert(0, t) 

		if 'searchUser' in request.POST:
			searchedUser = request.POST['searchUser']
			request.session['searchedUser'] = searchedUser
			return HttpResponseRedirect("/usersearch/")

		if 'incomingTweet' in request.POST:
			newTweet = request.POST['incomingTweet']
			#process tweet_post, then save in database
			if len(newTweet) <= 140 and len(newTweet) > 1:
				addTweet = Tweet(message=newTweet,username=currentUser)
				addTweet.save()
				#add new tweet
				return render(request, 'twitter.html', {'result': "", 'currentUser': currentUser, 'myTweets':myTweets, 'theirTweets': theirTweetList}, context_instance=RequestContext(request))
			else:
				return render(request, 'twitter.html', {'result': "Your tweet needs to be between 1 to 140 characters.", 'currentUser': currentUser, 'myTweets': myTweets, 'theirTweets': theirTweetList}, context_instance=RequestContext(request))
		else:
			return render(request, 'twitter.html', {'result': "", 'currentUser': currentUser, 'myTweets':myTweets, 'theirTweets': theirTweetList}, context_instance=RequestContext(request))
	else:
		return HttpResponseRedirect("/")
Exemplo n.º 4
0
def tweetform_view(request):
    html = "tweetform.html"

    if request.method == "POST":
        form = TweetForm(request.POST)

        if form.is_valid():
            data = form.cleaned_data

            newTweet = Tweet(tweetbody=data['tweetbody'],
                             date_filed=data['date_filed'],
                             author=request.user)
            newTweet.save()
            # This newTweet['tweetbody'] is reaching into db
            # if '@' in newTweet['tweetbody']:
            pattern = re.search("@[\w\d]+", newTweet.tweetbody)

            if pattern is not None:
                pattern = pattern.group(0)[1:]
                target_user = TwitterUser.objects.get(username=pattern)

                Notification.objects.create(
                    target_user=target_user,
                    tweet=newTweet,
                )

            baseProfile = TwitterUser.objects.get(username=request.user)
            newTweet.twittuser.add(baseProfile)

            return HttpResponseRedirect(reverse("homepage"))

    form = TweetForm()

    return render(request, html, {"form": form})
Exemplo n.º 5
0
def make_tweet(request):
    if not request.user.is_authenticated:
        return HttpResponseRedirect(reverse('auth:log_in'))
    if request.POST:
        tweet = Tweet(title=request.POST['title'],
                      content=request.POST['content'],
                      user=request.user)
        tweet.save()
        return HttpResponseRedirect(
            reverse('tweet:show_tweet', args=(tweet.id, )))
    return render(request, 'tweet/make_tweet.html')
Exemplo n.º 6
0
 def post(self, request, username):
     form = TweetForm(request.POST)
     if form.is_valid():
         user = User.objects.get(username=username)
         tweet = Tweet(text=form.cleaned_data['text'], user=user, country=form.cleaned_data['country'])
         tweet.save()
         words = form.cleaned_data['text'].split(" ")
         for word in words:
             if word[0] == "#":
                 hashtag, created = HashTag.objects.get_or_create(name=word[1:])
                 hashtag.tweet.add(tweet)
     return HttpResponseRedirect('/user/'+username)
Exemplo n.º 7
0
def new_tweet_view(request):
    if request.method == 'POST':
        form = NewTweetForm(request.POST)
        if form.is_valid():
            content = form.cleaned_data['content']
            new_tweet = Tweet(
                content=content,
                composer=request.user
            )
            new_tweet.save()
            find_mention_notifications(new_tweet)
            return HttpResponseRedirect(
                reverse('homepage')
            )
Exemplo n.º 8
0
def crawl_tweets_for(username, since):
    for tweet in all_tweets_since(username, since):
        try:
            tweet_record = Tweet.objects.get(pk=tweet["id"])
            tweet_record.retweets = tweet["retweet_count"]
        except Tweet.DoesNotExist:
            tweet_data = {
                "tweet_id": tweet["id"],
                "text": tweet["text"],
                "created_at": tweet["created_at"],
                "retweets": tweet["retweet_count"],
                "username": UserTweet.objects.get(username=username),
            }
            tweet_record = Tweet(**tweet_data)
        tweet_record.save()
Exemplo n.º 9
0
def v2_tweet(request):
    token_hash = request.GET.get('key')
    if not token_hash:
        return HttpResponse('you did not send any key')
    try:
        token = TokenV2.objects.get(key=token_hash)
    except TokenV2.DoesNotExist:
        return HttpResponse('invalid key!')
    user = token.user
    # make tweet with request.GET and user and save it
    title = request.GET.get('title')
    content = request.GET.get('content')
    tweet = Tweet(title=title, content=content, user=user)
    tweet.save()
    return HttpResponse(tweet.title + " -- was created successfully ")
Exemplo n.º 10
0
 def save_tweets(self, public_tweets):
     for tweet in public_tweets:
         User.from_tweepy(tweet.author)
         for u in tweet.entities['user_mentions']:
             User.from_dict(u, api.get_user)
         t = Tweet.from_tweepy(tweet)
         print t.text.encode('utf8')
Exemplo n.º 11
0
 def post(self, request):
     try:
         data = json.loads(request.body)
         tweet = Tweet(user_id=data["user_id"],
                       user_content=data["user_content"])
         tweet.save()
         getpk = Tweet.objects.filter(user_id=data["user_id"]).last().pk
         return JsonResponse(
             {
                 "content_id": f"{getpk}",
                 "message": "Tweet Success"
             },
             safe=False,
             status=200)
     except KeyError:
         return JsonResponse({"message": "Tweet Failed"},
                             safe=False,
                             status=200)
Exemplo n.º 12
0
def saveresult(result,key,valeur):
	try :
		auteur = Auteur.objects.get(Nom=result['from_user_name'])
	except :
		auteur =  Auteur(Nom=result['from_user_name'])
		auteur.save()
	hashtags = extract_hash_tags(result["text"])
	

	tnom = Tweet(Auteur=auteur, Contenu=result["text"],TypeRecherche=key,Valeur=valeur)
	tnom.save()
	for h in hashtags :
		try :
			h1 = HashTag.objects.get(HashTag='#%s'%h)
		except :
			h1 = HashTag(HashTag='#%s'%h)
			h1.save()
		tnom.HashTag.add(h1)
	tnom.save()
Exemplo n.º 13
0
def add_tweet(request):
    """添加推文"""
    if request.method == 'POST':
        title = request.POST.get('title')
        content = request.POST.get('content')
        user_id = request.POST.get('user_id')
        t = Tweet()
        t.title = title
        t.content = content
        t.user_id = user_id
        t.read_num = gen_random_num()
        t.save()
        return JsonResponse({'code': 200, 'msg': 'success'})
Exemplo n.º 14
0
def save_tweets(raw_tweets):
    tweets_author = raw_tweets[0]['user']
    tweets_author_id = tweets_author['id']
    author_kwargs = {
        'author_id': tweets_author_id,
        'screen_name': tweets_author.get('screen_name'),
        'author_name': tweets_author.get('name'),
        # Stupid datetime...need to figure out how to parse
        # 'author_created': tweets_author.get('created_at'),
        'author_description': tweets_author.get('description')
    }
    # TO-DO: Figure out get_or_create on a variable but save with **kwargs
    try:
        author = Author.objects.get(author_id=tweets_author_id)
    except Author.DoesNotExist:
        author = Author(**author_kwargs)
        author.save()

    for tweet in raw_tweets:
        tweet_id = tweet['id']
        tweet_kwargs = {
            'tweet_id': tweet_id,
            'author': author,
            'content': tweet['text'],
            # date_published: tweet['created_at'],
            'date_published': datetime.datetime.now(),
            'coordinates': tweet.get('coordinates'),
            # Hashtags and user_mentinos TO BE IMPLEMENTED
            # 'user_mentions': tweet['entities'].get('user_mentions'),
            # hashtags: TO BE IMPLEMENTED
        }
        try:
            our_tweet = Tweet.objects.get(tweet_id=tweet_id)
        except Tweet.DoesNotExist:
            our_tweet = Tweet(**tweet_kwargs)
            our_tweet.save()

    return
Exemplo n.º 15
0
def create_tweet(request):
    if request.method=='POST':
        message=request.POST['message']
        profile_obj=Profile.objects.get(user=request.user)
        t_obj=Tweet()
        t_obj.profile=profile_obj
        t_obj.message=message
        t_obj.save()
        return HttpResponseRedirect(reverse('index'))
    else:
        form=CreateTweet()
        return render(request,'tweet/create_tweet.html',{'form':form})
Exemplo n.º 16
0
def feed(request):
    if request.method == 'POST':
        form = TweetForm(request.POST, request.FILES)
        if form.is_valid():
            tweet = Tweet()
            tweet.content = form.cleaned_data['tweet']
            tweet.image = form.cleaned_data.get('image')
            tweet.user = request.user
            tweet.save()
            form = TweetForm()
    else:
        form = TweetForm()
    tweets = Tweet.objects.order_by('-post_date')
    context = {
        'tweets': tweets,
        'form': form,
        'user': request.user,
    }
    return render(request, "tweet/feed.html", context)
Exemplo n.º 17
0
 def post(self,request):
     tweet_input = json.loads(request.body)
     user_id = tweet_input['user_id']
     tweet_content = tweet_input['tweet']
     Tweet(tweet = tweet_content, user_id = User.objects.get(id=user_id)).save()
     return JsonResponse({ 'tweet_content': tweet_content })
Exemplo n.º 18
0
    def get_queryset(self):
        #expressão de busca enviada
        expression = self.request.query_params.get('search')

        if (expression):
            #codifica a expressão para o padrão utilizado na web
            search_word = requests.utils.quote(expression)

            API_KEY = '5MU3Vu3zXm6xn0XQuIZzg2Q1I'
            API_SECRET = 'huaphtigFjD0riKGuT9rZHig6RCCr0zR7eeBsNvZtldcXCYnQz'
            ACCESS_TOKEN = '27258579-r6APNk6Y1mracJWcdAln3C6NsC5hj9dZKG8G2f654'
            ACCESS_TOKEN_SECRET = 'ulF8lFGppaeqEoA7TS17IGAnCMYjsI8QinyGLTI8uCQHP'

            session = OAuth1Session(API_KEY, API_SECRET, ACCESS_TOKEN,
                                    ACCESS_TOKEN_SECRET)

            url = "https://api.twitter.com/1.1/search/tweets.json?lang=pt&q=" + search_word + "&count=30&tweet_mode=extended"

            response = session.get(url)

            tweets = json.loads(response.content.decode('utf-8'))

            #armazena os dados dos usuarios
            user_data = []
            #armazena os tweets dos usuários para posterior classificação
            user_tweets = []

            for t in tweets['statuses']:
                #converte a data para o timezone do Brasil
                d = datetime.strptime(
                    t['created_at'], '%a %b %d %H:%M:%S %z %Y').replace(
                        tzinfo=timezone.utc).astimezone(
                            pytz.timezone('America/Sao_Paulo')).strftime(
                                '%Y-%m-%d %H:%M:%S')
                data = {
                    "data": d,
                    "username": t['user']['screen_name'],
                    "tweet_id": t['id'],
                    "tweet": t['full_text']
                }
                user_data.append(data)
                user_tweets.append(t['full_text'])

            #carrega o modelo gravado em arquivo
            text_clf = pickle.load(
                open(settings.MEDIA_ROOT + "/model.sav", 'rb'))

            #classifica os tweets
            predicted = text_clf.predict(user_tweets)

            #salva o termo de busca
            search = Search()
            search.expression = expression
            search.save()

            for x in range(len(predicted)):
                user_model = Tweet()
                user_model.user = user_data[x]['username']
                user_model.tweet_date = user_data[x]['data']
                user_model.tweet_id = user_data[x]['tweet_id']
                user_model.tweet_text = user_data[x]['tweet']
                user_model.classification = predicted[x]
                user_model.search = search
                user_model.save()

            return Tweet.objects.filter(search=search)

        elif (self.request.query_params.get('search_id')):
            search_id = self.request.query_params.get('search_id')
            return Tweet.objects.filter(search=search_id)

        else:
            return Tweet.objects.all()
Exemplo n.º 19
0
def crawl(request, username=None):
    Tweet.crawl_for(username)
    return HttpResponse("OK")
Exemplo n.º 20
0
def crawl(request, username=None):
    """Given some twitter username get all the tweets since some specific date"""
    Tweet.crawl_for(username)
    return HttpResponse("OK")
Exemplo n.º 21
0
def create_tweet(user_id, mutter):
    tweet = Tweet(tweeted_by_id=user_id, mutter=mutter)
    tweet.save()
    return tweet