def remove_favorite(request, flowgram):
try:
models.Favorite.objects.get(owner=request.user, flowgram=flowgram).delete()
controller.record_stat(request, 'remove_favorite_website', '0', flowgram.id)
except:
# Ignoring Flowgrams that were not already favorites.
pass
def my_logout(request):
controller.record_stat(request, 'view_logout_website', '0', '')
auth.logout(request)
if request.GET.get('redirect', 'true').lower() == 'true':
return helpers.go_back(request)
else:
return data_response.create(request.POST.get('enc', 'json'), 'ok', {})
def help_article(request, question_id):
question = Question.objects.get(id=question_id)
controller.record_stat(request, 'view_help_website', '0', question_id)
return req_render_to_response(request, 'help/help_article.html', {
'question': question,
})
def help(request):
category_list = Category.objects.all()
controller.record_stat(request, 'view_help_website', '0', 'help index')
return req_render_to_response(request, 'help/help.html', {
'category_list': category_list,
})
def create_easy(request, enc):
(flowgram, new) = controller.get_working_flowgram(request.user)
hash_parts = ["%s-%s" % (key, request.GET[key]) for key in sorted(request.GET.keys())]
controller.record_stat(request, "view_create_website", "0", "")
return helpers.redirect("/r/%s/%s" % (flowgram.id, "__".join(hash_parts)))
def invite(request, invitees, personal_message):
from flowgram.core.mail import send_invitations
invitees = helpers.get_email_addresses_from_comma_separated_string(invitees)
send_invitations(request.user, invitees, personal_message)
controller.record_stat(request, 'add_invite_website', '0', '%d invitees' % len(invitees))
def view_toprated(request, enc):
context = get_default_context()
context['next'] = '/browse/toprated'
controller.record_stat(request, 'view_browse_rate_website', '0', '')
return webhelpers.flowgram_lister(request,
enc=enc,
queryset=cached_sets.top_rated(),
template_name='flowgram/view_toprated.html',
extra_context=context)
def view_your_flowgrams_thumb(request, enc, user, sort_criterion, prpusort, page):
controller.record_stat(request, 'view_browse_userFGs_website', '0',
'FGs owner user id = ' + str(user.id))
users_flowgrams = models.Flowgram.objects.filter(owner=user)
fgs = {}
page_owner = request.user == user
if page_owner:
active = 'you'
activesecondary = 'viewall'
if prpusort == 'private':
fgs = users_flowgrams.filter(public=False)
elif prpusort == 'public':
fgs = users_flowgrams.filter(public=True)
else:
fgs = users_flowgrams
fgs = fgs.order_by(helpers.convert_sort_criterion(sort_criterion, '-modified_at'))
else:
#TODO(cyap) figure out multiple views on this for owner/non-owners
active = 'browse'
activesecondary = 'viewalluser'
fgs = users_flowgrams.filter(public=True)\
.order_by(helpers.convert_sort_criterion(sort_criterion, '-modified_at'))
helpers.delete_blank_flowgrams(fgs)
args = {'template_name': 'flowgram/view_your_flowgrams_thumb.html',
'template_object_name': 'flowgram',
'paginate_by': 14,
'allow_empty': True,
'page': page,
'extra_context': {
'user': request.user,
'u': user,
'profile': user.get_profile(),
'active': active,
'subs_active': localsettings.FEATURE['subscriptions_fw'],
'activesecondary': activesecondary,
'pageowner': page_owner,
'mostviewed': cached_sets.most_viewed()[:6],
'display_mode': request.COOKIES.get('flowgram_results_filter_type', 'grid'),
'num_favs': len(models.Favorite.objects.filter(owner=user)),
'sort_criterion': sort_criterion,
'pub_priv': prpusort,
'multiple_owners': False,
'sortable': True,
'send_to_details': localsettings.FEATURE['send_to_details'],
'posts': webhelpers.get_latest_fg_blog_posts(),
},
'queryset': fgs}
return object_list(request, **args)
def view_newest(request, enc):
context = get_default_context()
context['fg_timestamp'] = True
context['next'] = '/browse/newest'
controller.record_stat(request, 'view_browse_new_website', '0', '')
return webhelpers.flowgram_lister(request,
enc=enc,
queryset=cached_sets.newest(),
template_name='flowgram/view_newest.html',
extra_context=context)
def delete_comment(request, enc, comment_id):
comment = get_object_or_404(models.Comment, id=comment_id)
if not permissions.can_edit(request.user, comment.flowgram):
log.sec_req(request, "User tried to delete comment on flowgram %s." % (comment.flowgram.id))
raise Http404
comment.delete()
controller.record_stat(request, 'del_comment_website', '0', comment_id)
return helpers.go_back(request)
def record_bulk_stats(request):
for stat_index in range(5):
type_key = "type%s" % stat_index
# Exiting when the first missing entry is encountered.
if not type_key in request.POST:
break
type_value = request.POST.get(type_key, None)
num_value = int(request.POST.get("num%s" % stat_index, 0))
string_value = request.POST.get("string%s" % stat_index, "")
controller.record_stat(request, type_value, num_value, string_value)
def view_featured(request, enc):
context = {'hero': cached_sets.get_hero(models.feat.FEATURED_PAGE),
'mostviewed': cached_sets.most_viewed()[:6],
'category_bestof_fgs': helpers.get_category_bestof_fgs(),
'next': '/browse/featured',
'send_to_details': localsettings.FEATURE['send_to_details'],
'posts': webhelpers.get_latest_fg_blog_posts(),
}
controller.record_stat(request, 'view_browse_feat_website', '0', '')
return webhelpers.flowgram_lister(request,
enc=enc,
queryset=cached_sets.get_featured(models.feat.FEATURED_PAGE),
template_name='flowgram/view_featured.html',
extra_context=context)
def add_tag(request, enc, flowgram, tag_name):
tag_name = tag_name.strip()
(tag, null) = models.Tag.objects.get_or_create(adder=request.user,
flowgram=flowgram,
name=tag_name)
controller.record_stat(request, 'add_tag_website', '0', flowgram.id)
if localsettings.FEATURE['notify_fw']:
controller.store_fgtagged_event({'current_user': request.user,
'fg_id': flowgram.id,
'eventCode': 'FG_TAGGED'})
return HttpResponse(tag.name)
def view_favorites(request, enc, user, sort_criterion, prpusort):
favs = models.Favorite.objects.filter(owner=user)
controller.record_stat(request,
'view_favorites_website',
'0',
'fave owner user id = ' + str(user.id))
fav_fgs = []
for favorite in favs:
flowgram = favorite.flowgram
is_public_str = 'public' if flowgram.public else 'private'
if request.user == user:
if prpusort == 'all' or prpusort == is_public_str:
fav_fgs.append(flowgram)
elif flowgram.public:
fav_fgs.append(flowgram)
(page_owner, active) = (True, 'you') if request.user == user else (False, 'browse')
fav_fgs = helpers.sort_flowgrams(fav_fgs,
helpers.convert_sort_criterion(sort_criterion, '-modified_at'))
extra_context = {
'u': user,
'profile': user.get_profile(),
'fgs': fav_fgs,
'active': active,
'subs_active': localsettings.FEATURE['subscriptions_fw'],
'activesecondary': 'favorites',
'mostviewed': cached_sets.most_viewed()[:6],
'pageowner': page_owner,
'num_favs': len(fav_fgs),
'sort_criterion': sort_criterion,
'pub_priv': prpusort,
'multiple_owners': True,
'sortable': True,
'send_to_details': localsettings.FEATURE['send_to_details'],
'posts': webhelpers.get_latest_fg_blog_posts(),
}
return webhelpers.flowgram_lister(request,
enc='html',
queryset=fav_fgs,
template_name='flowgram/view_favorites.html',
extra_context=extra_context)
def add_favorite(request, flowgram):
try:
models.Favorite.objects.get(owner=request.user, flowgram=flowgram)
except:
# If the specified Flowgram is not already a favorite, add it.
models.Favorite.objects.create(owner=request.user, flowgram=flowgram)
controller.record_stat(request, 'add_favorite_website', '0', flowgram.id)
# UserHistory: FG_FAVED
if localsettings.FEATURE['notify_fw']:
try:
controller.store_fgfaved_event({
'current_user': request.user,
'fg_id': flowgram.id,
'eventCode': 'FG_FAVED'})
except:
log.debug("In api/views.py, attempted to send FG_FAVED event to controller.py/store_fgfaved_event -- FAILED")
def show_flowgram(request, enc, flowgram):
can_edit = permissions.can_edit(request.user, flowgram)
context = {
'fg': flowgram,
'can_edit': can_edit,
'subs_active': localsettings.FEATURE['subscriptions_fw'],
'show_delete': can_edit,
'active': 'you' if request.user == flowgram.owner else 'browse',
'mostviewed': cached_sets.most_viewed()[:6],
'send_to_details': localsettings.FEATURE['send_to_details']
}
context.update(webhelpers.get_flowgram_stats(flowgram))
controller.record_stat(request, 'view_flowgram_det_website', '0', flowgram.id)
return helpers.req_render_to_response(
request,
'flowgram/show_flowgram.html',
context)
def contact_us_email(request):
if request.method != 'POST':
return req_render_to_response(request, 'about_us/contact_us_email.html')
name = request.POST.get('name', '')
if name == '':
name='Anonymous'
email = request.POST.get('email', '')
subject = request.POST.get('subject', '')
if subject == '':
subject='I am not big on typing or words.'
comments = request.POST.get('comments', '')
controller.record_stat(request, 'add_feedback_website', '0', '')
add_to_mail_queue(
'*****@*****.**',
'*****@*****.**',
'Contact via FG Contact Us/Feedback form',
'FROM: %s <%s> | SUBJECT: %s | COMMENTS: %s' % (name, email, subject, comments))
return HttpResponseRedirect('/about_us/contact_us_confirm/')
def add_comment(request, enc, flowgram, text):
if not text:
# TODO(westphal): Drop support for XML.
if enc == 'xml':
return HttpResponse('No comment text')
else:
return error_response.create(enc, 'No comment text')
comment = models.Comment.objects.create(
owner=request.user if request.user.is_authenticated() else None,
flowgram=flowgram,
text=text)
controller.record_stat(request, 'add_comment_website', '0', comment.id)
if localsettings.FEATURE['notify_fw']:
controller.store_fgcomented_event({'commentor': request.user,
'fg_id': flowgram.id,
'eventCode': 'FG_COMMENTED'})
# TODO(westphal): Drop support for XML.
if enc == 'xml':
return HttpResponse(helpers.render_comment_to_xml(comment), mimetype="text/xml")
else:
return data_response.create(enc, 'ok', encode.comment.to_dict(comment))
def edit_profile(request):
u = request.user
p = u.get_profile()
if request.method == 'GET':
initial = {
'gender': p.gender,
'newsletter_optin': p.newsletter_optin,
'birthdate': p.birthdate,
'homepage': p.homepage,
'email': u.email,
'description': p.description,
#'subscribe_fg_on_comment': p.subscribe_fg_on_comment,
#'subscribed_to_own_fgs': p.subscribed_to_own_fgs,
}
f = ProfileForm(initial=initial)
return req_render_to_response(request, 'user/edit_profile.html', {
'profile': p,
'form': f,
'subs_active': subs_active,
})
elif request.method == 'POST':
f = ProfileForm(request.POST)
if f.is_valid():
cleaned = f.cleaned_data
p.gender = cleaned['gender']
p.newsletter_optin = cleaned['newsletter_optin']
p.birthdate = cleaned['birthdate']
p.homepage = cleaned['homepage']
p.description = cleaned['description']
#p.subscribe_fg_on_comment = cleaned['subscribe_fg_on_comment']
#p.subscribed_to_own_fgs = cleaned['subscribed_to_own_fgs']
p.save()
u.email = cleaned['email']
u.save()
add_good_message(request, "Your profile was updated.")
controller.record_stat(request, 'edit_profile_website', '0', '')
EmailSubscriptionRequest.objects.create(should_subscribe=p.newsletter_optin, email_address=u.email)
return HttpResponseRedirect(p.url())
def login(request, enc):
next = request.GET.get('next', '/')
if request.user.is_authenticated():
return helpers.redirect(next)
next_greeting = ''
if next.find('create') >= 0:
next_greeting = "Please login or register to get started making Flowgrams. It's quick and easy!"
elif next.find('subscribe') >= 0:
next_greeting = "Please login or register to subscribe to a user. It's quick and easy!"
if request.method == 'POST':
succeeded = False
form = forms.LoginForm(request.POST)
if form.is_valid():
user = auth.authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
assert(user)
auth.login(request, user)
request.session[settings.PERSISTENT_SESSION_KEY] = form.cleaned_data['remember_user']
succeeded = True
if not succeeded:
request.session['processed_login_form'] = form.as_p()
controller.record_stat(request, 'view_login_website', '0', 'unsuccessful')
return HttpResponseRedirect('/login')
next = request.POST.get('next', '')
if next:
controller.record_stat(request,
'view_login_website',
'0',
'successful, next url = %s' % next)
return helpers.redirect(next)
controller.record_stat(request, 'view_login_website', '0', 'successful, next url = /')
return HttpResponseRedirect('/')
else:
form = forms.LoginForm()
reg_form = forms.RegistrationFormStep1()
return helpers.req_render_to_response(request,
'login/login.html',
{'next': next,
'next_greeting': next_greeting,
'reg_form': reg_form,
'which_form_reg': 'register_step_1'})
def view_ajax_browse(request, enc, browse_type, user):
stat_string = 'FGs owner user id = ' + (user.username if user else 'None')
if browse_type == 'featured':
fg_data_set = [cached_sets.get_hero(models.feat.FEATURED_PAGE)] + \
cached_sets.get_featured(models.feat.FEATURED_PAGE)[:11]
controller.record_stat(request, 'view_browse_feat_ajax_website', '0', '')
elif browse_type == 'newest':
fg_data_set = cached_sets.newest()[:12]
controller.record_stat(request, 'view_browse_feat_new_website', '0', '')
elif browse_type == 'most_viewed':
fg_data_set = cached_sets.most_viewed()[:12]
controller.record_stat(request, 'view_browse_most_ajax_website', '0', '')
elif browse_type == 'most_discussed':
fg_data_set = cached_sets.most_discussed()[:12]
controller.record_stat(request, 'view_browse_disc_ajax_website', '0', '')
elif browse_type == 'top_rated':
fg_data_set = cached_sets.top_rated()[:12]
controller.record_stat(request, 'view_browse_rate_ajax_website', '0', '')
elif browse_type == 'user_newest':
fg_data_set = cached_sets.user_newest(user.username)[:6]
controller.record_stat(request, 'view_browse_new_ajax_website', '0', stat_string)
elif browse_type == 'user_most_viewed':
fg_data_set = cached_sets.user_most_viewed(user.username)[:6]
controller.record_stat(request, 'view_browse_most_ajax_website', '0', stat_string)
elif browse_type == 'user_most_discussed':
fg_data_set = cached_sets.user_most_discussed(user.username)[:6]
controller.record_stat(request, 'view_browse_disc_ajax_website', '0', stat_string)
elif browse_type == 'user_top_rated':
fg_data_set = cached_sets.user_top_rated(user.username)[:6]
controller.record_stat(request, 'view_browse_rate_ajax_website', '0', stat_string)
elif browse_type == 'user_title':
fg_data_set = cached_sets.user_title(user.username)[:6]
controller.record_stat(request, 'view_browse_title_ajax_website', '0', stat_string)
return helpers.req_render_to_response(request,
'includes/modules/flowgram/fg_modules_ajax.incl',
{'fg_data_set': fg_data_set,
'fg_timestamp': request.user == user,
'send_to_details': localsettings.FEATURE['send_to_details'],})
def you(request, enc):
controller.record_stat(request, 'view_yourFGs_website', '0', '')
return HttpResponseRedirect('/%s/viewyourflowgramsthumb' % request.user.username)
def _check_anon_create(request, *args, **kwargs):
if request.user.is_anonymous():
controller.record_stat(request, 'view_create_website', '0', '')
return view_func(request, *args, **kwargs)
def record_stat(request, type, num, string):
controller.record_stat(request, type, num, string)
def search(request, enc, q):
controller.record_stat(request, 'view_search_website', '0', '')
if localsettings.FEATURE['use_HEsearch']:
return hyperestraier_search(request, enc, q)
fgs = models.Flowgram.objects.filter(public=True)
if request.user.is_authenticated():
fgs |= models.Flowgram.objects.filter(owner=request.user)
# Using filter with a non-sense id because .none returns an EmptyQueueSet, which causes |= to
# fail with "TypeError: Cannot merge querysets of different types 'EmptyQuerySet' and
# 'QuerySet'.".
by_title = by_tag = by_page_url = by_description = fgs.filter(id='NONSENSE_ID')
extra_context = {'mostviewed': cached_sets.most_viewed()[:6],
'q': q,
'get_args': "q=%s" % q,
'send_to_details': localsettings.FEATURE['send_to_details']}
terms = q.split()
query_terms = "%%%s%%" % "%".join(terms)
by_title_description = fgs.extra(where=['(title LIKE %s OR description LIKE %s)'],
params=[query_terms, query_terms])
if not len(by_title_description):
# By title:
for term in terms:
by_this_title = fgs.filter(title__icontains=term)
by_title |= by_this_title
# By description:
for term in terms:
by_this_description = fgs.filter(description__icontains=term)
by_description |= by_this_description
by_title_description = by_title | by_description
# By tag:
for term in terms:
tags = models.Tag.objects.filter(name=term)
by_this_tag = fgs.filter(id__in=[tag.flowgram.id for tag in tags])
by_tag |= by_this_tag
search_results = (by_tag | by_page_url | by_title_description).order_by('-created_at')
# Check if author exists
if len(terms) == 1:
try:
auth_models.User.objects.get(username=terms[0])
by_username = True
except auth_models.User.DoesNotExist:
by_username = False
extra_context['by_username'] = by_username
return webhelpers.flowgram_lister(request,
enc='html',
queryset=search_results,
template_name='search/search_results.html',
extra_context=extra_context,
display_mode='list')
def delete_tag(request, enc, flowgram, tag_name):
models.Tag.objects.filter(flowgram=flowgram, name=tag_name).delete()
controller.record_stat(request, 'del_tag_website', '0', flowgram.id)
return HttpResponseRedirect(flowgram.url())
