def search_hashtags(search_query):
result = {}
json_data = raw_to_json(Hashtag.search(search_query.replace("&", " ").split())[0])
result[search_query] = json_data
json_data = raw_to_json(Hashtag.search(search_query.replace("&", " ").split())[1])
result[search_query+"_or"] = json_data
return jsonify(result)
def search(search_query):
search_query_strings = search_query.replace("&", " ").split()
json_data = {
"tweets" : raw_to_json(Tweet.search(search_query_strings)[0]),
"tweets_or": raw_to_json(Tweet.search(search_query_strings)[1]),
"hashtags" : raw_to_json(Hashtag.search(search_query_strings)[0]),
"hashtags_or": raw_to_json(Hashtag.search(search_query_strings)[1])
}
return jsonify(json_data)
def createCivi(request):
'''
USAGE:
use this function to insert a new connected civi into the database.
Text POST:
group
creator
topic
category
title
body
type
reference (optional)
at (optional)
and_negative (optional)
and_positive (optional)
:return: (200, ok) (400, missing required parameter) (500, internal error)
'''
civi = Civi()
data = {
'group_id': request.POST.get('group', ''),
'creator_id': request.POST.get('creator', ''),
'topic_id': request.POST.get('topic', ''),
'title': request.POST.get('title', ''),
'body': request.POST.get('body', ''),
'type': request.POST.get('type', ''),
'visits': 0,
'votes_neutral': 0,
'votes_positive1': 0,
'votes_positive2': 0,
'votes_negative1': 0,
'votes_negative2': 0,
'reference_id': request.POST.get('reference', ''),
'at_id': request.POST.get('at', ''),
'and_negative_id': request.POST.get('and_negative', ''),
'and_positive_id': request.POST.get('and_positive', ''),
}
try:
civi = Civi(**data)
hashtags = request.POST.get('hashtags', '')
split = [x.strip() for x in hashtags.split(',')]
for str in split:
if not Hashtag.objects.filter(title=str).exists():
hash = Hashtag(title=str)
hash.save()
else:
hash = Hashtag.objects.get(title=str)
civi.hashtags.add(hash.id)
civi.save()
return HttpResponse()
except Exception as e:
return HttpResponseServerError(reason=str(e))
def new_hashtags(self, status):
t = self.tweet_ctrl.get_tweet(status.id)
return [
Hashtag(tweet=t, hashtag=ht['text'])
for ht in status.entities['hashtags']
]
def test_get_kweek_hashtags():
query = " SELECT ID FROM KWEEK WHERE USERNAME = '******' LIMIT 1"
kweek_id = db_manager.execute_query(query)[0]['id']
actual_hashtag = actions.get_kweek_hashtags(kweek_id)[0]
query = "SELECT ID FROM HASHTAG WHERE TEXT='trend' LIMIT 1"
hashtag_id = db_manager.execute_query(query)[0]['id']
expected_hashtag = Hashtag({
'id': hashtag_id,
'indices': [25, 30],
'text': 'trend'
})
assert isinstance(expected_hashtag, Hashtag)
assert actual_hashtag.to_json() == expected_hashtag.to_json()
query = "SELECT ID FROM KWEEK WHERE USERNAME = '******' LIMIT 1"
kweek_id = db_manager.execute_query(query)[0]['id']
hashtags = actions.get_kweek_hashtags(kweek_id)
assert hashtags == []
def extract_hash_tags(tmp_tweet):
set_of_hastags = set(part[1:] for part in tmp_tweet.text.split() if part.startswith('#'))
for hashtag in set_of_hastags:
# check if hashtag already exists
hashtag_object = None
relate_hastag_to_tweet = None
try:
# look if there's already the hastag in the db
hashtag_object = Hashtag.objects.get(name=hashtag)
except:
# if there isn't create a new hastag object in the db
hashtag_object = Hashtag(name=hashtag, type=2, mentioned=0)
hashtag_object.save()
# create a new relationship between the hashtag and the tweet
relate_hastag_to_tweet = TweetRelatedHashtags(tweet=tmp_tweet, hashtag=hashtag_object)
relate_hastag_to_tweet.save()
# update number of mentions for this hashtag
update_number_of_mentions(hashtag_object)
def _store_hashtags(self, model_instance, hashtags):
for hashtag in hashtags:
h = Hashtag()
if model_instance.__class__.__name__ == "Reply":
h.reply = model_instance
elif model_instance.__class__.__name__ == "TrumpStatus":
h.trump_status = model_instance
else:
h.retweet = model_instance
h.hashtag = hashtag['text']
h.save()
def addCivi(request):
'''
takes in civi info and adds it to the database
:param request:
:return:
'''
civi = Civi()
civi.id = Civi.objects.all().order_by("-id")[0].id + 1
civi.author_id = request.POST.get('author_id', '')
civi.article_id = request.POST.get('article_id', '')
civi.title = request.POST.get('title', '')
civi.body = request.POST.get('body', '')
civi.type = request.POST.get('type', '')
civi.REFERENCE_id = request.POST.get('reference_id', '')
civi.AT_id = request.POST.get('at_id', '')
civi.AND_NEGATIVE_id = request.POST.get('and_negative_id', '')
civi.AND_POSITIVE_id = request.POST.get('and_positive_id', '')
civi.save()
hashtags = request.POST.get('hashtags', '')
split = [x.strip() for x in hashtags.split(',')]
for str in split:
if len(Hashtag.objects.filter(title=str)) == 0:
hash = Hashtag(title=str)
hash.save()
else:
hash = Hashtag.objects.filter(title=str)[0]#get the first element
civi.hashtags.add(hash.id)
civi.save()
return JsonResponse({'result': 'success'})
def save_question_from_form(qForm, user): if qForm.is_valid(): title = qForm.cleaned_data['title'] text = qForm.cleaned_data['text'] date = datetime.now() author = user q = Question(title=title, text=text, timeStamp=date #author=Profile.objects.get(user=author.id).id ) q.save() for tag in qForm.cleaned_data['tags']: try: htag = Hashtag.objects.get(tag=tag) q.hashtags.add(htag) except Hashtag.DoesNotExist: htag = Hashtag(tag=tag) htag.save() q.hashtags.add(htag) q.save() return True else: return False
def show_hashtags():
if "user_id" not in session:
flash("Please Login First!", "danger")
return redirect("/")
form = HashtagForm()
all_hashtags = Hashtag.query.all()
if form.validate_on_submit():
text = form.text.data
new_hashtag = Hashtag(text=text, user_id=session["user_id"])
db.session.add(new_hashtag)
db.session.commit()
flash("Hashtag Created!" "success")
return redirect("/hashtags")
return render_template("hashtags.html", form=form, hashtags=all_hashtags)
def get_kweek_hashtags(kweek_id):
"""
Gets the hashtags in a given kweek.
*Parameters:*
- *kweek_id (int)*: The id of the kweek.
*Returns:*
- *List of models.Hashtag objects*
"""
database_hashtags = query_factory.get_kweek_hashtags(kweek_id)
hashtags = []
for database_hashtag in database_hashtags:
hashtag = {
'id': database_hashtag['hashtag_id'],
'indices': [database_hashtag['starting_index'], database_hashtag['ending_index']],
'text': database_hashtag['text']
}
hashtags.append(Hashtag(hashtag))
return hashtags
def agregar_hashtag(request):
if request.method == 'POST':
if request.POST.get('hashtag',False):
h = True
else:
h = False
if request.POST.get('dias',False):
try:
dias = int(request.POST.get('dias'))
except:
dias = 7
else:
return redirect('/')
a = Hashtag(nombre=request.POST['cuenta'], hashtag = h)
a.save()
a.hasta = a.creado + timedelta(days=dias)
a.save()
return redirect('/')
assert message == 'success'
query: str = """SELECT COUNT(*) FROM HASHTAG """
third_count = db_manager.execute_query(query)[0]['count']
assert third_count - second_count == 0
check, message = actions.insert_kweek(kweek_test_3)
assert message == 'Repeated mention in the same kweek'
check, message = actions.insert_kweek(kweek_test_4)
assert message == 'the user mentioned does not exist in the database'
@pytest.mark.parametrize("text, expected_hashtags, expected_mentions",
[
('#hashtag and @mention',
[Hashtag({'indices': (0, 8), 'text': '#hashtag', 'id': 0})],
[Mention({'indices': (13, 21), 'username': '******'})]),
('#hashtag and @mention ',
[Hashtag({'indices': (0, 8), 'text': '#hashtag', 'id': 0})],
[Mention({'indices': (13, 21), 'username': '******'})]),
('@mention and #hashtag',
[Hashtag({'indices': (13, 21), 'text': '#hashtag', 'id': 0})],
[Mention({'indices': (0, 8), 'username': '******'})]),
('@mention and #hashtag ',
[Hashtag({'indices': (13, 21), 'text': '#hashtag', 'id': 0})],
[Mention({'indices': (0, 8), 'username': '******'})]),
('@mention and # ',
[Hashtag({'indices': (13, 14), 'text': '#', 'id': 0})],
[Mention({'indices': (0, 8), 'username': '******'})]),
('@mention and #',
[],
p = multiprocessing.Process(target=self.store_json_data,
args=(self.json_data_list[:], ))
self.json_data_list = []
p.start()
def on_error(self, status_code):
print('Got an error with status code: ' + str(status_code))
if __name__ == '__main__':
from keys import *
try:
Reply.create_table()
Retweet.create_table()
Hashtag.create_table()
TrumpStatus.create_table()
print("New tables made")
except:
print("Table/s already exist")
auth = tweepy.OAuthHandler(twitter_consumer_key, twitter_consumer_secret)
auth.set_access_token(twitter_access_token, twitter_access_token_secret)
tweepy_api = tweepy.API(auth)
TwitterStreamListener = TwitterStreamListener(TrumpTwitterAnalyzer())
twitterStream = tweepy.Stream(auth=tweepy_api.auth,
listener=TwitterStreamListener)
trump_twitter_id = "25073877"
networks_group_id = "804836955485859841" # for testing on our account @networks_group
twitterStream.filter(follow=[trump_twitter_id], stall_warnings=True)
def test_get_kweek_with_replies():
# first kweek #
query: str = """INSERT INTO KWEEK (CREATED_AT,TEXT,MEDIA_URL,USERNAME,REPLY_TO) VALUES(%s, %s, %s, %s,%s) """
data = ('01-01-2010', 'test1', None, 'test_user1', None)
db_manager.execute_query_no_return(query, data)
kid1 = str(db_manager.execute_query("""SELECT ID FROM KWEEK ORDER BY ID DESC LIMIT 1 """)[0]['id'])
query: str = """INSERT INTO HASHTAG(TEXT) VALUES (%s) """
data = ('hashtag1---',)
db_manager.execute_query_no_return(query, data)
query: str = """SELECT ID FROM HASHTAG WHERE TEXT = %s """
data = ('hashtag1---',)
hid1 = db_manager.execute_query(query, data)[0]['id']
query: str = """INSERT INTO KWEEK_HASHTAG VALUES (%s,%s,%s,%s)"""
data = (kid1, hid1, 0, 9,)
db_manager.execute_query_no_return(query, data)
query: str = """INSERT INTO MENTION VALUES(%s,%s,%s,%s) """
data = (kid1, 'test_user2', 10, 15)
db_manager.execute_query_no_return(query, data)
query: str = """INSERT INTO REKWEEK VALUES(%s,%s,%s) """
data = ('test_user2', kid1, '01-01-2010')
db_manager.execute_query_no_return(query, data)
query: str = """INSERT INTO FAVORITE VALUES(%s,%s,%s) """
data = ('test_user2', kid1, '01-01-2010')
db_manager.execute_query_no_return(query, data)
# second kweek #
query: str = """INSERT INTO KWEEK (CREATED_AT,TEXT,MEDIA_URL,USERNAME,REPLY_TO) VALUES(%s, %s, %s, %s,%s) """
data = ('01-01-2010', 'test2', None, 'test_user2', kid1)
db_manager.execute_query_no_return(query, data)
kid2 = str(db_manager.execute_query("""SELECT ID FROM KWEEK ORDER BY ID DESC LIMIT 1 """)[0]['id'])
query: str = """INSERT INTO HASHTAG(TEXT) VALUES (%s) """
data = ('hashtag2---',)
db_manager.execute_query_no_return(query, data)
query: str = """SELECT ID FROM HASHTAG WHERE TEXT = %s """
data = ('hashtag2---',)
hid2 = db_manager.execute_query(query, data)[0]['id']
query: str = """INSERT INTO KWEEK_HASHTAG VALUES (%s,%s,%s,%s)"""
data = (kid2, hid2, 0, 9,)
db_manager.execute_query_no_return(query, data)
query: str = """INSERT INTO FAVORITE VALUES(%s,%s,%s) """
data = ('test_user1', kid2, '01-01-2010')
db_manager.execute_query_no_return(query, data)
# third kweek #
query: str = """INSERT INTO KWEEK (CREATED_AT,TEXT,MEDIA_URL,USERNAME,REPLY_TO) VALUES(%s, %s, %s, %s,%s) """
data = ('01-01-2010', 'test3', None, 'test_user3', kid1)
db_manager.execute_query_no_return(query, data)
kid3 = str(db_manager.execute_query("""SELECT ID FROM KWEEK ORDER BY ID DESC LIMIT 1 """)[0]['id'])
query: str = """INSERT INTO HASHTAG(TEXT) VALUES (%s) """
data = ('hashtag3---',)
db_manager.execute_query_no_return(query, data)
query: str = """SELECT ID FROM HASHTAG WHERE TEXT = %s """
data = ('hashtag3---',)
hid3 = db_manager.execute_query(query, data)[0]['id']
query: str = """INSERT INTO KWEEK_HASHTAG VALUES (%s,%s,%s,%s)"""
data = (kid3, hid3, 0, 9,)
db_manager.execute_query_no_return(query, data)
query: str = """INSERT INTO FAVORITE VALUES(%s,%s,%s) """
data = ('test_user3', kid3, '01-01-2010')
db_manager.execute_query_no_return(query, data)
kweek_test1 = Kweek({
'id': int(kid1),
'created_at': datetime(2010, 1, 1, 0, 0),
'text': 'test1',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test1',
'profile_image_url': 'image_url',
'following': True,
'follows_you': True,
'muted': False,
'blocked': False
}),
'mentions': [
Mention({
'username': '******',
'indices': [10, 15]})
],
'hashtags': [
Hashtag({
'text': 'hashtag1---',
'indices': [0, 9],
'id': hid1
})
],
'number_of_likes': 1,
'number_of_rekweeks': 1,
'number_of_replies': 2,
'reply_to': None,
'rekweek_info': None,
'liked_by_user': False,
'rekweeked_by_user': False
})
replies_test1 = [
Kweek({
'id': int(kid2),
'created_at': datetime(2010, 1, 1, 0, 0),
'text': 'test2',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test2',
'profile_image_url': 'image_url',
'following': False,
'follows_you': True,
'muted': False,
'blocked': False
}),
'mentions': [
],
'hashtags': [
Hashtag({
'text': 'hashtag2---',
'indices': [0, 9],
'id': hid2
})
],
'number_of_likes': 1,
'number_of_rekweeks': 0,
'number_of_replies': 0,
'reply_to': int(kid1),
'rekweek_info': None,
'liked_by_user': False,
'rekweeked_by_user': False
}), Kweek({
'id': int(kid3),
'created_at': datetime(2010, 1, 1, 0, 0),
'text': 'test3',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test3',
'profile_image_url': 'image_url',
'following': False,
'follows_you': False,
'muted': False,
'blocked': False
}),
'mentions': [
],
'hashtags': [
Hashtag({
'text': 'hashtag3---',
'indices': [0, 9],
'id': hid3
})
],
'number_of_likes': 1,
'number_of_rekweeks': 0,
'number_of_replies': 0,
'reply_to': int(kid1),
'rekweek_info': None,
'liked_by_user': True,
'rekweeked_by_user': False
}),
]
check_replies, message, k, r = actions.get_kweek_with_replies(kid1, 'test_user3')
print('kwweeek')
print(k)
print('replies')
print(r)
assert True == check_replies
assert message == 'success'
assert k.to_json() == kweek_test1.to_json()
for n, i in enumerate(r):
assert i.to_json() == replies_test1[n].to_json()
def get_kweek(kid, authorized_username, replies_only):
"""
Get the requested kweek with its credentials.
*Parameters:*
- *kid*: The id of the kweek to be retrieved.
- *authorized_username(string)*: The user currently logged in.
- *replies_only (bool)*: To indicate whether the kweek with its replies
is to be retrieved or the replies only
*Returns:*
-*Tuple*: {
| *check (bool)*: To indicate whether kweek credentials creation
| was successful or not.,
| *message (str)*: To specify the reason of failure if detected.
| *kweekobj (kweek object )*: the kweek to be retrieved,
| *replies (list of int )*: Ids of the replies to the retrieved kweek .
| *code*: The code to be returned in the request.
| }
"""
check, message, code = validate_request(kid)
if not check:
return check, message, None, None, code
replies = retrieve_replies(
kid
) # rows of kweek table who is set as a reply to the retrieved kweek (ids)
if replies_only:
return True, message, None, replies, code
hashtags = retrieve_hashtags(kid) # rows of hahstag-kweek table (*)
mentions = retrieve_mentions(kid) # rows of mention table (*)
rekweeks = retrieve_user(kid, 3)
likers = retrieve_user(
kid,
2) # rows of likers table for those who liked the kweek (usernames)
user = retrieve_user(kid, 1)
hashtags_list = [] # list of hashtag objects
mentions_list = [] # list of mention objects
rekweeked_by_user = False
liked_by_user = False
if hashtags:
for hash_obj in hashtags:
hid = hash_obj['hashtag_id']
s_index = hash_obj['starting_index']
e_index = hash_obj['ending_index']
indices = [s_index, e_index]
text = hash_obj['text']
hash_dic = {'id': hid, 'indices': indices, 'text': text}
hashtag = Hashtag(hash_dic)
hashtags_list.append(hashtag)
if mentions:
for ment in mentions:
s_index = ment['starting_index']
e_index = ment['ending_index']
indices = [s_index, e_index]
username = ment['username']
ment_dic = {'indices': indices, 'username': username}
mention = Mention(ment_dic)
mentions_list.append(mention)
user = user[0]
extrauser = {}
me = authorized_username # should be replaced by the function getting the current user
check = check_following(me, user['username'])
if check:
extrauser['following'] = True
else:
extrauser['following'] = False
check = check_following(user['username'], me)
if check:
extrauser['follows_you'] = True
else:
extrauser['follows_you'] = False
check = check_blocked(user['username'], me)
if check:
extrauser['blocked'] = True
else:
extrauser['blocked'] = False
check = check_muted(user['username'], me)
if check:
extrauser['muted'] = True
else:
extrauser['muted'] = False
extrauser.update(user)
userobj = User(extrauser)
if replies:
num_of_replies = len(replies)
else:
num_of_replies = 0
if likers:
num_of_likes = len(likers)
for user in likers:
if user['username'] == me:
liked_by_user = True
else:
num_of_likes = 0
if rekweeks:
num_of_rekweeks = len(rekweeks)
for user in rekweeks:
if user['username'] == me:
rekweeked_by_user = True
else:
num_of_rekweeks = 0
kweekdic = {
'hashtags': hashtags_list,
'mentions': mentions_list,
'number_of_likes': num_of_likes,
'number_of_rekweeks': num_of_rekweeks,
'number_of_replies': num_of_replies,
'rekweek_info': None,
'liked_by_user': liked_by_user,
'rekweeked_by_user': rekweeked_by_user,
'user': userobj
}
kweek = retrieve_kweek(kid) # a row of kweek table
kweek = kweek[0]
kweekdic.update(kweek)
kweekdic['reply_info'] = get_reply_to_info(kid)
kweekobj = Kweek(kweekdic)
return True, 'success.', kweekobj, replies, 200
def extract_mentions_hashtags(text):
"""
Extract mentions and replies for the given kweek.
*Parameters:*
- *text*: The text of the kweek to be inserted .
*Returns:*
-*Tuple*: {
| *hashtags (hashtag object )*: The list of kweek hashtags,
| *mention (mention object )*: The list of kweek mentions.
| }
"""
hashtags = []
mentions = []
size = len(text)
i = 0
while i < size:
hashtag_indices_list = []
mention_indices_list = []
if text[i] == '#':
hashtag_indices_list.append(i)
for i in range(i + 1, len(text)):
if (i == size - 1 and text[i] == ' ') or text[i] == ' ':
hashtag_indices_list.append(i)
elif i == size - 1:
hashtag_indices_list.append(i + 1)
else:
continue
hashtag_text = text[
hashtag_indices_list[0]:hashtag_indices_list[1]]
hashtag = {
'indices': hashtag_indices_list,
'text': hashtag_text,
'id': 0
}
hashtags.append(Hashtag(hashtag))
break
if text[i] == '@':
mention_indices_list.append(i)
for i in range(i + 1, len(text)):
if (i == size - 1 and text[i] == ' ') or text[i] == ' ':
mention_indices_list.append(i)
elif i == size - 1:
mention_indices_list.append(i + 1)
else:
continue
mention_username = text[mention_indices_list[0] +
1:(mention_indices_list[1])]
mention = {
'indices': mention_indices_list,
'username': mention_username
}
mentions.append(Mention(mention))
break
i += 1
return hashtags, mentions # lists of objects
def test_insert_kweek():
kweek_test_1 = Kweek({
'id': 0,
'created_at': datetime.utcnow(),
'text': '#test1',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test1',
'profile_image_url': 'image_url',
'following': False,
'follows_you': False,
'muted': False,
'blocked': False
}),
'mentions': [
Mention({
'username': '******',
'indices': [10, 16]}),
Mention({
'username': '******',
'indices': [18, 20]},
)
],
'hashtags': [
Hashtag({
'text': '#sky',
'indices': [10, 16],
'id': 0
})
],
'number_of_likes': 0,
'number_of_rekweeks': 0,
'number_of_replies': 0,
'reply_to': None,
'rekweek_info': None,
'liked_by_user': False,
'rekweeked_by_user': False
})
kweek_test_2 = Kweek({
'id': 0,
'created_at': datetime.utcnow(),
'text': '#test2',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test1',
'profile_image_url': 'image_url',
'following': False,
'follows_you': False,
'muted': False,
'blocked': False
}),
'mentions': [
Mention({
'username': '******',
'indices': [10, 16]}),
Mention({
'username': '******',
'indices': [18, 20]})
],
'hashtags': [
Hashtag({
'text': '#sky',
'indices': [10, 16],
'id': 0
})
],
'number_of_likes': 0,
'number_of_rekweeks': 0,
'number_of_replies': 0,
'reply_to': None,
'rekweek_info': None,
'liked_by_user': False,
'rekweeked_by_user': False
})
kweek_test_3 = Kweek({
'id': 0,
'created_at': datetime.utcnow(),
'text': '#test3',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test1',
'profile_image_url': 'image_url',
'following': False,
'follows_you': False,
'muted': False,
'blocked': False
}),
'mentions': [
Mention({
'username': '******',
'indices': [10, 16]}),
Mention({
'username': '******',
'indices': [18, 20]},
)
],
'hashtags': [
Hashtag({
'text': '#sky',
'indices': [10, 16],
'id': 0
})
],
'number_of_likes': 0,
'number_of_rekweeks': 0,
'number_of_replies': 0,
'reply_to': None,
'rekweek_info': None,
'liked_by_user': False,
'rekweeked_by_user': False
})
kweek_test_4 = Kweek({
'id': 0,
'created_at': datetime.utcnow(),
'text': '#test1',
'media_url': None,
'user': User({
'username': '******',
'screen_name': 'test1',
'profile_image_url': 'image_url',
'following': False,
'follows_you': False,
'muted': False,
'blocked': False
}),
'mentions': [
Mention({
'username': '******',
'indices': [10, 16]}),
Mention({
'username': '******',
'indices': [18, 20]},
)
],
'hashtags': [
Hashtag({
'text': '#sky',
'indices': [10, 16],
'id': 0
})
],
'number_of_likes': 0,
'number_of_rekweeks': 0,
'number_of_replies': 0,
'reply_to': None,
'rekweek_info': None,
'liked_by_user': False,
'rekweeked_by_user': False
})
query: str = """SELECT ID FROM HASHTAG WHERE TEXT=%s """
data = ('#sky',)
hid = db_manager.execute_query(query, data)
if len(hid) != 0:
query: str = """DELETE FROM HASHTAG WHERE ID=%s """
data = (hid[0]['id'],)
db_manager.execute_query_no_return(query, data)
query: str = """DELETE FROM KWEEK_HASHTAG WHERE HASHTAG_ID=%s """
data = (hid[0]['id'],)
db_manager.execute_query_no_return(query, data)
query: str = """SELECT COUNT(*) FROM HASHTAG """
first_count = db_manager.execute_query(query)[0]['count']
actions.insert_kweek(kweek_test_1)
query: str = """SELECT ID FROM KWEEK ORDER BY ID DESC LIMIT 1 """
kid = db_manager.execute_query(query)[0]['id']
print("kweek id", kid)
query: str = """SELECT ID FROM HASHTAG ORDER BY ID DESC LIMIT 1 """
hid = db_manager.execute_query(query)[0]['id']
print("hahstag id ", hid)
query: str = """SELECT ID,TEXT,media_url,username,reply_to FROM KWEEK WHERE ID= %s """
data = (kid,)
resulted_kweek = db_manager.execute_query(query, data)[0]
print("kweek", resulted_kweek)
query: str = """SELECT * FROM MENTION WHERE KWEEK_ID= %s"""
data = (kid,)
resulted_mention = db_manager.execute_query(query, data)[0]
query: str = """SELECT TEXT, KWEEK_ID, HASHTAG_ID, STARTING_INDEX, ENDING_INDEX
FROM KWEEK_HASHTAG JOIN HASHTAG ON ID = HASHTAG_ID WHERE KWEEK_ID = %s"""
data = (kid,)
resulted_hashtag = db_manager.execute_query(query, data)[0]
print("hashtag", resulted_hashtag)
expected_mention = {'kweek_id': kid, 'username': '******', 'starting_index': 10,
'ending_index': 16}
expected_hahstag = {'text': '#sky', 'kweek_id': kid, 'hashtag_id': hid,
'starting_index': 10, 'ending_index': 16}
expected_kweek = {'id': kid, 'text': '#testtest',
'media_url': None, 'username': '******', 'reply_to': None}
assert expected_kweek == resulted_kweek
assert expected_hahstag == resulted_hashtag
assert expected_mention == resulted_mention
query: str = """SELECT COUNT(*) FROM HASHTAG """
second_count = db_manager.execute_query(query)[0]['count']
assert (second_count - first_count) == 1
check, message = actions.insert_kweek(kweek_test_2)
assert message == 'success'
query: str = """SELECT COUNT(*) FROM HASHTAG """
third_count = db_manager.execute_query(query)[0]['count']
assert third_count - second_count == 0
check, message = actions.insert_kweek(kweek_test_3)
assert message == 'Repeated mention in the same kweek'
check, message = actions.insert_kweek(kweek_test_4)
assert message == 'the user mentioned does not exist in the database'
