def home(request, page=1):
"""Paginated recent videos and live videos."""
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
profile = get_profile_safely(request.user)
if profile and profile.contributor:
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
archived_events = Event.objects.archived()
if privacy_filter:
archived_events = archived_events.filter(**privacy_filter)
elif privacy_exclude:
archived_events = archived_events.exclude(**privacy_exclude)
archived_events = archived_events.order_by('-start_time')
tags = None
if request.GET.getlist('tag'):
requested_tags = request.GET.getlist('tag')
found_tags = []
not_found_tags = False
for each in requested_tags:
try:
found_tags.append(Tag.objects.get(name__iexact=each).name)
except Tag.DoesNotExist:
not_found_tags = True
if not_found_tags:
# invalid tags were used in the query string
url = reverse('main:home')
if found_tags:
# some were good
url += '?%s' % urllib.urlencode({'tag': found_tags}, True)
return redirect(url, permanent=True)
tags = Tag.objects.filter(name__in=found_tags)
archived_events = archived_events.filter(tags__in=tags)
if tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = (Event.objects.live().order_by('start_time'))
if privacy_filter:
live_events = live_events.filter(**privacy_filter)
elif privacy_exclude:
live_events = live_events.exclude(**privacy_exclude)
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
return render(
request, 'main/home.html', {
'events': archived_paged,
'live': live,
'also_live': also_live,
'tags': tags,
'Event': Event,
})
def vidly_media(request):
events = Event.objects.filter(
Q(template__name__contains='Vid.ly')
|
Q(pk__in=VidlySubmission.objects.all()
.values_list('event_id', flat=True))
)
status = request.GET.get('status')
repeated = request.GET.get('repeated') == 'event'
repeats = {}
if status:
if status not in ('New', 'Processing', 'Finished', 'Error'):
return http.HttpResponseBadRequest("Invalid 'status' value")
# make a list of all tags -> events
_tags = {}
for event in events:
environment = event.template_environment or {}
if not environment.get('tag') or environment.get('tag') == 'None':
continue
_tags[environment['tag']] = event.id
event_ids = []
for tag in vidly.medialist(status):
try:
event_ids.append(_tags[tag])
except KeyError:
# it's on vid.ly but not in this database
logging.debug("Unknown event with tag=%r", tag)
events = events.filter(id__in=event_ids)
elif repeated:
repeats = dict(
(x['event_id'], x['event__id__count'])
for x in
VidlySubmission.objects
.values('event_id')
.annotate(Count('event__id'))
.filter(event__id__count__gt=1)
)
events = Event.objects.filter(id__in=repeats.keys())
def get_repeats(event):
return repeats[event.id]
events = events.order_by('-start_time')
events = events.select_related('template')
paged = paginate(events, request.GET.get('page'), 15)
vidly_resubmit_form = forms.VidlyResubmitForm()
context = {
'paginate': paged,
'status': status,
'vidly_resubmit_form': vidly_resubmit_form,
'repeated': repeated,
'get_repeats': get_repeats,
}
return render(request, 'manage/vidly_media.html', context)
def channel_feed(request, slug):
context = {}
# this slug might be the slug of a parent
channels = Channel.objects.filter(
Q(slug=slug) |
Q(parent__slug=slug)
)
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
if is_contributor(request.user):
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
archived_events = Event.objects.archived()
if privacy_filter:
archived_events = archived_events.filter(**privacy_filter)
elif privacy_exclude:
archived_events = archived_events.exclude(**privacy_exclude)
archived_events = archived_events.order_by('-start_time')
archived_events = archived_events.filter(channels__in=channels)
page = 1
archived_paged = paginate(archived_events, page, 100)
context['events'] = archived_paged
context['get_media_info'] = get_media_info
response = render(request, 'roku/channel.xml', context)
response['Content-Type'] = 'text/xml'
return response
def event_comments(request, id):
context = {}
event = get_object_or_404(Event, id=id)
context['event'] = event
comments = Comment.objects.filter(event=event)
form = forms.CommentsFilterForm(request.GET)
filtered = False
if form.is_valid():
if form.cleaned_data['status'] == 'flagged':
comments = comments.filter(flagged__gt=0)
filtered = True
elif form.cleaned_data['status']:
comments = comments.filter(status=form.cleaned_data['status'])
filtered = True
if form.cleaned_data['user']:
user_filter = (
Q(user__email__icontains=form.cleaned_data['user'])
| Q(user__first_name__icontains=form.cleaned_data['user'])
| Q(user__last_name__icontains=form.cleaned_data['user']))
comments = comments.filter(user_filter)
filtered = True
if form.cleaned_data['comment']:
comments = comments.filter(
comment__icontains=form.cleaned_data['comment'])
filtered = True
context['count'] = comments.count()
paged = paginate(comments, request.GET.get('page'), 10)
context['paginate'] = paged
context['form'] = form
context['filtered'] = filtered
return render(request, 'manage/comments.html', context)
def staticpages(request):
staticpages_paged = paginate(StaticPage.objects.all(),
request.GET.get('page'), 10)
context = {
'paginate': staticpages_paged,
}
return render(request, 'manage/staticpages.html', context)
def home(request, page=1):
template_name = 'starred/home.html'
ids = request.GET.get('ids')
if request.is_ajax():
template_name = 'starred/events.html'
if request.user.is_authenticated():
events = (
Event.objects.filter(starredevent__user=request.user.id)
.order_by('starredevent__created')
)
elif ids:
ids = [int(x) for x in ids.split(',')]
events = Event.objects.filter(id__in=ids)
events = sorted(events, key=lambda e: ids.index(e.id))
else:
events = None
starred_paged = next_page_url = prev_page_url = None
if events:
starred_paged = paginate(events, page, 10)
# to simplify the complexity of the template when it tries to make the
# pagination URLs, we just figure it all out here
if starred_paged.has_next():
next_page_url = reverse(
'starred:home',
args=(starred_paged.next_page_number(),)
)
if starred_paged.has_previous():
prev_page_url = reverse(
'starred:home',
args=(starred_paged.previous_page_number(),)
)
curated_groups_map = collections.defaultdict(list)
curated_groups = (
CuratedGroup.objects.filter(event__in=[
x.id for x in starred_paged
])
.values_list('event_id', 'name')
.order_by('name')
)
for event_id, name in curated_groups:
curated_groups_map[event_id].append(name)
def get_curated_groups(event):
if events:
return curated_groups_map.get(event.id)
context = {
'events': starred_paged,
'get_curated_groups': get_curated_groups,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url,
'star_on': True,
}
return render(request, template_name, context)
def uploads(request):
event = None
if request.method == 'POST':
event = get_object_or_404(Event, id=request.POST['event'])
ids = request.POST.getlist('ids')
deletions = 0
# first check all before attempting to delete
uploads = Upload.objects.filter(event=event, id__in=ids)
for upload in uploads:
if upload.get_vidly_submissions().exists():
return http.HttpResponseBadRequest(
'Upload used by a Vid.ly submission')
for upload in uploads:
if delete_s3_keys_by_urls(upload.url):
deletions += 1
upload.delete()
messages.success(request, '{} upload(s) deleted'.format(deletions))
url = reverse('manage:uploads') + '?event={}'.format(event.id)
return redirect(url)
if request.GET.get('event'):
event = get_object_or_404(Event, id=request.GET['event'])
records = (Upload.objects.select_related('event').order_by('-created'))
if event:
records = records.filter(event=event)
paged = paginate(records, request.GET.get('page'), 20)
context = {
'paginate': paged,
'event': event,
}
return render(request, 'manage/uploads.html', context)
def all_comments(request):
context = {}
comments = Comment.objects.all().select_related('user', 'event')
form = forms.CommentsFilterForm(request.GET)
filtered = False
if form.is_valid():
if form.cleaned_data['event']:
comments = comments.filter(
event__title__icontains=form.cleaned_data['event'])
if form.cleaned_data['status'] == 'flagged':
comments = comments.filter(flagged__gt=0)
filtered = True
elif form.cleaned_data['status']:
comments = comments.filter(status=form.cleaned_data['status'])
filtered = True
if form.cleaned_data['user']:
user_filter = (
Q(user__email__icontains=form.cleaned_data['user'])
| Q(user__first_name__icontains=form.cleaned_data['user'])
| Q(user__last_name__icontains=form.cleaned_data['user']))
comments = comments.filter(user_filter)
filtered = True
if form.cleaned_data['comment']:
comments = comments.filter(
comment__icontains=form.cleaned_data['comment'])
filtered = True
comments = comments.order_by('-created')
context['count'] = comments.count()
paged = paginate(comments, request.GET.get('page'), 20)
context['paginate'] = paged
context['form'] = form
context['filtered'] = filtered
return render(request, 'manage/comments.html', context)
def event_vidly_submissions(request, id):
event = get_object_or_404(Event, id=id)
submissions = (
VidlySubmission.objects
.filter(event=event)
.order_by('submission_time')
)
if request.method == 'POST':
ids = request.POST.getlist('id')
forced = request.POST.get('forced')
submissions = submissions.filter(id__in=ids)
if not forced:
submissions = submissions.filter(tag__isnull=False)
# if any of those have tag that we're currently using, raise a 400
current_tag = event.template_environment.get('tag')
if current_tag and submissions.filter(tag=current_tag):
return http.HttpResponseBadRequest(
"Can not delete because it's in use"
)
deletions = failures = 0
for submission in submissions:
if submission.tag:
results = vidly.delete_media(submission.tag)
else:
assert forced
results = ''
if forced or submission.tag in results:
submission.delete()
deletions += 1
else:
failures += 1
messages.success(
request,
"%s vidly submissions deleted. %s failures" % (
deletions,
failures
)
)
return redirect('manage:event_vidly_submissions', event.id)
paged = paginate(submissions, request.GET.get('page'), 20)
active_submission = None
try:
te = event.template_environment
if te and te.get('tag'):
active_submission = submissions.get(
tag=te['tag']
)
except VidlySubmission.DoesNotExist: # pragma: no cover
pass
data = {
'paginate': paged,
'event': event,
'active_submission': active_submission,
}
return render(request, 'manage/event_vidly_submissions.html', data)
def vidly_media(request):
events = Event.objects.filter(
Q(template__name__contains='Vid.ly')
| Q(pk__in=VidlySubmission.objects.all().values_list('event_id',
flat=True)))
status = request.GET.get('status')
repeated = request.GET.get('repeated') == 'event'
repeats = {}
if status:
if status not in ('New', 'Processing', 'Finished', 'Error'):
return http.HttpResponseBadRequest("Invalid 'status' value")
# make a list of all tags -> events
_tags = {}
for event in events:
environment = event.template_environment or {}
if not environment.get('tag') or environment.get('tag') == 'None':
continue
_tags[environment['tag']] = event.id
event_ids = []
for tag in vidly.medialist(status):
try:
event_ids.append(_tags[tag])
except KeyError:
# it's on vid.ly but not in this database
logging.debug("Unknown event with tag=%r", tag)
events = events.filter(id__in=event_ids)
elif repeated:
repeats = dict(
(x['event_id'], x['event__id__count'])
for x in VidlySubmission.objects.values('event_id').annotate(
Count('event__id')).filter(event__id__count__gt=1))
events = Event.objects.filter(id__in=repeats.keys())
def get_repeats(event):
return repeats[event.id]
events = events.order_by('-start_time')
events = events.select_related('template')
paged = paginate(events, request.GET.get('page'), 15)
submissions = defaultdict(list)
for submission in VidlySubmission.objects.filter(event__in=paged):
submissions[submission.event_id].append(submission)
vidly_resubmit_form = forms.VidlyResubmitForm()
context = {
'paginate': paged,
'status': status,
'vidly_resubmit_form': vidly_resubmit_form,
'repeated': repeated,
'get_repeats': get_repeats,
'submissions': submissions,
}
return render(request, 'manage/vidly_media.html', context)
def home(request, page=1):
template_name = 'starred/home.html'
ids = request.GET.get('ids')
if request.is_ajax():
template_name = 'starred/events.html'
if request.user.is_authenticated():
events = (Event.objects.filter(
starredevent__user=request.user).order_by('starredevent__created'))
elif ids:
# If you're not authenticated, you should only be able to see
# public events.
try:
ids = [int(x) for x in ids.split(',')]
except ValueError:
return http.HttpResponseBadRequest('invalid id')
events = Event.objects.filter(id__in=ids).filter(
Q(privacy=Event.PRIVACY_PUBLIC)
| Q(privacy=Event.PRIVACY_CONTRIBUTORS))
events = sorted(events, key=lambda e: ids.index(e.id))
else:
events = None
starred_paged = next_page_url = prev_page_url = None
if events:
starred_paged = paginate(events, page, 10)
# to simplify the complexity of the template when it tries to make the
# pagination URLs, we just figure it all out here
if starred_paged.has_next():
next_page_url = reverse('starred:home',
args=(starred_paged.next_page_number(), ))
if starred_paged.has_previous():
prev_page_url = reverse(
'starred:home', args=(starred_paged.previous_page_number(), ))
curated_groups_map = collections.defaultdict(list)
curated_groups = (CuratedGroup.objects.filter(
event__in=[x.id for x in starred_paged]).values_list(
'event_id', 'name').order_by('name'))
for event_id, name in curated_groups:
curated_groups_map[event_id].append(name)
def get_curated_groups(event):
if events:
return curated_groups_map.get(event.id)
context = {
'events': starred_paged,
'get_curated_groups': get_curated_groups,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url,
'star_on': True,
}
return render(request, template_name, context)
def loggedsearches(request):
searches = (
LoggedSearch.objects.select_related('event_clicked').order_by('-date'))
paged = paginate(searches, request.GET.get('page'), 20)
context = {
'paginate': paged,
'hash_user_id': lambda x: str(hash(str(x)))[-4:],
}
return render(request, 'manage/loggedsearches.html', context)
def all_event_tweets(request):
"""Summary of tweets and submission of tweets"""
tweets = (EventTweet.objects.filter().select_related('event').order_by(
'-send_date'))
paged = paginate(tweets, request.GET.get('page'), 10)
data = {
'paginate': paged,
}
return render(request, 'manage/all_event_tweets.html', data)
def staticpages(request):
staticpages_paged = paginate(
StaticPage.objects.all(),
request.GET.get('page'),
10
)
context = {
'paginate': staticpages_paged,
}
return render(request, 'manage/staticpages.html', context)
def event_hit_stats(request):
possible_order_by = ('total_hits', 'hits_per_day', 'score')
order_by = request.GET.get('order')
if order_by not in possible_order_by:
order_by = possible_order_by[-1]
include_excluded = bool(request.GET.get('include_excluded'))
today = timezone.now()
yesterday = today - datetime.timedelta(days=1)
title = request.GET.get('title')
stats = (
EventHitStats.objects
.exclude(event__archive_time__isnull=True)
.filter(event__archive_time__lt=yesterday)
.order_by('-%s' % order_by)
.extra(select={
'hits_per_day': 'total_hits / extract(days from (now() '
'- main_event.archive_time))',
'score': '(featured::int + 1) * total_hits'
'/ extract(days from (now() - archive_time)) ^ 1.8',
})
.select_related('event')
)
if title:
stats = stats.filter(event__title__icontains=title)
if not include_excluded:
stats = stats.exclude(event__channels__exclude_from_trending=True)
stats_total = (
EventHitStats.objects
.filter(event__archive_time__isnull=False)
.aggregate(Sum('total_hits'))
)
stats_total = stats_total['total_hits__sum']
events_total = (
Event.objects
.filter(archive_time__isnull=False)
.filter(template__name__contains='Vid.ly')
.count()
)
paged = paginate(stats, request.GET.get('page'), 20)
data = {
'order_by': order_by,
'paginate': paged,
'stats_total': stats_total,
'events_total': events_total,
'include_excluded': include_excluded,
'title': title,
}
return render(request, 'manage/event_hit_stats.html', data)
def uploads(request):
records = (
Upload.objects
.select_related('event')
.order_by('-created')
)
paged = paginate(records, request.GET.get('page'), 20)
context = {
'paginate': paged,
}
return render(request, 'manage/uploads.html', context)
def users(request):
"""User editor: view users and update a user's group."""
if request.method == 'POST':
form = forms.UserFindForm(request.POST)
if form.is_valid():
user = User.objects.get(email=form.cleaned_data['email'])
return redirect('manage:user_edit', user.id)
else:
form = forms.UserFindForm()
users_paged = paginate(User.objects.all(), request.GET.get('page'), 10)
return render(request, 'manage/users.html',
{'paginate': users_paged, 'form': form})
def users(request):
"""User editor: view users and update a user's group."""
if request.method == 'POST':
form = forms.UserFindForm(request.POST)
if form.is_valid():
user = User.objects.get(email=form.cleaned_data['email'])
return redirect('manage:user_edit', user.id)
else:
form = forms.UserFindForm()
users_paged = paginate(User.objects.all(), request.GET.get('page'), 10)
return render(request, 'manage/users.html',
{'paginate': users_paged, 'form': form})
def uploads(request):
event = None
if request.GET.get('event'):
event = get_object_or_404(Event, id=request.GET['event'])
records = (Upload.objects.select_related('event').order_by('-created'))
if event:
records = records.filter(event=event)
paged = paginate(records, request.GET.get('page'), 20)
context = {
'paginate': paged,
'event': event,
}
return render(request, 'manage/uploads.html', context)
def loggedsearches(request):
searches = (
LoggedSearch.objects
.select_related('event_clicked')
.order_by('-date')
)
paged = paginate(searches, request.GET.get('page'), 20)
context = {
'paginate': paged,
'hash_user_id': lambda x: str(hash(str(x)))[-4:],
}
return render(request, 'manage/loggedsearches.html', context)
def all_event_tweets(request):
"""Summary of tweets and submission of tweets"""
tweets = (
EventTweet.objects
.filter()
.select_related('event')
.order_by('-send_date')
)
paged = paginate(tweets, request.GET.get('page'), 10)
data = {
'paginate': paged,
}
return render(request, 'manage/all_event_tweets.html', data)
def uploads(request):
event = None
if request.GET.get('event'):
event = get_object_or_404(Event, id=request.GET['event'])
records = (
Upload.objects
.select_related('event')
.order_by('-created')
)
if event:
records = records.filter(event=event)
paged = paginate(records, request.GET.get('page'), 20)
context = {
'paginate': paged,
'event': event,
}
return render(request, 'manage/uploads.html', context)
def home(request, page=1):
"""Paginated recent videos and live videos."""
if request.user.is_active:
public_filter = {}
else:
public_filter = {'public': True}
archived_events = (Event.objects.archived().filter(
**public_filter).order_by('-archive_time'))
tags = None
if request.GET.getlist('tag'):
requested_tags = request.GET.getlist('tag')
found_tags = []
not_found_tags = False
for each in requested_tags:
try:
found_tags.append(Tag.objects.get(name__iexact=each).name)
except Tag.DoesNotExist:
not_found_tags = True
if not_found_tags:
# invalid tags were used in the query string
url = reverse('main:home')
if found_tags:
# some were good
url += '?%s' % urllib.urlencode({'tag': found_tags}, True)
return redirect(url, permanent=True)
tags = Tag.objects.filter(name__in=found_tags)
archived_events = archived_events.filter(tags__in=tags)
if tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = (Event.objects.live().filter(
**public_filter).order_by('start_time'))
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
return render(
request, 'main/home.html', {
'events': archived_paged,
'live': live,
'also_live': also_live,
'tags': tags
})
def home(request, page=1):
"""Paginated recent videos and live videos."""
if request.user.is_active:
public_filter = {}
else:
public_filter = {'public': True}
archived_events = (Event.objects.archived().filter(**public_filter)
.order_by('-archive_time'))
live_events = (Event.objects.live().filter(**public_filter)
.order_by('start_time'))
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
return render(request, 'main/home.html', {
'events': archived_paged,
'live': live,
'also_live': also_live
})
def events(request):
"""Event edit/production: approve, change, and publish events."""
if request.user.has_perm('main.change_event_others'):
creator_filter = {}
else:
creator_filter = {'creator': request.user}
search_results = []
if request.method == 'POST':
search_form = forms.EventFindForm(request.POST)
if search_form.is_valid():
search_results = Event.objects.filter(
title__icontains=search_form.cleaned_data['title'],
**creator_filter).order_by('-start_time')
else:
search_form = forms.EventFindForm()
initiated = (Event.objects.initiated().filter(
**creator_filter).order_by('start_time').select_related(
'category', 'location'))
upcoming = (Event.objects.upcoming().filter(
**creator_filter).order_by('start_time').select_related(
'category', 'location'))
live = (Event.objects.live().filter(
**creator_filter).order_by('start_time').select_related(
'category', 'location'))
archiving = (Event.objects.archiving().filter(
**creator_filter).order_by('-archive_time').select_related(
'category', 'location'))
archived = (Event.objects.archived_and_removed().filter(
**creator_filter).order_by('-start_time').select_related(
'category', 'location'))
archived_paged = paginate(archived, request.GET.get('page'), 10)
return render(
request, 'manage/events.html', {
'initiated': initiated,
'upcoming': upcoming,
'live': live,
'archiving': archiving,
'archived': archived_paged,
'form': search_form,
'search_results': search_results
})
def channel_feed(request, slug):
# this slug might be the slug of a parent
channels = Channel.objects.filter(Q(slug=slug) | Q(parent__slug=slug))
events = Event.objects.archived().approved()
events = events.filter(channels__in=channels)
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
if is_contributor(request.user):
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
if privacy_filter:
events = events.filter(**privacy_filter)
elif privacy_exclude:
events = events.exclude(**privacy_exclude)
events = events.order_by('-start_time')
paged = paginate(events, 1, 100)
return render_channel_events(paged, request)
def all_comments(request):
context = {}
comments = Comment.objects.all().select_related('user', 'event')
form = forms.CommentsFilterForm(request.GET)
filtered = False
if form.is_valid():
if form.cleaned_data['event']:
comments = comments.filter(
event__title__icontains=form.cleaned_data['event']
)
if form.cleaned_data['status'] == 'flagged':
comments = comments.filter(flagged__gt=0)
filtered = True
elif form.cleaned_data['status']:
comments = comments.filter(status=form.cleaned_data['status'])
filtered = True
if form.cleaned_data['user']:
user_filter = (
Q(user__email__icontains=form.cleaned_data['user'])
|
Q(user__first_name__icontains=form.cleaned_data['user'])
|
Q(user__last_name__icontains=form.cleaned_data['user'])
)
comments = comments.filter(user_filter)
filtered = True
if form.cleaned_data['comment']:
comments = comments.filter(
comment__icontains=form.cleaned_data['comment']
)
filtered = True
comments = comments.order_by('-created')
context['count'] = comments.count()
paged = paginate(comments, request.GET.get('page'), 20)
context['paginate'] = paged
context['form'] = form
context['filtered'] = filtered
return render(request, 'manage/comments.html', context)
def uploads(request):
event = None
if request.method == 'POST':
event = get_object_or_404(Event, id=request.POST['event'])
ids = request.POST.getlist('ids')
deletions = 0
# first check all before attempting to delete
uploads = Upload.objects.filter(event=event, id__in=ids)
for upload in uploads:
if upload.get_vidly_submissions().exists():
return http.HttpResponseBadRequest(
'Upload used by a Vid.ly submission'
)
for upload in uploads:
if delete_s3_keys_by_urls(upload.url):
deletions += 1
upload.delete()
messages.success(
request,
'{} upload(s) deleted'.format(deletions)
)
url = reverse('manage:uploads') + '?event={}'.format(event.id)
return redirect(url)
if request.GET.get('event'):
event = get_object_or_404(Event, id=request.GET['event'])
records = (
Upload.objects
.select_related('event')
.order_by('-created')
)
if event:
records = records.filter(event=event)
paged = paginate(records, request.GET.get('page'), 20)
context = {
'paginate': paged,
'event': event,
}
return render(request, 'manage/uploads.html', context)
def home(request, page=1):
"""Paginated recent videos and live videos."""
if request.user.is_active:
public_filter = {}
else:
public_filter = {"public": True}
archived_events = Event.objects.archived().filter(**public_filter).order_by("-archive_time")
tags = None
if request.GET.getlist("tag"):
requested_tags = request.GET.getlist("tag")
found_tags = []
not_found_tags = False
for each in requested_tags:
try:
found_tags.append(Tag.objects.get(name__iexact=each).name)
except Tag.DoesNotExist:
not_found_tags = True
if not_found_tags:
# invalid tags were used in the query string
url = reverse("main:home")
if found_tags:
# some were good
url += "?%s" % urllib.urlencode({"tag": found_tags}, True)
return redirect(url, permanent=True)
tags = Tag.objects.filter(name__in=found_tags)
archived_events = archived_events.filter(tags__in=tags)
if tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = Event.objects.live().filter(**public_filter).order_by("start_time")
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
return render(
request, "main/home.html", {"events": archived_paged, "live": live, "also_live": also_live, "tags": tags}
)
def events(request):
"""Event edit/production: approve, change, and publish events."""
if request.user.has_perm('main.change_event_others'):
creator_filter = {}
else:
creator_filter = {'creator': request.user}
search_results = []
if request.method == 'POST':
search_form = forms.EventFindForm(request.POST)
if search_form.is_valid():
search_results = Event.objects.filter(
title__icontains=search_form.cleaned_data['title'],
**creator_filter
).order_by('-start_time')
else:
search_form = forms.EventFindForm()
initiated = (Event.objects.initiated().filter(**creator_filter)
.order_by('start_time')
.select_related('category', 'location'))
upcoming = (Event.objects.upcoming().filter(**creator_filter)
.order_by('start_time').select_related('category', 'location'))
live = (Event.objects.live().filter(**creator_filter)
.order_by('start_time').select_related('category', 'location'))
archiving = (Event.objects.archiving().filter(**creator_filter)
.order_by('-archive_time')
.select_related('category', 'location'))
archived = (Event.objects.archived_and_removed().filter(**creator_filter)
.order_by('-start_time')
.select_related('category', 'location'))
archived_paged = paginate(archived, request.GET.get('page'), 10)
return render(request, 'manage/events.html', {
'initiated': initiated,
'upcoming': upcoming,
'live': live,
'archiving': archiving,
'archived': archived_paged,
'form': search_form,
'search_results': search_results
})
def participants(request):
"""Participants page: view and search participants/speakers."""
if request.method == 'POST':
search_form = forms.ParticipantFindForm(request.POST)
if search_form.is_valid():
participants = Participant.objects.filter(
name__icontains=search_form.cleaned_data['name'])
else:
participants = Participant.objects.all()
else:
participants = Participant.objects.exclude(
cleared=Participant.CLEARED_NO)
search_form = forms.ParticipantFindForm()
participants_not_clear = Participant.objects.filter(
cleared=Participant.CLEARED_NO)
participants_paged = paginate(participants, request.GET.get('page'), 10)
return render(
request, 'manage/participants.html', {
'participants_clear': participants_paged,
'participants_not_clear': participants_not_clear,
'form': search_form
})
def participants(request):
"""Participants page: view and search participants/speakers."""
if request.method == 'POST':
search_form = forms.ParticipantFindForm(request.POST)
if search_form.is_valid():
participants = Participant.objects.filter(
name__icontains=search_form.cleaned_data['name']
)
else:
participants = Participant.objects.all()
else:
participants = Participant.objects.exclude(
cleared=Participant.CLEARED_NO
)
search_form = forms.ParticipantFindForm()
participants_not_clear = Participant.objects.filter(
cleared=Participant.CLEARED_NO
)
participants_paged = paginate(participants, request.GET.get('page'), 10)
return render(request, 'manage/participants.html',
{'participants_clear': participants_paged,
'participants_not_clear': participants_not_clear,
'form': search_form})
def channel_feed(request, slug):
# this slug might be the slug of a parent
channels = Channel.objects.filter(
Q(slug=slug) |
Q(parent__slug=slug)
)
events = Event.objects.archived().approved()
events = events.filter(channels__in=channels)
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
if is_contributor(request.user):
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
if privacy_filter:
events = events.filter(**privacy_filter)
elif privacy_exclude:
events = events.exclude(**privacy_exclude)
events = events.order_by('-start_time')
paged = paginate(events, 1, 100)
return render_channel_events(paged, request)
def event_comments(request, id):
context = {}
event = get_object_or_404(Event, id=id)
context['event'] = event
comments = Comment.objects.filter(event=event)
form = forms.CommentsFilterForm(request.GET)
filtered = False
if form.is_valid():
if form.cleaned_data['status'] == 'flagged':
comments = comments.filter(flagged__gt=0)
filtered = True
elif form.cleaned_data['status']:
comments = comments.filter(status=form.cleaned_data['status'])
filtered = True
if form.cleaned_data['user']:
user_filter = (
Q(user__email__icontains=form.cleaned_data['user'])
|
Q(user__first_name__icontains=form.cleaned_data['user'])
|
Q(user__last_name__icontains=form.cleaned_data['user'])
)
comments = comments.filter(user_filter)
filtered = True
if form.cleaned_data['comment']:
comments = comments.filter(
comment__icontains=form.cleaned_data['comment']
)
filtered = True
context['count'] = comments.count()
paged = paginate(comments, request.GET.get('page'), 10)
context['paginate'] = paged
context['form'] = form
context['filtered'] = filtered
return render(request, 'manage/comments.html', context)
def flatpages(request):
flatpages_paged = paginate(FlatPage.objects.all(),
request.GET.get('page'), 10)
return render(request, 'manage/flatpages.html',
{'paginate': flatpages_paged})
def home(request, page=1, channel_slug=settings.DEFAULT_CHANNEL_SLUG):
"""Paginated recent videos and live videos."""
channels = Channel.objects.filter(slug=channel_slug)
if not channels.count():
if channel_slug == settings.DEFAULT_CHANNEL_SLUG:
# then, the Main channel hasn't been created yet
Channel.objects.create(name=settings.DEFAULT_CHANNEL_NAME,
slug=settings.DEFAULT_CHANNEL_SLUG)
channels = Channel.objects.filter(slug=channel_slug)
else:
raise http.Http404('Channel not found')
request.channels = channels
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
profile = get_profile_safely(request.user)
if profile and profile.contributor:
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
archived_events = Event.objects.archived()
if privacy_filter:
archived_events = archived_events.filter(**privacy_filter)
elif privacy_exclude:
archived_events = archived_events.exclude(**privacy_exclude)
archived_events = archived_events.order_by('-start_time')
tags = None
if request.GET.getlist('tag'):
requested_tags = request.GET.getlist('tag')
found_tags = []
not_found_tags = False
for each in requested_tags:
try:
found_tags.append(Tag.objects.get(name__iexact=each).name)
except Tag.DoesNotExist:
not_found_tags = True
if not_found_tags:
# invalid tags were used in the query string
url = reverse('main:home')
if found_tags:
# some were good
url += '?%s' % urllib.urlencode({'tag': found_tags}, True)
return redirect(url, permanent=True)
tags = Tag.objects.filter(name__in=found_tags)
archived_events = archived_events.filter(tags__in=tags)
if tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = (Event.objects.live().order_by('start_time'))
if privacy_filter:
live_events = live_events.filter(**privacy_filter)
elif privacy_exclude:
live_events = live_events.exclude(**privacy_exclude)
# apply the mandatory channels filter
# but only do this if it's not filtered by tags
live_events = live_events.filter(channels=channels)
archived_events = archived_events.filter(channels=channels)
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
# to simplify the complexity of the template when it tries to make the
# pagination URLs, we just figure it all out here
next_page_url = prev_page_url = None
channel = channels[0]
if archived_paged.has_next():
if channel.slug == settings.DEFAULT_CHANNEL_SLUG:
next_page_url = reverse('main:home',
args=(archived_paged.next_page_number(), ))
else:
next_page_url = reverse('main:home_channels',
args=(channel.slug,
archived_paged.next_page_number()))
if archived_paged.has_previous():
if channel.slug == settings.DEFAULT_CHANNEL_SLUG:
prev_page_url = reverse(
'main:home', args=(archived_paged.previous_page_number(), ))
else:
prev_page_url = reverse(
'main:home_channels',
args=(channel.slug, archived_paged.previous_page_number()))
return render(
request, 'main/home.html', {
'events': archived_paged,
'live': live,
'also_live': also_live,
'tags': tags,
'Event': Event,
'channel': channel,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url,
})
def home(request, page=1):
"""Paginated recent videos and live videos."""
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
profile = get_profile_safely(request.user)
if profile and profile.contributor:
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
archived_events = Event.objects.archived()
if privacy_filter:
archived_events = archived_events.filter(**privacy_filter)
elif privacy_exclude:
archived_events = archived_events.exclude(**privacy_exclude)
archived_events = archived_events.order_by('-start_time')
tags = None
if request.GET.getlist('tag'):
requested_tags = request.GET.getlist('tag')
found_tags = []
not_found_tags = False
for each in requested_tags:
try:
found_tags.append(Tag.objects.get(name__iexact=each).name)
except Tag.DoesNotExist:
not_found_tags = True
if not_found_tags:
# invalid tags were used in the query string
url = reverse('main:home')
if found_tags:
# some were good
url += '?%s' % urllib.urlencode({
'tag': found_tags
}, True)
return redirect(url, permanent=True)
tags = Tag.objects.filter(name__in=found_tags)
archived_events = archived_events.filter(tags__in=tags)
if tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = (Event.objects.live()
.order_by('start_time'))
if privacy_filter:
live_events = live_events.filter(**privacy_filter)
elif privacy_exclude:
live_events = live_events.exclude(**privacy_exclude)
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
return render(request, 'main/home.html', {
'events': archived_paged,
'live': live,
'also_live': also_live,
'tags': tags,
'Event': Event,
})
def flatpages(request):
flatpages_paged = paginate(FlatPage.objects.all(), request.GET.get('page'),
10)
return render(request, 'manage/flatpages.html',
{'paginate': flatpages_paged})
def home(request, page=1, channel_slug=settings.DEFAULT_CHANNEL_SLUG):
"""Paginated recent videos and live videos."""
channels = Channel.objects.filter(slug=channel_slug)
if not channels.count():
if channel_slug == settings.DEFAULT_CHANNEL_SLUG:
# then, the Main channel hasn't been created yet
Channel.objects.create(
name=settings.DEFAULT_CHANNEL_NAME,
slug=settings.DEFAULT_CHANNEL_SLUG
)
channels = Channel.objects.filter(slug=channel_slug)
else:
raise http.Http404('Channel not found')
request.channels = channels
privacy_filter = {}
privacy_exclude = {}
if request.user.is_active:
if is_contributor(request.user):
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
archived_events = Event.objects.archived()
if privacy_filter:
archived_events = archived_events.filter(**privacy_filter)
elif privacy_exclude:
archived_events = archived_events.exclude(**privacy_exclude)
archived_events = archived_events.order_by('-start_time')
found_tags = []
if request.GET.getlist('tag'):
requested_tags = request.GET.getlist('tag')
for each in requested_tags:
found_tags.extend(Tag.objects.filter(name__iexact=each))
if len(found_tags) < len(requested_tags):
# invalid tags were used in the query string
url = reverse('main:home')
if found_tags:
# some were good
url += '?%s' % urllib.urlencode({
'tag': [x.name for x in found_tags]
}, True)
return redirect(url, permanent=True)
archived_events = archived_events.filter(tags__in=found_tags)
if found_tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = (Event.objects.live()
.order_by('start_time'))
if privacy_filter:
live_events = live_events.filter(**privacy_filter)
elif privacy_exclude:
live_events = live_events.exclude(**privacy_exclude)
# apply the mandatory channels filter
# but only do this if it's not filtered by tags
live_events = live_events.filter(channels=channels)
archived_events = archived_events.filter(channels=channels)
if channels and channels[0].reverse_order:
archived_events = archived_events.reverse()
archived_paged = paginate(archived_events, page, 10)
live = None
also_live = []
if live_events:
live, also_live = live_events[0], live_events[1:]
# to simplify the complexity of the template when it tries to make the
# pagination URLs, we just figure it all out here
next_page_url = prev_page_url = None
channel = channels[0]
if archived_paged.has_next():
if channel.slug == settings.DEFAULT_CHANNEL_SLUG:
next_page_url = reverse(
'main:home',
args=(archived_paged.next_page_number(),)
)
else:
next_page_url = reverse(
'main:home_channels',
args=(channel.slug,
archived_paged.next_page_number())
)
if archived_paged.has_previous():
if channel.slug == settings.DEFAULT_CHANNEL_SLUG:
prev_page_url = reverse(
'main:home',
args=(archived_paged.previous_page_number(),)
)
else:
prev_page_url = reverse(
'main:home_channels',
args=(channel.slug,
archived_paged.previous_page_number())
)
events_qs = Event.objects.archived().all()
if request.user.is_active:
if is_contributor(request.user):
feed_privacy = 'contributors'
events_qs = events_qs.exclude(privacy=Event.PRIVACY_COMPANY)
else:
feed_privacy = 'company'
else:
events_qs = events_qs.filter(privacy=Event.PRIVACY_PUBLIC)
feed_privacy = 'public'
channel_children = []
for child in channel.get_children().order_by('name'):
channel_children.append((
child,
events_qs.filter(channels=child).count()
))
return render(request, 'main/home.html', {
'events': archived_paged,
'live': live,
'also_live': also_live,
'tags': found_tags,
'Event': Event,
'channel': channel,
'channel_children': channel_children,
'feed_privacy': feed_privacy,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url,
})
def home(request, page=1, channel_slug=settings.DEFAULT_CHANNEL_SLUG):
"""Paginated recent videos and live videos."""
channels = Channel.objects.filter(slug=channel_slug)
if not channels.count():
if channel_slug == settings.DEFAULT_CHANNEL_SLUG:
# then, the Main channel hasn't been created yet
Channel.objects.create(name=settings.DEFAULT_CHANNEL_NAME,
slug=settings.DEFAULT_CHANNEL_SLUG)
channels = Channel.objects.filter(slug=channel_slug)
else:
raise http.Http404('Channel not found')
request.channels = channels
privacy_filter = {}
privacy_exclude = {}
archived_events = Event.objects.archived()
if request.user.is_active:
if is_contributor(request.user):
privacy_exclude = {'privacy': Event.PRIVACY_COMPANY}
else:
privacy_filter = {'privacy': Event.PRIVACY_PUBLIC}
archived_events = archived_events.approved()
if privacy_filter:
archived_events = archived_events.filter(**privacy_filter)
elif privacy_exclude:
archived_events = archived_events.exclude(**privacy_exclude)
archived_events = archived_events.order_by('-start_time')
archived_events = archived_events.select_related('picture')
found_tags = []
if request.GET.getlist('tag'):
requested_tags = request.GET.getlist('tag')
for each in requested_tags:
found_tags.extend(Tag.objects.filter(name__iexact=each))
if len(found_tags) < len(requested_tags):
# invalid tags were used in the query string
url = reverse('main:home')
if found_tags:
# some were good
url += '?%s' % urllib.urlencode(
{'tag': [x.name for x in found_tags]}, True)
return redirect(url, permanent=True)
archived_events = archived_events.filter(tags__in=found_tags)
if found_tags:
# no live events when filtering by tag
live_events = Event.objects.none()
else:
live_events = (Event.objects.live().order_by('start_time'))
if not request.user.is_active:
live_events = live_events.approved()
if privacy_filter:
live_events = live_events.filter(**privacy_filter)
elif privacy_exclude:
live_events = live_events.exclude(**privacy_exclude)
# apply the mandatory channels filter
# but only do this if it's not filtered by tags
live_events = live_events.filter(channels=channels)
archived_events = archived_events.filter(channels=channels)
live_events = live_events.select_related('picture')
if channels and channels[0].reverse_order:
archived_events = archived_events.reverse()
archived_paged = paginate(archived_events, page, 10)
# to simplify the complexity of the template when it tries to make the
# pagination URLs, we just figure it all out here
next_page_url = prev_page_url = None
channel = channels[0]
if archived_paged.has_next():
if channel.slug == settings.DEFAULT_CHANNEL_SLUG:
next_page_url = reverse('main:home',
args=(archived_paged.next_page_number(), ))
else:
next_page_url = reverse('main:home_channels',
args=(channel.slug,
archived_paged.next_page_number()))
if archived_paged.has_previous():
if channel.slug == settings.DEFAULT_CHANNEL_SLUG:
prev_page_url = reverse(
'main:home', args=(archived_paged.previous_page_number(), ))
else:
prev_page_url = reverse(
'main:home_channels',
args=(channel.slug, archived_paged.previous_page_number()))
events_qs = Event.objects.archived().all()
if request.user.is_active:
if is_contributor(request.user):
feed_privacy = 'contributors'
events_qs = events_qs.exclude(privacy=Event.PRIVACY_COMPANY)
else:
feed_privacy = 'company'
else:
events_qs = events_qs.filter(privacy=Event.PRIVACY_PUBLIC)
feed_privacy = 'public'
channel_children = []
for child in channel.get_children().order_by('name'):
channel_children.append(
(child, events_qs.filter(channels=child).count()))
curated_groups_map = collections.defaultdict(list)
curated_groups = (CuratedGroup.objects.all().values_list(
'event_id', 'name').order_by('name'))
for event_id, name in curated_groups:
curated_groups_map[event_id].append(name)
def get_curated_groups(event):
return curated_groups_map.get(event.id)
context = {
'events': archived_paged,
'live_events': live_events,
'tags': found_tags,
'Event': Event,
'channel': channel,
'channel_children': channel_children,
'feed_privacy': feed_privacy,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url,
'get_curated_groups': get_curated_groups,
}
return render(request, 'main/home.html', context)
