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)