def YTPlaylistTable(request):
user = request.user
tableRowsSelections = getUserSelection(request)
queryset = user.userProfile.ytPlaylistsToHarvest.all()
tableRowsSelections = getUserSelection(request)
selectedPlaylists = tableRowsSelections.getSavedQueryset("YTPlaylist", 'YTPlaylistTable')
return ajaxResponse(queryset, request, selectedPlaylists)
def selectUnselectAll(request):
if not 'modelName' in request.GET: return missingParam('modelName')
modelName = request.GET['modelName']
if modelName not in MODEL_WHITELIST: return jsonForbiddenError()
queryset = getModel(request.GET['modelName']).objects.none()
if 'selected' in request.GET:
queryset = getQueryset(request)
getUserSelection(request).saveQuerySet(queryset, request.GET['tableId'])
def linechart_userPopularity(request):
chartGen = LinechartGenerator()
tableSelection = getUserSelection(request)
selectedTWUsers = tableSelection.getSavedQueryset('TWUser', 'TWUserTable')
selectedFBPages = tableSelection.getSavedQueryset('FBPage',
'FacebookPages')
for source in selectedTWUsers:
chartGen.addColum({
'label':
'%s (Abonnés)' %
(source.name if source.name else source.screen_name),
'type':
'number'
})
chartGen.insertValues(
source.followers_counts.extra({'date_created': "date(recorded_time)", 'date_count': 'value'}) \
.values('date_created', 'date_count'))
for source in selectedFBPages:
chartGen.addColum({
'label': '%s (Nombre de fans)' % source,
'type': 'number'
})
chartGen.insertValues(source.fan_counts.extra({'date_created': "date(recorded_time)", 'date_count': 'value'}) \
.values('date_created', 'date_count'))
return chartGen.generate()
def removeSelectedItems(request):
""" Removes the selecteds ItemHarvesters from the user's harvesting list
"""
user = request.user
selection = getUserSelection(request)
queryset = selection.getSavedQueryset(None, request.GET['tableId'])
count = queryset.count()
try:
for item in queryset:
user.userProfile.remove_item_from_harvest_list(item)
except Exception:
logError(
'An error occured while removing selection from harvesting list')
return jResponse({
'error': {
'code': 500,
'message': 'Une erreur est survenue. Veuillez réessayer.'
}
})
resetUserSelection(request)
return jsonMessages([
"{} élément{} {} été retiré{} de votre liste de "
"collecte.".format(count, 's' if count > 1 else '',
'ont' if count > 1 else 'a',
's' if count > 1 else '')
])
def linechart_userActivity(request):
chartGen = LinechartGenerator()
tableSelection = getUserSelection(request)
selectedTWUsers = tableSelection.getSavedQueryset('TWUser', 'TWUserTable')
selectedTWHashHarvs = tableSelection.getSavedQueryset(
'HashtagHarvester', 'TWHashtagTable')
if selectedTWHashHarvs.count() + selectedTWUsers.count() > 10:
raise Exception('Veuillez sélectionner au plus 10 éléments.')
for source in selectedTWUsers:
chartGen.addColum({
'label':
'%s (Tweets)' %
(source.name if source.name else source.screen_name),
'type':
'number'
})
tweets = source.tweets.exclude(created_at__isnull=True)
chartGen.insertValues(tweets.extra({'date_created': "date(created_at)"}) \
.values('date_created') \
.annotate(date_count=Count('id')))
for source in selectedTWHashHarvs:
chartGen.addColum({
'label': '#%s (Tweets)' % source.hashtag.term,
'type': 'number'
})
tweets = source.harvested_tweets.exclude(created_at__isnull=True)
chartGen.insertValues(tweets.extra({'date_created': "date(created_at)"}) \
.values('date_created') \
.annotate(date_count=Count('id')))
return chartGen.generate()
def piechart_location(request):
chartGen = PieChartGenerator()
tableSelection = getUserSelection(request)
twUserFollowerLoc = tableSelection.getSavedQueryset('TWUser', 'TWUserTableFollowerLoc')
selectedTWHashHarvs = tableSelection.getSavedQueryset('HashtagHarvester', 'TWHashtagTable')
if selectedTWHashHarvs.count() + twUserFollowerLoc.count() > 10:
raise Exception('Please select at most 10 elements or create a group')
followers = follower.objects.none()
for source in twUserFollowerLoc:
followers = followers | source.followers.filter(ended__isnull=True)
locations = followers.distinct().values('value__location').annotate(c=Count('id'))
for location in locations:
if location['value__location']:
cleanKey = location['value__location'].split(',')[0]
cleanKey = cleanKey.title()
chartGen.put(cleanKey, location['c'])
tweets = Tweet.objects.none()
for harv in selectedTWHashHarvs:
tweets = tweets | harv.hashtag.tweets.filter(deleted_at__isnull=True)
posters_locations = tweets.distinct().values('user__location').annotate(c=Count('id'))
for location in posters_locations:
if location['user__location']:
cleanKey = location['user__location'].split(',')[0]
cleanKey = cleanKey.title()
chartGen.put(cleanKey, location['c'])
threshold = 0
if 'visibility_threshold' in request.GET: threshold = int(request.GET['visibility_threshold'])
return chartGen.generate(threshold)
def setUserSelection(request):
response = {}
try:
selection = getUserSelection(request)
tableId = request.GET['tableId']
if ('selected' in request.GET and request.GET['selected'] == '_all') or \
('unselected' in request.GET and request.GET['unselected'] == '_all'):
selectUnselectAll(request)
else:
if 'selected' in request.GET:
queryset = getItemQueryset(request.GET['selected'])
selection.selectRow(tableId, queryset)
elif 'unselected' in request.GET:
queryset = getItemQueryset(request.GET['unselected'])
selection.unselectRow(tableId, queryset)
options = [(name[4:], request.GET[name])
for name in request.GET.keys() if 'opt_' in name]
for option in options:
selection.setQueryOption(tableId, option[0], option[1])
response['selectedCount'] = selection.getSelectedRowCount()
response['status'] = 'completed'
except:
viewsLogger.exception("AN ERROR OCCURED IN setUserSelection")
response = {
'status': 'error',
'error': {
'description': 'An error occured in views'
}
}
return HttpResponse(json.dumps(response), content_type='application/json')
def ajaxBase(request):
try:
if not request.user.is_authenticated: return jsonUnauthorizedError()
if 'tableId' not in request.GET: return missingParam('tableId')
if 'modelName' not in request.GET: return missingParam('modelName')
if 'srcs' not in request.GET: return missingParam('srcs')
tableId = request.GET['tableId']
modelName = request.GET['modelName']
if modelName not in MODEL_WHITELIST: return jsonForbiddenError()
queryset = getQueryset(request)
userSelection = getUserSelection(request)
selecteds = userSelection.getSavedQueryset(modelName,
tableId).distinct()
if 'download' in request.GET and request.GET['download'] == 'true':
if request.GET['fileType'] == 'csv':
return generateCSVDownload(request, selecteds, userSelection)
elif request.GET['fileType'] == 'json':
return generateJSONDownload(request, selecteds, userSelection)
else:
response = generateAjaxTableResponse(queryset, request, selecteds)
return HttpResponse(json.dumps(response),
content_type='application/json')
except EmojiiSearchException:
return jResponse({
"status": "exception",
"error": {
"code": 400,
"reason": "La recherche par emojii n'est pas supportée."
}
})
except Exception as e:
logError("Exception occured in tool/views/ajaxTables:ajaxBase")
return jsonBadRequest("Bad arguments")
def removeSelectedItems(request):
aspiraErrors = []
userProfile = request.user.userProfile
selection = getUserSelection(request)
queryset = selection.getSavedQueryset(None, request.GET['tableId'])
successNum = 0
listToRemovefrom = getattr(userProfile, request.GET['listToRemoveFrom'])
for item in queryset:
try:
listToRemovefrom.remove(item)
successNum += 1
except:
aspiraErrors.append(
'Something weird has happened while removing %s' % item)
if aspiraErrors == []:
response = {
'status':
'ok',
'messages': [
'Retiré %i élément%s de votre liste de collecte' %
(successNum, 's' if successNum > 1 else '')
]
}
else:
response = {'status': 'exception', 'errors': aspiraErrors}
selection.delete()
return HttpResponse(json.dumps(response), content_type='application/json')
def YTChannelTable(request):
aspiraUser = request.user
if aspiraUser.is_staff:
queryset = YTChannel.objects.filter(harvested_by__isnull=False)
else:
queryset = aspiraUser.userProfile.ytChannelsToHarvest.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("YTChannel", 'YTChannelTable')
return ajaxResponse(queryset, request, selecteds)
def YTChannelVideosTable(request):
if not 'channelId' in request.GET: return jsonBadRequest(request,'no channelId specified')
if not YTChannel.objects.filter(_ident=request.GET['channelId']).exists():
return jsonNotFound(request)
channel = YTChannel.objects.get(_ident=request.GET['channelId'])
queryset = channel.videos.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("YTVideo", 'YTChannelVideosTable')
return ajaxResponse(queryset, request, selecteds)
def YTPlaylistVideosTable(request):
if not 'playlist' in request.GET: return jsonBadRequest(request, 'no playlist id specified')
if not YTPlaylist.objects.filter(_ident=request.GET['playlist']).exists():
return jsonNotFound(request)
playlist = YTPlaylist.objects.get(_ident=request.GET['playlist'])
queryset = playlist.items.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("YTPlaylistItem", 'YTPlaylistVideosTable')
return ajaxResponse(queryset, request, selecteds)
def YTCommentsTable(request):
if not 'video' in request.GET: return jsonBadRequest(request, 'no video id specified')
if not YTVideo.objects.filter(_ident=request.GET['video']).exists():
return jsonNotFound(request)
video = YTVideo.objects.get(_ident=request.GET['video'])
queryset = video.comments.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("YTComment", 'YTCommentsTable')
return ajaxResponse(queryset, request, selecteds)
def downloadProgress(request):
tableRowsSelections = getUserSelection(request)
options = tableRowsSelections.getQueryOptions(request.GET['tableId'])
if not 'downloadProgress' in options:
tableRowsSelections.setQueryOption(request.GET['tableId'],
'downloadProgress', 0)
options = tableRowsSelections.getQueryOptions(request.GET['tableId'])
return HttpResponse(json.dumps(options), content_type='application/json')
def ajaxTWHashtagTable(request, aspiraUserId):
aspiraUser = User.objects.get(pk=aspiraUserId)
if aspiraUser.is_staff:
queryset = HashtagHarvester.objects.filter(harvested_by__isnull=False)
else:
queryset = aspiraUser.userProfile.twitterHashtagsToHarvest.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("HashtagHarvester", 'TWHashtagTable')
return ajaxResponse(queryset, request, selecteds)
def TWContainedHashtagsTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
value = request.GET['pageURL'].split('/')[-1]
tweet = get_from_any_or_404(Tweet, _ident=value)
queryset = Hashtag.objects.none()
if select:
queryset = tweet.hashtags.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def TWFavoritedByTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
value = request.GET['pageURL'].split('/')[-1]
tweet = get_from_any_or_404(Tweet, _ident=value)
queryset = favorite_tweet.objects.none()
if select:
queryset = tweet.favorited_by.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def TWRepliesTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
value = request.GET['pageURL'].split('/')[-1]
value = re.sub('_', '', value)
tweet = get_from_any_or_404(Tweet, _ident=value)
queryset = Tweet.objects.none()
if select:
queryset = tweet.replied_by.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def TWRepliesTable(request, TweetId):
try:
tweet = get_object_or_404(Tweet, pk=TweetId)
queryset = tweet.replied_by.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("Tweet", 'TWTweetRepliesTable')
return ajaxResponse(queryset, request, selecteds)
except:
viewsLogger.exception("Error occured in TWMentionnedUsers:")
return error500json(request)
def ajaxTWUserMentions(request, TWUserId):
try:
twUser = get_object_or_404(TWUser, pk=TWUserId)
queryset = twUser.mentions.filter(retweet_of__isnull=True)
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("Tweet", 'TWUserMentionsTable')
return ajaxResponse(queryset, request, selecteds)
except:
viewsLogger.exception("Error occured in ajaxTWUserMentions:")
return error500json(request)
def ajaxTWFollowersTable(request, TWUserId):
try:
twUser = get_object_or_404(TWUser, pk=TWUserId)
queryset = twUser.followers.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("follower", 'TWFollowersTable')
return ajaxResponse(queryset, request, selecteds)
except:
viewsLogger.exception("Error occured in ajaxTWUserMentions:")
return error500json(request)
def TWFriendsTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
twuser_ident = request.GET['pageURL'].split('/')[-1]
twuser = get_from_any_or_404(TWUser, screen_name=twuser_ident,
_ident=twuser_ident, pk=twuser_ident)
queryset = TWUser.objects.none()
if select:
queryset = twuser.friends.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def TWUserMentionsTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
twuser_ident = request.GET['pageURL'].split('/')[-1]
twuser = get_from_any_or_404(TWUser, screen_name=twuser_ident,
_ident=twuser_ident, pk=twuser_ident)
queryset = Tweet.objects.none()
if select:
queryset = twuser.mentions.filter(retweet_of__isnull=True)
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def TWContainedHashtags(request, TweetId):
try:
tweet = get_object_or_404(Tweet, pk=TweetId)
queryset = tweet.hashtags.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("Hashtag", 'TWContainedHashtagsTable')
return ajaxResponse(queryset, request, selecteds)
except:
viewsLogger.exception("Error occured in TWMentionnedUsers:")
return error500json(request)
def YTCommentsTableTableSelection(request):
match = re.match(r'/youtube/video/(?P<videoId>[\w\._-]+)/?.*', request.GET['pageURL'])
if not match: return jsonBadRequest(request, 'invalid pageURL parameter')
if not YTVideo.objects.filter(_ident=match.group('videoId')).exists():
return jsonNotFound(request)
video = YTVideo.objects.get(_ident=match.group('videoId'))
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
queryset = YTComment.objects.none()
if select: queryset = video.comments.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def YTPlaylistVideosTableSelection(request):
match = re.match(r'/youtube/playlist/(?P<playlistId>[\w\._-]+)/?.*',request.GET['pageURL'])
if not match: return jsonBadRequest(request, 'invalid pageURL parameter')
if not YTPlaylist.objects.filter(_ident=match.group('playlistId')).exists():
return jsonNotFound(request)
playlist = YTPlaylist.objects.get(_ident=match.group('playlistId'))
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
queryset = YTPlaylistItem.objects.none()
if select: queryset = playlist.items.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def linechart_userPopularity(request):
chartGen = LinechartGenerator()
tableSelection = getUserSelection(request)
selectedTWUsers = tableSelection.getSavedQueryset('TWUser', 'TWUserTable')
for source in selectedTWUsers:
chartGen.addColum({'label': '%s (Followers)' % (source.name if source.name else source.screen_name),
'type': 'number'})
chartGen.insertValues(source.followers_counts.extra({'date_created': "date(recorded_time)",'date_count':'value'}) \
.values('date_created', 'date_count'))
return chartGen.generate()
def TWUserTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
user = request.user
queryset = TWUser.objects.none()
if select:
if user.is_staff:
queryset = TWUser.objects.filter(harvested_by__isnull=False)
else:
queryset = user.userProfile.twitterUsersToHarvest.all()
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def HashtagTweetTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
value = request.GET['pageURL'].split('/')[-1]
hashtag = get_from_any_or_404(Hashtag, term=value)
queryset = Tweet.objects.none()
if select:
queryset = hashtag.tweets.all()
options = tableRowsSelection.getQueryOptions(request.GET['tableId'])
if 'exclude_retweets' in options and options['exclude_retweets']:
queryset = queryset.filter(retweet_of__isnull=True)
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def ajaxTWUserTweetTable(request, TWUserId):
try:
twUser = get_object_or_404(TWUser, pk=TWUserId)
queryset = twUser.tweets.all()
tableRowsSelections = getUserSelection(request)
selecteds = tableRowsSelections.getSavedQueryset("Tweet", 'TWUserTweetTable')
options = tableRowsSelections.getQueryOptions('TWUserTweetTable')
if 'exclude_retweets' in options and options['exclude_retweets']:
queryset = queryset.filter(retweet_of__isnull=True)
return ajaxResponse(queryset, request, selecteds)
except:
viewsLogger.exception("Error occured in ajaxTWUserMentions:")
return error500json(request)
def TWUserFavoritesTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
twuser_ident = request.GET['pageURL'].split('/')[-1]
twuser = get_from_any_or_404(TWUser, screen_name=twuser_ident,
_ident=twuser_ident, pk=twuser_ident)
queryset = Tweet.objects.none()
if select:
queryset = twuser.favorite_tweets.all()
options = tableRowsSelection.getQueryOptions(request.GET['tableId'])
if 'exclude_retweets' in options and options['exclude_retweets']:
queryset = queryset.filter(value__retweet_of__isnull=True)
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def YTVideosTableSelection(request):
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
user = request.user
selectedChannels = tableRowsSelection.getSavedQueryset('YTChannel', 'YTChannelTable')
selectedPlaylists = tableRowsSelection.getSavedQueryset('YTPlaylist', 'YTPlaylistTable')
queryset = YTVideo.objects.none()
if select:
for channel in selectedChannels:
queryset = queryset | channel.videos.all()
for playlist in selectedPlaylists:
items = playlist.items.all()
queryset = queryset | YTVideo.objects.filter(playlistsSpots__pk__in=items)
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def YTVideosTable(request):
user = request.user
tableRowsSelections = getUserSelection(request)
selectedChannels = tableRowsSelections.getSavedQueryset('YTChannel', 'YTChannelTable')
selectedPlaylists = tableRowsSelections.getSavedQueryset('YTPlaylist', 'YTPlaylistTable')
queryset = YTVideo.objects.none()
for channel in selectedChannels:
queryset = queryset | channel.videos.all()
for playlist in selectedPlaylists:
items = playlist.items.all()
queryset = queryset | YTVideo.objects.filter(playlistsSpots__pk__in=items)
selectedVideos = tableRowsSelections.getSavedQueryset("YTVideo", 'YTVideosTable')
queryset = queryset | selectedVideos
return ajaxResponse(queryset.distinct(), request, selectedVideos)
def getQueryset(request):
updateQueryOptions(request)
modelName = request.GET['modelName']
queryset = getModel(modelName).objects.none()
srcs = request.GET['srcs']
userSelection = getUserSelection(request)
for src in json.loads(srcs):
if "query" in src:
queryset = queryset | querySearch(request.user, modelName,
src['query'])
else:
srcModel = request.user.userProfile
attrs = src['attr'].split('__')
if 'modelName' in src:
srcModelName = src['modelName']
if "tableId" in src:
selectedSrcs = userSelection.getSavedQueryset(
srcModelName, src["tableId"])
for selected in selectedSrcs:
subqueryset = reduce_methods(selected, attrs)
queryset = queryset | subqueryset.all()
else:
subqueryset = get_object_or_404(getModel(srcModelName),
pk=src['id'])
queryset = queryset | reduce_methods(subqueryset,
attrs).all()
else:
queryset = queryset | reduce_methods(srcModel, attrs)
options = userSelection.getQueryOptions(request.GET['tableId'])
recordsTotal = queryset.count()
if "exclude_retweets" in options.keys() and options['exclude_retweets']:
queryset = queryset.filter(retweet_of__isnull=True)
if 'search_term' in options.keys(
) and options['search_term'] != "" and 'search_fields' in options.keys():
if re.match(emoji.get_emoji_regexp(), options['search_term']):
raise EmojiiSearchException
queryset = filterQuerySet(queryset,
options['search_fields'].split(','),
options['search_term'])
if 'ord_field' in options.keys():
queryset = orderQueryset(queryset, options['ord_field'],
options['ord_direction'])
queryset.recordsTotal = recordsTotal
return queryset
def ajaxTWTweetTable(request):
try:
#queryset = Tweet.objects.none()
userSelection = getUserSelection(request)
selectedTWUsers = userSelection.getSavedQueryset('TWUser', 'TWUserTable')
selectedHashHarvesters = userSelection.getSavedQueryset('HashtagHarvester', 'TWHashtagTable')
queryset = userSelection.getSavedQueryset('Tweet', 'TWTweetTable')
options = userSelection.getQueryOptions('TWTweetTable')
for user in selectedTWUsers.all():
queryset = queryset | user.tweets.all()
for hashtagHarvester in selectedHashHarvesters.all():
queryset = queryset | hashtagHarvester.hashtag.tweets.all()
if 'exclude_retweets' in options and options['exclude_retweets']:
queryset = queryset.filter(retweet_of__isnull=True)
selecteds = userSelection.getSavedQueryset("Tweet", 'TWTweetTable')
return ajaxResponse(queryset.distinct(), request, selecteds)
except:
viewsLogger.exception("Error occured in ajaxTWTweetTable:")
return error500json(request)
def TWTweetTableSelection(request):
'''
:param select: Boolean. If true, select all item in given table
:return: None
'''
select = 'selected' in request.GET
tableRowsSelection = getUserSelection(request)
queryset = Tweet.objects.none()
if select:
selectedTWUsers = tableRowsSelection.getSavedQueryset('TWUser', 'TWUserTable')
selectedHashHarvesters = tableRowsSelection.getSavedQueryset('HashtagHarvester', 'TWHashtagTable')
for selected in selectedTWUsers:
queryset = queryset | selected.tweets.all()
for selected in selectedHashHarvesters:
queryset = queryset | selected.hashtag.tweets.all()
options = tableRowsSelection.getQueryOptions(request.GET['tableId'])
if 'exclude_retweets' in options and options['exclude_retweets']:
queryset = queryset.filter(retweet_of__isnull=True)
tableRowsSelection.saveQuerySet(queryset, request.GET['tableId'])
def piechart_location(request):
threshold = 1
if 'visibility_threshold' in request.GET:
threshold = int(request.GET['visibility_threshold'])
chart_gen = PieChartGenerator()
table_selection = getUserSelection(request)
twuser_follower_location = table_selection.getSavedQueryset(
'TWUser', 'TWUserTableFollowerLoc')
selected_twitter_hashtags = table_selection.getSavedQueryset(
'Hashtag', 'TWHashtagTable')
if selected_twitter_hashtags.count() + twuser_follower_location.count(
) > 10:
raise Exception('Veuillez sélectionner au plus 10 éléments')
followers = follower.objects.none()
for source in twuser_follower_location:
followers = followers | source.followers.filter(ended__isnull=True)
locations = followers \
.values('value__location') \
.annotate(c=Count('id')) \
.filter(c__gte=threshold)
for location in locations: # TODO: This can take an awful long time. Optimise this.
if location['value__location']:
clean_key = location['value__location'].split(',')[0]
clean_key = clean_key.title()
chart_gen.put(clean_key, location['c'])
tweets = Tweet.objects.none()
for harv in selected_twitter_hashtags:
tweets = tweets | harv.tweets.filter(deleted_at__isnull=True)
posters_locations = \
tweets.distinct() \
.values('user__location') \
.annotate(c=Count('id')) \
.filter(c__gte=threshold)
for location in posters_locations:
if location['user__location']:
clean_key = location['user__location'].split(',')[0]
clean_key = clean_key.title()
chart_gen.put(clean_key, location['c'])
return chart_gen.generate()
def updateQueryOptions(request):
params = request.GET
userSelection = getUserSelection(request)
selecteds = userSelection.getSavedQueryset(params['modelName'], params['tableId'])
if 'fields' in params:
fields = params['fields'].split(',')
if "iSortCol_0" in params:
ordering_column = int(params['iSortCol_0']) - 1
if ordering_column >= 0:
userSelection.setQueryOption(request.GET['tableId'], "ord_field", fields[ordering_column])
userSelection.setQueryOption(request.GET['tableId'], "ord_direction", params['sSortDir_0'])
if selecteds.count():
selecteds = orderQueryset(selecteds, fields[ordering_column], params['sSortDir_0'])
userSelection.saveQuerySet(selecteds, params['tableId'])
if 'sSearch' in params: # and params['sSearch'] != '':
searchables_keys = [value for key, value in sorted(params.items()) if key.startswith("bSearchable_")][1:]
search_fields = [pair[0] for pair in zip(fields, searchables_keys) if pair[1] == 'true']
userSelection.setQueryOption(request.GET['tableId'], 'search_fields', ",".join(search_fields))
userSelection.setQueryOption(request.GET['tableId'], "search_term", params['sSearch'])
def linechart_userActivity(request):
chartGen = LinechartGenerator()
tableSelection = getUserSelection(request)
selectedTWUsers = tableSelection.getSavedQueryset('TWUser', 'TWUserTable')
selectedTWHashHarvs = tableSelection.getSavedQueryset('HashtagHarvester', 'TWHashtagTable')
if selectedTWHashHarvs.count() + selectedTWUsers.count() > 10:
raise Exception('Please select at most 10 elements or create a group')
for source in selectedTWUsers:
chartGen.addColum({'label': '%s (Tweets)' %
(source.name if source.name else source.screen_name),'type': 'number'})
chartGen.insertValues(source.tweets.extra({'date_created': "date(created_at)"}) \
.values('date_created') \
.annotate(date_count=Count('id')))
for source in selectedTWHashHarvs:
chartGen.addColum({'label': '#%s (Tweets)' % source.hashtag.term, 'type': 'number'})
chartGen.insertValues(source.harvested_tweets.extra({'date_created': "date(created_at)"}) \
.values('date_created') \
.annotate(date_count=Count('id')))
return chartGen.generate()
def removeCollectionItem(request):
user = request.user
post = request.POST
if not 'table_id' in post: return missingParam('table_id')
if not 'collection_id' in post: return missingParam('collection_id')
collection = Collection.objects.filter(pk=post['collection_id']).first()
if not collection:
return jsonNotFound()
if user not in collection.curators.all():
return jsonForbiddenError()
selection = getUserSelection(request)
queryset = selection.getSavedQueryset(
"CollectionItem", "collection_table_{}".format(post['collection_id']))
for collection_item in queryset:
collection_item.delete()
return jsonMessages(
"Les éléments sélectionnés ont étés retirés de cette collecte.")
def addItems(request):
user = request.user
get = request.GET
if not 'pageURL' in get: return missingParam('pageURL')
if not 'modelName' in get: return missingParam('modelName')
if not 'tableId' in get: return missingParam('tableId')
if not 'collection_id' in get: return missingParam('collection_id')
collection = Collection.objects.filter(pk=get['collection_id']).first()
if not collection:
return jsonNotFound()
if user not in collection.curators.all():
return jsonForbiddenError()
selection = getUserSelection(request)
queryset = selection.getSavedQueryset(get['modelName'], get['tableId'])
for item in queryset:
CollectionItem.create(collection, item)
return jsonMessages('Les éléments ont étés ajoutés à la collecte %s.' %
collection.name)
