def user(request, format=None):
"""
(POST): Users are created upon successful (federated) login, so no create user functionality is provided
GET: Retrieve a list of users that are the administrators of the domain
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP", status=status.HTTP_401_UNAUTHORIZED)
try:
service_user = User.objects.get(username=request.user)
except User.DoesNotExist:
# service_user = None
return Response("User is unknown :"+request.user, status=status.HTTP_400_BAD_REQUEST)
if request.method == 'GET':
# get academic entity from user name
academic = service_user.last_name
# get all users for the defined academic entity
user_list = User.objects.all().filter(last_name=academic)
result_list = []
for user_item in user_list:
result = {'username': user_item.username, 'name': user_item.first_name, 'email': user_item.email,
'domain': user_item.last_name, 'date_joined': user_item.date_joined}
result_list.append(result)
if result_list:
return Response(result_list, status=status.HTTP_200_OK)
else:
return Response("user list not found", status=status.HTTP_400_BAD_REQUEST)
def history_id(request, history_id, format=None):
"""
Retrieve history items for specific id
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
print "retrieve histroy item "
hist_asynch = get_history_item.delay(history_id)
# hist_asynch = get_all_history.delay()
hist_list = hist_asynch.get()
print "retrieve one hist_list " + str(hist_list)
# results = {"history"+queryid};
return Response(hist_list, status=status.HTTP_200_OK)
if request.method == 'DELETE':
print "DELETE histroy item "
hist_asynch = delete_history.delay(history_id)
# hist_asynch = get_all_history.delay()
delete_result = hist_asynch.get()
print "delete one hist " + str(delete_result)
# results = {"history"+queryid};
return Response(delete_result, status=status.HTTP_200_OK)
def cat_suggestions(request, keyword, format=None):
"""
Retrieve related keywords
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
# try:
# service_user = User.objects.get(username=request.user)
# except User.DoesNotExist:
# # service_user = None
# return Response("User is unknown :"+request.user, status=status.HTTP_400_BAD_REQUEST)
#
# if valid_user(service_user, lsname) is False:
# return Response("User:"******" is not authorised to manage LS:"+str(lsname),
# status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
cat_suggestions_asynch = get_cat_suggestions.delay(keyword)
return Response(cat_suggestions_asynch.get(),
status=status.HTTP_200_OK)
def gtrends(request, keyword, location, category, format=None):
"""
Retrieve interest for one term
Numbers represent search interest relative to the highest point on the
chart for the given region and time. A value of 100 is the peak popularity
for the term. A value of 50 means that the term is half as popular. Likewise
a score of 0 means the term was less than 1% as popular as the peak.
if no timeframe is specified initial date is : 2012-07-01, until: today
interest index / per week.
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
# try:
# service_user = User.objects.get(username=request.user)
# except User.DoesNotExist:
# # service_user = None
# return Response("User is unknown :"+request.user, status=status.HTTP_400_BAD_REQUEST)
#
# if valid_user(service_user, lsname) is False:
# return Response("User:"******" is not authorised to manage LS:"+str(lsname),
#
if request.method == 'GET':
print keyword, location, category
get_gtrends_asynch = get_gtrends.delay(keyword, location, category)
print "get_gtrends_asynch: " + str(get_gtrends_asynch.get())
return Response(get_gtrends_asynch.get(), status=status.HTTP_200_OK)
def username_mgmt(request, username, format=None):
"""
GET: Retrieve details for one user
DELETE: Delete specified user ..
"""
ip_address = request.META['REMOTE_ADDR']
print "delete/get ip_address:"+ip_address
if valid_ip(ip_address) is False:
return Response("Not authorised client IP", status=status.HTTP_401_UNAUTHORIZED)
# verify that token corresponds to a valid user
try:
service_user = User.objects.get(username=request.user)
except User.DoesNotExist:
return Response("User token is unknown :"+request.user, status=status.HTTP_400_BAD_REQUEST)
# verify that username exist
try:
user_name = User.objects.get(username=username)
except User.DoesNotExist:
return Response("Username is unknown :"+str(username), status=status.HTTP_400_BAD_REQUEST)
# verify that service_user has the rights to manage the username
if user_name:
# academic domain of service_user should be the same as the managed user
user_domain = user_name.last_name
user_domain_ = user_domain.replace(".", "_")
service_user_domain = service_user.last_name
service_user_domain_ = service_user_domain.replace(".", "_")
if user_domain_ == service_user_domain_:
print "permission granted"
else:
return Response("Not sufficient rights to perform this action for: "+username,
status=status.HTTP_400_BAD_REQUEST)
if request.method == 'DELETE':
user_deleted = User.objects.get(username=username).delete()
if user_deleted is None:
return Response("user:"******" deleted", status=status.HTTP_200_OK)
else:
return Response("user:"******" not deleted", status=status.HTTP_400_BAD_REQUEST)
if request.method == 'GET':
# get academic entity from user name
# get all users for the defined academic entity
user_item = User.objects.get(username=username)
result = {}
if user_item:
result = {'username': user_item.username, 'name': user_item.first_name, 'email': user_item.email,
'domain': user_item.last_name, 'date_joined': user_item.date_joined}
return Response(result, status=status.HTTP_200_OK)
if not result:
return Response("user:"******" not found", status=status.HTTP_400_BAD_REQUEST)
def get_trends_location(request, place_id, format=None):
"""
Retrieve twitter trends for specified location
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP", status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
twitter_trends_location_asynch = get_tw_trends.delay(place_id)
# print "related_queries_asynch: " + str(twitter_trends_location_asynch.get())
return Response(twitter_trends_location_asynch.get(), status=status.HTTP_200_OK)
def user_token(request, format=None):
"""
Retrieve user's token based on the following attributes
{
"displayName": "John Doe",
"eduPersonPrincipalName": "*****@*****.**",
"eduPersonEntitlement": "admin",
"schacHomeOrganization": "ntua.gr"
}
the value in schacHomeOrganization will be utilised for the Logical System's name
user.first_name = display_name
user.last_name = domain
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP", status=status.HTTP_401_UNAUTHORIZED)
print("get_user_token: Retrieve user's token based on provided credentials")
# academicEntityList = {"ntua","uoa", "uoi"}
if request.method == 'POST':
display_name = request.data['displayName']
username = request.data['eduPersonPrincipalName']
role = request.data['eduPersonEntitlement']
domain = request.data['schacHomeOrganization']
# ip_addr = request.META['REMOTE_ADDR']
if role != "admin":
return Response("unnauthorised user", status=status.HTTP_401_UNAUTHORIZED)
# create user if not exist
# user = get_user_obj(username)
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
if user is None:
# print "create LS admin :"+username +" academic domain:" + domain
user = User.objects.create_user(username, email=username)
# academic = AcademicEntityAdmin(user, domain = domain)
user.first_name = display_name
domain_ = domain.replace(".", "_")
user.last_name = domain_
user.save()
# print "get token for:" + str(user)
token = Token.objects.get_or_create(user_id=user.id)
# print 'token:'+str(token)
stringtoken = str(token)
return Response({'token': stringtoken}, status=status.HTTP_200_OK)
def create_user(request):
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP", status=status.HTTP_401_UNAUTHORIZED)
username = request.data['username']
email = request.data['email']
password = request.data['password']
user = User.objects.create_user(username, email, password)
if user:
return Response(user.username, status=status.HTTP_201_CREATED)
else:
return Response("user not created", status=status.HTTP_400_BAD_REQUEST)
def history(request, format=None):
"""
Retrieve all history
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
# print "retrieve histroy"
hist_asynch = get_all_history.delay()
hist_list = hist_asynch.get()
# print("in1")
# print "retrieve hist_list " + str(hist_list)
return Response(hist_list, status=status.HTTP_200_OK)
def keywords_volume_query_id(request, keywd, query_id, format=None):
"""
Retrieve related queries
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
print "in view:" + str(keywd)
if request.method == 'GET':
related_keywords_asynch = get_keywords_volume.delay(
adwords_username, adwords_password, keywd, loc_name)
return Response(related_keywords_asynch.get(),
status=status.HTTP_200_OK)
def autocomplete(request, keyword, format=None):
"""
Get autocomplete questions...
:param request:
:param keyword:
:param format:
:return:
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
autocomplete_asynch = get_autocomplete.delay(keyword)
# print "trend_asynch: "+ trend_asynch
return Response(autocomplete_asynch.get(), status=status.HTTP_200_OK)
def query_params_mgmt_id(request, id, format=None):
"""
Manage "Query Parameters" by id
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
# try:
# service_user = User.objects.get(username=request.user)
# except User.DoesNotExist:
# # service_user = None
# return Response("User is unknown :"+request.user, status=status.HTTP_400_BAD_REQUEST)
#
# if valid_user(service_user, lsname) is False:
# return Response("User:"******" is not authorised to manage LS:"+str(lsname),
# status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'DELETE':
print "delete query_params by id in view "
deletion_status = delete_query_params_id.delay(id)
print "deletion_status:" + str(deletion_status)
# if deletion_status:
# return Response("query param deleted:" + id, status=status.HTTP_200_OK)
# else:
# return Response("query param not deleted:" + id, status=status.HTTP_400_BAD_REQUEST)
return Response("query param deleted:" + id, status=status.HTTP_200_OK)
if request.method == 'GET':
print "get query_params by id in view "
query_param = get_query_params_id.delay(id)
print "query_param:" + str(query_param)
return Response(query_param.get(), status=status.HTTP_200_OK)
def discover(request, queryid, format=None):
"""
Make integrated trends discovery
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
print "integrated trends discovery query id: " + queryid
start_time = time.time()
results = {}
# query_param = get_query_params_id.delay(id)
query_param = get_query_params_id(queryid)
print "query params:"
print query_param
description = query_param['description']
keyword = query_param['keywords']
location = query_param['location']
category = query_param['category']
youtube = query_param['youtube']
twitter = query_param['twitter']
google = query_param['google']
start_date = query_param['start_date']
end_date = query_param['end_date']
questions = query_param['questions']
inference = query_param['inference']
# sentiment = query_param['sentiment']
print "query_param keyword: " + keyword
if google:
get_gtrends_asynch = get_gtrends.delay(keyword, location, category,
start_date, end_date)
trends_results = get_gtrends_asynch.get()
print "## Retrieving get_related_queries ##"
related_queries_result_list = trends_results[
'related_queries_list']
print "## Retrieving time based interest ##"
time_interest_kw_dic = trends_results['time_interest_list']
print "## Retrieving region based interest ##"
region_interest_kw_dic = trends_results['interest_over_region']
## Retrieving adwords volume ##
print "## Retrieving adwords volume ## for " + keyword
volume_list = []
# Uncomment this !!!
adwords_username = account_repo.get_adwords_username()
adwords_password = account_repo.get_adwords_password()
keywords_volume_asynch = get_keywords_volume.delay(
adwords_username, adwords_password, keyword, location)
volume_dic = keywords_volume_asynch.get()
print "keyword volume ????"
print volume_dic
print "-------"
try:
for x in range(0, len(volume_dic)):
volume = {
"count": volume_dic[x]['count'],
"year": volume_dic[x]['year'],
"month": volume_dic[x]['month']
}
volume_list.append(volume)
except TypeError:
volume_list.append("none")
# Until here !!!
else:
volume_list = {}
related_queries_result_list = {}
time_interest_kw_dic = {}
region_interest_kw_dic = {}
if questions:
# retrieve autocomplete questions
print "## Retrieving autocomplete ##"
autocomplete_asynch = get_autocomplete.delay(keyword)
autocomplete_results = autocomplete_asynch.get()
print autocomplete_results
print "Retrieving autocomplete - finished"
else:
autocomplete_results = {}
# volume_list = [{'count': 450000, 'month': 8, 'year': 2017}, {'count': 673000, 'month': 7, 'year': 2017},
# {'count': 450000, 'month': 6, 'year': 2017}, {'count': 550000, 'month': 5, 'year': 2017},
# {'count': 673000, 'month': 4, 'year': 2017}, {'count': 823000, 'month': 3, 'year': 2017},
# {'count': 1000000, 'month': 2, 'year': 2017}, {'count': 1830000, 'month': 1, 'year': 2017},
# {'count': 2240000, 'month': 12, 'year': 2016}, {'count': 2240000, 'month': 11, 'year': 2016},
# {'count': 1830000, 'month': 10, 'year': 2016}, {'count': 3350000, 'month': 9, 'year': 2016}]
print "Retrieving adwords volume - finished"
print "## Retrieving twitter data ##"
if twitter:
# chain = (task1.s() | task2.s(r1) | task3.s(r2)).apply_async()
# get_tweets_term
# chain = (get_tweets_term.s(keyword,100) | get_tw_term(inference) ).apply_async()
auth = account_repo.get_twitter_auth()
api = API(auth)
number_of_tweets = 120
cricTweet = tweepy.Cursor(
api.search,
q=keyword,
tweet_mode='extended',
result_type='popular').items(number_of_tweets)
# gender inference
ans_list = {}
popular_tweets = []
tweet_sentiment_all = []
twitter_sentiment_top_result = []
# create dictionaries from initial tweets dataset
for tweet in cricTweet:
# gender
image_url = hq_image(tweet.user.profile_image_url_https)
ans_list[tweet.user.id_str] = (tweet.user.name, image_url)
# sentiment
tweet_sentiment = {}
tweet_sentiment["user"] = tweet.user.name
tweet_sentiment["text"] = tweet.full_text
tweet_sentiment["favs"] = tweet.favorite_count
tweet_sentiment["retweets"] = tweet.retweet_count
tweet_sentiment["created"] = tweet.created_at.isoformat()
tweet_sentiment_all.append(tweet_sentiment)
if "RT @" not in tweet.full_text:
tweet = {
"id": tweet.user.id_str,
"user": tweet.user.name,
"text": tweet.full_text,
"favs": tweet.favorite_count,
"retweets": tweet.retweet_count,
"created": tweet.created_at.isoformat()
}
popular_tweets.append(tweet)
if inference:
response_gender_asynch = get_tw_gender.delay(ans_list)
twitter_gender_result = response_gender_asynch.get()
response_sent_asynch = get_tw_sentiment.delay(
tweet_sentiment_all)
twitter_sentiment_result = response_sent_asynch.get()
else:
twitter_gender_result = {}
twitter_sentiment_result = {}
# response_twt_asynch = get_tw_term.delay(cricTweet, inference)
# twitter_gender_top_result = response_twt_asynch.get()
twitter_twt_result = {
'popular_tweets': popular_tweets,
'tweet_gender_prob': twitter_gender_result,
'twitter_sentiment_top_result': twitter_sentiment_result
}
print "twitter_twt_result finished --------"
print twitter_twt_result
print "----------------"
# try:
# response_twt_asynch = get_tw_term.delay(cricTweet, inference)
# twitter_gender_top_result = response_twt_asynch.get()
# print "twitter_gender finished --------"
# except:
# twitter_gender_top_result = [{"text": "error when retrieving Tweets"}]
# try:
# response_twt_asynch = get_tw_sentiment_term.delay(cricTweet)
# twitter_sentiment_top_result = response_twt_asynch.get()
# print "twitter_sentiment finished --------"
# except:
# twitter_sentiment_top_result = [{"text": "error when retrieving Tweets"}]
# twitter_twt_result = {'twitter_gender_top_result': twitter_gender_top_result,
# 'twitter_sentiment_top_result': twitter_sentiment_top_result}
else:
twitter_twt_result = {}
# results = {'popular_tweets': popular_tweets, 'tweet_gender_prob': gender_prob}
print "Retrieving twitter data - finished"
# print("--- %s seconds ---" % (time.time() - start_time))
time_duration = (time.time() - start_time)
time_f = str(time_duration)[:-8]
print "total time:"
print time_f
## integrate results ##
results = {
"related_queries_list": related_queries_result_list,
# "related_queries_list_youtube": related_queries_youtube_result_list,
"volume_list": volume_list,
"time_interest_list": time_interest_kw_dic,
"interest_over_region": region_interest_kw_dic,
"autocomplete": autocomplete_results,
"tweets": twitter_twt_result,
"time": time_f
}
print "results:"
print results
# dump to local file
# filename = keyword+"_results.txt"
# print filename
# with open(filename, 'w') as outfile:
# json.dump(results, outfile)
username = '******'
# print "json results:"
json_results = json.dumps(results)
# print json_results
# print "saving to history"
add_history.delay(queryid, keyword, description, username,
json_results)
# print "saved"
# print json_results
# print "done"
return Response(results, status=status.HTTP_200_OK)
def query_params_mgmt(request, format=None):
"""
Manage "Query Parameters"
"""
ip_address = request.META['REMOTE_ADDR']
if valid_ip(ip_address) is False:
return Response("Not authorised client IP",
status=status.HTTP_401_UNAUTHORIZED)
# try:
# service_user = User.objects.get(username=request.user)
# except User.DoesNotExist:
# # service_user = None
# return Response("User is unknown :"+request.user, status=status.HTTP_400_BAD_REQUEST)
#
# if valid_user(service_user, lsname) is False:
# return Response("User:"******" is not authorised to manage LS:"+str(lsname),
# status=status.HTTP_401_UNAUTHORIZED)
# use the following json in order to add new query parameters
# {
# "description" : "My Mediterranean Capitals Research",
# "sources": "Twitter",
# "location": "Athens",
# "start_date": "1-1-2010",
# "end_date": "1-1-2012",
# "inference": true,
# "questions": true
# }
if request.method == 'POST':
print "create query_params_mgmt "
description = request.data['description']
keywords = request.data['keywords']
location = request.data['location']
start_date = request.data['start_date']
end_date = request.data['end_date']
inference = request.data['inference']
questions = request.data['questions']
twitter = request.data['twitter']
google = request.data['google']
category = request.data['category']
topic = request.data['topic']
youtube = request.data['youtube']
print category
print topic
print keywords
new_params = add_query_params(description, keywords, location,
start_date, end_date, inference,
questions, twitter, google, youtube,
category, topic)
print 'new_params:' + str(new_params)
return Response(True, status=status.HTTP_200_OK)
if request.method == 'GET':
print "get get_all_query_params in view "
all_params = get_all_query_params.delay()
print all_params
return Response(all_params.get(), status=status.HTTP_200_OK)
