def mail_followee(request, fwee, fwer):
followee_name = user_display(fwee)
follower_name = user_display(fwer)
subject = _("%(followee)s, %(follower)s is now following you on NewCo.")
subject_kwargs = {"followee": followee_name, "follower": follower_name}
txt_template = get_template("mail/_follow_notification_email.txt")
html_template = get_template("mail/_follow_notification_email.html")
context = Context({
"followee":
fwee,
"follower":
fwer,
"followee_name":
followee_name,
"follower_name":
follower_name,
"followee_url":
request.build_absolute_uri(fwee.get_absolute_url()),
"follower_url":
request.build_absolute_uri(fwer.get_absolute_url()),
"request":
request,
"message_subject":
subject
})
send_mail(subject, subject_kwargs, fwee, txt_template, html_template,
context, fwer)
def mail_question_author(request, answer):
question = answer.question
receiver = question.author
receiver_name = user_display(question.author)
answerer = answer.author
answerer_name = user_display(answer.author)
subject = _("%(receiver)s, %(answerer)s has answered your question!")
subject_kwargs = {"receiver": receiver_name, "answerer": answerer_name}
txt_template = get_template("mail/_answer_notification_email.txt")
html_template = get_template("mail/_answer_notification_email.html")
context = Context({
"answer":
answer,
"request":
request,
"receiver":
receiver_name,
"receiver_url":
request.build_absolute_uri(receiver.get_absolute_url()),
"answerer":
answerer_name,
"answerer_url":
request.build_absolute_uri(answerer.get_absolute_url()),
"message_subject":
subject,
})
send_mail(subject, subject_kwargs, receiver, txt_template, html_template,
context, answerer)
def render(self, context):
try:
content = self.content.resolve(context)
display = self.display.resolve(context)
args, kwargs = self.resolve_template_args(context)
except:
return ""
pic_size = kwargs.get("pic_size", None)
pic_size = args[0] if not pic_size and len(args) > 0 else pic_size
template, author = ["content/info.html", content.author]
ctx = {"created": content.created}
if "signature" in display or display == "detail":
ctx.update({"case": "signature"})
if display in ["signature", "detail"]:
ctx.update({
"signature_author": True,
"signature_pic": True,
"author_name": user_display(author),
"reputation": author.reputation.reputation_incremented,
"author_url": author.get_absolute_url(),
"profile_pic": profile_pic(author, size=pic_size)
})
elif display == "signature-author":
ctx.update({
"signature_author": True,
"author_name": user_display(author),
"reputation": author.reputation.reputation_incremented,
"author_url": author.get_absolute_url()
})
elif display == "signature-pic":
ctx.update({
"signature_pic": True,
"profile_pic": profile_pic(author, size=pic_size)
})
else:
raise TemplateSyntaxError("'content_info': wrong display.")
elif display == "header":
ctx.update({
"case": "header",
# "author_name": user_display(author),
# "author_url": author.get_absolute_url(),
"author": author,
"reputation": author.reputation.reputation_incremented,
"about": author.get_profile().about
})
elif display in ["date", "list"]:
ctx.update({"case": "date"})
else:
raise TemplateSyntaxError("'content_info': wrong display value.")
return render_to_string(template, ctx, context_instance=context)
def confirm_email(request, confirmation_key, **kwargs):
"""
Confirms the email as normal, but then also logs the user in if succesful
"""
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
email_address = None
user = authenticate(confirmation_key=confirmation_key)
if user:
auth_login(request, user)
try:
email_confirmation = EmailConfirmation.objects.get(confirmation_key=confirmation_key)
email_address = email_confirmation.email_address
# now delete the confirmation
email_confirmation.delete()
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
messages.add_message(
request,
messages.SUCCESS,
ugettext(u"You have confirmed that %(email)s is an email address for user '%(user)s'.")
% {"user": user_display(email_address.user), "email": email_address.email},
)
return HttpResponseRedirect(success_url)
except:
pass
return render_to_response(
"emailconfirmation/confirm_email.html",
{"email_address": email_address},
context_instance=RequestContext(request),
)
def folder_share(request, pk):
User = get_user_model()
qs = Folder.objects.for_user(request.user)
folder = get_object_or_404(qs, pk=pk)
if not folder.can_share(request.user):
raise Http404()
form_kwargs = {
"colleagues": User.objects.all() # @@@ make this a hookset to be defined at site level
}
if request.method == "POST":
if "remove" in request.POST:
user_to_remove = User.objects.get(pk=request.POST["remove"])
messages.success(request, "{} has been removed from folder share".format(user_display(user_to_remove)))
return redirect("documents_folder_share", folder.pk)
else:
form = ColleagueFolderShareForm(request.POST, **form_kwargs)
if form.is_valid():
folder.share(form.cleaned_data["participants"])
return redirect(folder)
else:
form = ColleagueFolderShareForm(**form_kwargs)
ctx = {
"folder": folder,
"form": form,
"participants": folder.shared_with(),
}
return render(request, "documents/folder_share.html", ctx)
def render(self, context):
user = self.user_var.resolve(context)
display = user_display(user)
if self.as_var:
context[self.as_var] = display
return ""
return conditional_escape(display)
def render(self, context):
user = self.user_var.resolve(context)
display = user_display(user)
if self.as_var:
context[self.as_var] = display
return ""
return conditional_escape(display)
def render(self, context):
try:
obj = self.obj.resolve(context)
display = self.display.resolve(context)
args, kwargs = self.resolve_template_args(context)
except:
return ""
ctx = {"object": obj, "display": display}
color = kwargs.get("color", None)
color = args[0] if not color and len(args) > 0 else color
if color:
ctx.update({"color": color})
if obj.__class__ is Item:
template = "items/_product_display.html"
elif obj.__class__ is User:
template = "profiles/_profile_display.html"
skills = obj.get_profile().skills
ctx.update({"username": user_display(obj)})
if skills.count():
ctx.update({"skills": skills})
else:
raise TemplateSyntaxError("'object_display' only renders Item "
"and User instances")
html = render_to_string(template, ctx, context_instance=context)
return self.render_output(context, html)
def process_following(self, request, obj, success_url):
user = request.user
kwargs = {}
if not user == obj:
is_following = Follow.objects.is_following(user, obj)
follow_obj = unfollow(user, obj) if is_following else \
follow(user, obj)
is_following = not is_following
if follow_obj.target.__class__ is User:
if is_following:
mail_followee(request, follow_obj.target, user)
title = user_display(follow_obj.target)
else:
title = unicode(follow_obj.target)
key = "follow" if is_following else "unfollow"
kwargs.update({"object": title})
else:
key = "follow-warning"
add_message(key, request, **kwargs)
if request.is_ajax():
messages = render_messages(request)
data = {"is_following": is_following, "messages": messages}
return HttpResponse(json.dumps(data), mimetype="application/json")
else:
return HttpResponseRedirect(success_url)
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = (request.GET.get("success_url")
or request.POST.get("success_url")
or kwargs.pop("success_url", None))
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if success_url is None:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url,
redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
messages.add_message(
request, messages.SUCCESS,
ugettext(u"Successfully logged in as %(user)s.") %
{"user": user_display(form.user)})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"form":
form,
"url_required":
url_required,
"redirect_field_name":
redirect_field_name,
"redirect_field_value":
request.GET.get(redirect_field_name,
request.POST.get(redirect_field_name)),
"success_url":
success_url,
})
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
ctx['invite_parameters'] = get_invite_parameters(request)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url,
redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, request.FILES, group=group)
if form.is_valid():
user = form.save(request=request)
accept_invite(request, user)
if settings.ACCOUNT_EMAIL_VERIFICATION:
ctx.update({
"email": form.cleaned_data["email"],
"success_url": success_url,
})
ctx = RequestContext(request, ctx)
return render_to_response("account/verification_sent.html",
ctx)
else:
form.login(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") %
{"user": user_display(user)})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group,
initial={
'username': ugettext('Username'),
'email': ugettext('Email address')
})
ctx.update({
"form":
form,
"redirect_field_name":
redirect_field_name,
"redirect_field_value":
request.REQUEST.get(redirect_field_name),
})
return render_to_response(template_name, RequestContext(request, ctx))
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = (request.GET.get("success_url")
or request.POST.get("success_url")
or kwargs.pop("success_url", None))
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if success_url is None:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(
request, fallback_url, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
messages.add_message(
request, messages.SUCCESS,
ugettext(u"Successfully logged in as %(user)s.") % {
"user": user_display(form.user)
})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(
redirect_field_name,
request.POST.get(redirect_field_name)
),
"success_url": success_url,
})
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
template_name_failure = kwargs.pop("template_name_failure", "signup_codes/failure.html")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(request)
ctx = group_context(group, bridge)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user = form.save(request=request)
signup_code = form.cleaned_data["signup_code"]
if signup_code:
signup_code.use(user)
form.login(request, user)
messages.add_message(
request,
messages.SUCCESS,
ugettext("Successfully logged in as %(username)s.") % {"username": user_display(user)},
)
return HttpResponseRedirect(success_url)
else:
signup_code = SignupCode.check(code)
if signup_code:
initial = {"signup_code": code, "email": signup_code.email}
form = form_class(initial=initial, group=group)
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
ctx.update({"code": code})
ctx = RequestContext(request, ctx)
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(template_name_failure, ctx)
else:
form = form_class(group=group)
ctx.update({"code": code, "form": form})
return render_to_response(template_name, RequestContext(request, ctx))
def form_valid(self, form):
self.created_user = self.create_user(form, commit=False)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED:
self.created_user.is_active = False
# prevent User post_save signal from creating an Account instance
# we want to handle that ourself.
self.created_user._disable_account_creation = True
self.created_user.save()
self.create_account(form)
email_kwargs = {
"primary": True,
"verified": False,
"confirm": settings.ACCOUNT_EMAIL_CONFIRMATION_EMAIL,
}
if self.signup_code:
self.signup_code.use(self.created_user)
if self.signup_code.email and self.created_user.email == self.signup_code.email:
email_kwargs["verified"] = True
EmailAddress.objects.add_email(self.created_user, self.created_user.email, **email_kwargs)
self.after_signup(form)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED and not email_kwargs["verified"]:
response_kwargs = {
"request": self.request,
"template": self.template_name_email_confirmation_sent,
"context": {
"email": self.created_user.email,
"success_url": self.get_success_url(),
}
}
return self.response_class(**response_kwargs)
else:
show_message = [
settings.ACCOUNT_EMAIL_CONFIRMATION_EMAIL,
self.messages.get("email_confirmation_sent"),
not email_kwargs["verified"]
]
if all(show_message):
messages.add_message(
self.request,
self.messages["email_confirmation_sent"]["level"],
self.messages["email_confirmation_sent"]["text"] % {
"email": form.cleaned_data["email"]
}
)
self.login_user()
if self.messages.get("logged_in"):
messages.add_message(
self.request,
self.messages["logged_in"]["level"],
self.messages["logged_in"]["text"] % {
"user": user_display(self.created_user)
}
)
return redirect(self.get_success_url())
def form_valid(self, form):
new_user = self.create_user(form, commit=False)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED:
new_user.is_active = False
# prevent User post_save signal from creating an Account instance
# we want to handle that ourself.
new_user._disable_account_creation = True
new_user.save()
self.create_account(new_user, form)
email_kwargs = {
"primary": True,
"verified": False,
"confirm": settings.ACCOUNT_EMAIL_CONFIRMATION_EMAIL,
}
if self.signup_code:
self.signup_code.use(new_user)
if self.signup_code.email and new_user.email == self.signup_code.email:
email_kwargs["verified"] = True
EmailAddress.objects.add_email(new_user, new_user.email, **email_kwargs)
self.after_signup(new_user, form)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED and not email_kwargs["verified"]:
response_kwargs = {
"request": self.request,
"template": self.template_name_email_confirmation_sent,
"context": {
"email": new_user.email,
"success_url": self.get_success_url(),
}
}
return self.response_class(**response_kwargs)
else:
show_message = [
settings.ACCOUNT_EMAIL_CONFIRMATION_EMAIL,
self.messages.get("email_confirmation_sent"),
not email_kwargs["verified"]
]
if all(show_message):
messages.add_message(
self.request,
self.messages["email_confirmation_sent"]["level"],
self.messages["email_confirmation_sent"]["text"] % {
"email": form.cleaned_data["email"]
}
)
self.login_user(new_user)
if self.messages.get("logged_in"):
messages.add_message(
self.request,
self.messages["logged_in"]["level"],
self.messages["logged_in"]["text"] % {
"user": user_display(new_user)
}
)
return redirect(self.get_success_url())
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(
request, fallback_url, redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user = form.save(request=request)
if settings.ACCOUNT_EMAIL_VERIFICATION:
ctx.update({
"email": form.cleaned_data["email"],
"success_url": success_url,
})
ctx = RequestContext(request, ctx)
return render_to_response("account/verification_sent.html",
ctx)
else:
form.login(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {
"user": user_display(user)
})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx.update({
"form": form,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(
redirect_field_name,
request.POST.get(redirect_field_name)),
})
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
template_name_failure = kwargs.pop("template_name_failure", "signup_codes/failure.html")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
if success_url is None:
success_url = get_default_redirect(request)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
signup_code = form.cleaned_data["signup_code"]
signup_code.use(user)
auth_login(request, user)
messages.add_message(request, messages.SUCCESS,
ugettext("Successfully logged in as %(username)s.") % {
"username": user_display(user),
}
)
return HttpResponseRedirect(success_url)
else:
signup_code = check_signup_code(code)
if signup_code:
form = form_class(initial={"signup_code": code}, group=group)
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
ctx.update({
"code": code,
})
ctx = RequestContext(request, ctx)
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(template_name_failure, ctx)
else:
form = form_class(group=group)
ctx.update({
"code": code,
"form": form,
})
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/account_signup.html")
template_name_failure = kwargs.pop("template_name_failure",
"signup_codes/failure.html")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(request)
ctx = group_context(group, bridge)
if success_url is None:
success_url = get_default_redirect(request)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user = form.save(request=request)
signup_code = form.cleaned_data["signup_code"]
signup_code.use(user)
form.login(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(username)s.") % {
"username": user_display(user),
})
return HttpResponseRedirect(success_url)
else:
signup_code = check_signup_code(code)
if signup_code:
form = form_class(initial={"signup_code": code}, group=group)
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
ctx.update({
"code": code,
})
ctx = RequestContext(request, ctx)
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(template_name_failure, ctx)
else:
form = form_class(group=group)
ctx.update({
"code": code,
"form": form,
})
return render_to_response(template_name, RequestContext(request, ctx))
def form_valid(self, form):
if "ask" not in self.request.POST:
return super(AskForHelpMixin, self).form_valid(form)
receiver_profiles = []
request, user = [self.request, self.request.user]
question = Question.objects.get(id=form.question_id)
username = user_display(user)
for key, value in form.cleaned_data.items():
if key in ["experts", "users"] and value:
profile_ids = map(int, re.split("\D+", value))
receiver_profiles.extend(Profile.objects.filter(
id__in=profile_ids).select_related("user"))
elif key == "email" and value:
m = EMAIL_PATTERN.match(request.POST["email"])
if m:
receiver_profile = Profile(user=User(email=m.group()),
name=m.group("username"))
receiver_profile.user.account = Account()
receiver_profile.user.get_absolute_url = void
receiver_profiles.append(receiver_profile)
else:
kwargs = {"user": username, "email": request.POST["email"]}
add_message("email-error", request, **kwargs)
for receiver_profile in receiver_profiles:
receiver = receiver_profile.user
receiver_name = user_display(receiver_profile)
if receiver != user:
mail_helper(request, receiver, user, question, receiver_name,
username)
kwargs = {"user": username, "receiver": receiver_name}
add_message("email-sent", request, **kwargs)
else:
add_message("ask-warning", request, user=username)
return HttpResponseRedirect(request.path)
def mail_helper(request,
receiver,
requester,
question,
receiver_name=None,
requester_name=None):
if not receiver_name:
receiver_name = user_display(receiver)
if not requester_name:
requester_name = user_display(requester)
subject = _("%(receiver)s, %(requester)s needs your help.")
subject_kwargs = {"receiver": receiver_name, "requester": requester_name}
txt_template = get_template("mail/_ask_notification_email.txt")
html_template = get_template("mail/_ask_notification_email.html")
context = Context({
"receiver":
receiver_name,
"receiver_url":
request.build_absolute_uri(receiver.get_absolute_url()),
"asker":
requester_name,
"asker_url":
request.build_absolute_uri(requester.get_absolute_url()),
"request":
request,
"message_subject":
subject,
"question":
question,
"question_url":
request.build_absolute_uri(question.get_absolute_url()),
"settings_url":
request.build_absolute_uri(reverse("account_settings"))
})
send_mail(subject, subject_kwargs, receiver, txt_template, html_template,
context, requester)
def form_valid(self, form):
email_confirmed = False
new_user = self.create_user(form, commit=False)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED:
new_user.is_active = False
new_user.save()
signup_code = form.cleaned_data.get("code")
if signup_code:
signup_code.use(new_user)
if signup_code.email and form.cleaned_data["email"] == signup_code.email:
EmailAddress.objects.create(
user=new_user,
email=form.cleaned_data["email"],
primary=True,
verified=True
)
email_confirmed = True
else:
EmailAddress.objects.add_email(new_user, form.cleaned_data["email"])
else:
EmailAddress.objects.add_email(new_user, form.cleaned_data["email"])
self.after_signup(new_user, form)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED and not email_confirmed:
response_kwargs = {
"request": self.request,
"template": self.template_name_email_confirmation_sent,
"context": {
"email": form.cleaned_data["email"],
"success_url": self.get_success_url(),
}
}
return self.response_class(**response_kwargs)
else:
if self.messages.get("email_confirmation_sent") and not email_confirmed:
messages.add_message(
self.request,
self.messages["email_confirmation_sent"]["level"],
self.messages["email_confirmation_sent"]["text"] % {
"email": form.cleaned_data["email"]
}
)
self.login_user(new_user)
if self.messages.get("logged_in"):
messages.add_message(
self.request,
self.messages["logged_in"]["level"],
self.messages["logged_in"]["text"] % {
"user": user_display(new_user)
}
)
return super(SignupView, self).form_valid(form)
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = kwargs.pop("success_url", None)
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
message = ugettext(u"Successfully logged in as %(user)s.") % {"user": user_display(form.user)}
messages.add_message(request, messages.SUCCESS, message)
extra_context["message"] = message
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.is_ajax():
extra_context["TEMPLATE"] = ""
return extra_context
return HttpResponseRedirect(success_url)
else:
extra_context["message"] = "Login failed"
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update(
{
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(redirect_field_name),
"TEMPLATE": template_name,
}
)
ctx.update(extra_context)
return ctx
def login(self, request):
if self.is_valid():
login(request, self.user)
request.user.message_set.create(
message = ugettext(u"Successfully logged in as %(user)s.") % {
'user': user_display(self.user)
}
)
if self.cleaned_data['remember']:
request.session.set_expiry(60 * 60 * 24 * 7 * 3)
else:
request.session.set_expiry(0)
return True
return False
def update_kwargs(key, request, **kwargs):
WORDS = {"object-created": "created", "object-updated": "updated"}
kwargs.update({"user": user_display(request.user)})
if "model" in kwargs:
model = kwargs.pop("model")
kwargs.update({
"article": pgettext(model._meta.module_name, "the "),
"verbose_name": model._meta.verbose_name
})
if key in WORDS:
word = WORDS[key]
kwargs.update({word: pgettext(model._meta.module_name, word)})
return kwargs
def get_context_data(self, **kwargs):
history = self.page_user.content_set.public().prefetch_related(
"author__reputation", "items")
fwers_ids = Follow.objects.get_follows(self.page_user).values_list(
"user_id", flat=True)
obj_fwed = Follow.objects.filter(user=self.page_user)
fwees_ids = obj_fwed.values_list("target_user_id", flat=True)
items_fwed_ids = obj_fwed.values_list("target_item_id", flat=True)
empty_msg = _("%(page_user_display)s have not contributed yet.") % {
"page_user_display": user_display(self.page_user)
}
context = super(ProfileDetailView, self).get_context_data(**kwargs)
followers = User.objects.filter(pk__in=fwers_ids)
followees = User.objects.filter(pk__in=fwees_ids)
scores, votes = history.get_scores_and_votes(self.request.user, True)
context.update({
"empty_msg":
empty_msg,
"reputation":
self.page_user.reputation,
"fwers":
followers.order_by("-reputation__reputation_incremented"),
"fwees":
followees.order_by("-reputation__reputation_incremented"),
"items_fwed":
Item.objects.filter(pk__in=items_fwed_ids),
"scores":
scores,
"votes":
votes,
})
# Next step would be to be able to "merge" the get_context_data of both
# DetailView (SingleObjectMixin) and MultipleObjectMixin
m = MultipleObjectMixin()
m.request = self.request
m.kwargs = self.kwargs
m.paginate_by = self.paginate_by
history = history.select_subclasses()
context.update(m.get_context_data(object_list=history))
return context
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
credentials = form.save(request=request)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html",
{"email": form.cleaned_data["email"]},
context_instance=RequestContext(request),
)
else:
user = authenticate(**credentials)
auth_login(request, user)
messages.add_message(
request,
messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {"user": user_display(user)},
)
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update(
{
"form": form,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(redirect_field_name),
}
)
return render_to_response(template_name, RequestContext(request, ctx))
def form_valid(self, form):
email_confirmed = False
new_user = self.create_user(form, commit=False)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED:
new_user.is_active = False
new_user.save()
self.create_account(new_user, form)
email_kwargs = {"primary": True}
if self.signup_code:
self.signup_code.use(new_user)
if self.signup_code.email and new_user.email == self.signup_code.email:
email_kwargs["verified"] = True
email_confirmed = True
EmailAddress.objects.add_email(new_user, new_user.email, **email_kwargs)
self.after_signup(new_user, form)
if settings.ACCOUNT_EMAIL_CONFIRMATION_REQUIRED and not email_confirmed:
response_kwargs = {
"request": self.request,
"template": self.template_name_email_confirmation_sent,
"context": {
"email": new_user.email,
"success_url": self.get_success_url(),
}
}
return self.response_class(**response_kwargs)
else:
if self.messages.get("email_confirmation_sent") and not email_confirmed:
messages.add_message(
self.request,
self.messages["email_confirmation_sent"]["level"],
self.messages["email_confirmation_sent"]["text"] % {
"email": form.cleaned_data["email"]
}
)
self.login_user(new_user)
if self.messages.get("logged_in"):
messages.add_message(
self.request,
self.messages["logged_in"]["level"],
self.messages["logged_in"]["text"] % {
"user": user_display(new_user)
}
)
return redirect(self.get_success_url())
def mixpanel(request):
user = request.user
if user.is_authenticated():
profile = user.get_profile()
data = {
"userId": user.id,
"email": user.email,
"bio": profile.about,
"created": user.date_joined,
"name": user_display(profile),
"reputation": user.reputation.reputation_incremented
}
else:
data = {"userId": 0}
user = json.dumps(data, cls=DjangoJSONEncoder).replace("\\r",
"\\\\r").replace(
"\\n", "\\\\n")
output = {"MIXPANEL_KEY_ID": settings.MIXPANEL_KEY_ID, "user_json": user}
return output
def test_post_successful(self):
qs = User.objects.filter(email="*****@*****.**")
if qs:
qs.delete()
post = {
"email": "*****@*****.**",
"password": "******",
"password_confirm": "pwd",
"profile_name": "bob"
}
request = self.factory.post(reverse("account_signup"), post)
request.user = AnonymousUser()
# workaround bug in django 1.4
from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', self.session)
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = SignupEnabledView.as_view()(request)
self.assertEqual(response.status_code, 302)
user = User.objects.get(email="*****@*****.**")
self.assertEqual(user_display(user), "bob")
user.delete()
def label_from_instance(self, obj):
return user_display(obj)
def do_register(self, request, message=None):
"""
do_register implementation is copied from django-openid so we can
ensure Pinax functionality in OpenID registration. django-openid
didn't quite give enough hooks.
This implementation modifies the POST case and will not run
create_user, confirm_email_step or on_registration_complete hooks.
"""
# Show a registration / signup form, provided the user is not
# already logged in
if not request.user.is_anonymous():
return self.show_already_signed_in(request)
openid_url = request.POST.get("openid_url")
openids = request.session.get("openids")
if not openid_url and not openids:
return account_login(request,
url_required=True,
extra_context={
"openid_login": True,
})
# perform OpenID login if openid_url is defined. we do this before the
# check to ACCOUNT_OPEN_SIGNUP to allow users who have existing OpenID
# association to login even when ACCOUNT_OPEN_SIGNUP is turned off.
if openid_url:
return self.start_openid_process(
request,
user_url=openid_url,
on_complete_url=urlparse.urljoin(request.path,
"../register_complete/"),
trust_root=urlparse.urljoin(request.path, ".."))
if not settings.ACCOUNT_OPEN_SIGNUP:
return render_to_response("django_openid/registration_closed.html",
{},
context_instance=RequestContext(request))
RegistrationForm = self.get_registration_form_class(request)
try:
openid = request.openid and request.openid.openid or None
except AttributeError:
return self.show_error(
request, "Add CookieConsumer or similar to your middleware")
if request.method == "POST":
# TODO: The user might have entered an OpenID as a starting point,
# or they might have decided to sign up normally
form = RegistrationForm(
request.POST,
openid=openid,
reserved_usernames=self.reserved_usernames,
no_duplicate_emails=self.no_duplicate_emails)
if form.is_valid():
# Pinax modification
user = form.save(request=request)
if openid:
user.openids.create(openid=openid)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html", {
"email": form.cleaned_data["email"],
},
context_instance=RequestContext(request))
else:
# form.login is the same implementation used in normal
# signup. hopefully this doesn't bite us later.
self.log_in_user(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") %
{"user": user_display(user)})
# @@@ honor custom redirect more fully (this is used primarily for
# the default fallback)
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(
settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(
settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(
request, fallback_url, self.redirect_field_name)
return HttpResponseRedirect(success_url)
else:
form = RegistrationForm(
initial=request.openid
and self.initial_from_sreg(request.openid.sreg) or {},
openid=openid,
reserved_usernames=self.reserved_usernames,
no_duplicate_emails=self.no_duplicate_emails)
return self.render(
request, self.register_template, {
"form":
form,
"message":
message,
"openid":
request.openid,
"logo":
self.logo_path or (urlparse.urljoin(request.path, "../logo/")),
"no_thanks":
self.sign_next(request.path),
"action":
request.path,
})
def label_from_instance(self, obj):
return user_display(obj)
def get_owner_name(self, obj):
return user_display(obj.owner)
def get_display_name(self, obj):
return user_display(obj)
def profile(request):
result = {}
if request.user.is_authenticated():
profile = request.user.get_profile()
result.update({"PROFILE": profile, "USERNAME": user_display(profile)})
return result
def do_register(self, request, message=None):
"""
do_register implementation is copied from django-openid so we can
ensure Pinax functionality in OpenID registration. django-openid
didn't quite give enough hooks.
This implementation modifies the POST case and will not run
create_user, confirm_email_step or on_registration_complete hooks.
"""
# Show a registration / signup form, provided the user is not
# already logged in
if not request.user.is_anonymous():
return self.show_already_signed_in(request)
openid_url = request.POST.get("openid_url")
openids = request.session.get("openids")
if not openid_url and not openids:
return account_login(request, url_required=True, extra_context={
"openid_login": True,
})
# perform OpenID login if openid_url is defined. we do this before the
# check to ACCOUNT_OPEN_SIGNUP to allow users who have existing OpenID
# association to login even when ACCOUNT_OPEN_SIGNUP is turned off.
if openid_url:
return self.start_openid_process(request,
user_url = openid_url,
on_complete_url = urlparse.urljoin(
request.path, "../register_complete/"
),
trust_root = urlparse.urljoin(request.path, "..")
)
if not settings.ACCOUNT_OPEN_SIGNUP:
return render_to_response("django_openid/registration_closed.html", {
}, context_instance=RequestContext(request))
RegistrationForm = self.get_registration_form_class(request)
try:
openid = request.openid and request.openid.openid or None
except AttributeError:
return self.show_error(
request, "Add CookieConsumer or similar to your middleware"
)
if request.method == "POST":
# TODO: The user might have entered an OpenID as a starting point,
# or they might have decided to sign up normally
form = RegistrationForm(
request.POST,
openid = openid,
reserved_usernames = self.reserved_usernames,
no_duplicate_emails = self.no_duplicate_emails
)
if form.is_valid():
# Pinax modification
user = form.save(request=request)
if openid:
user.openids.create(openid=openid)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response("account/verification_sent.html", {
"email": form.cleaned_data["email"],
}, context_instance=RequestContext(request))
else:
# form.login is the same implementation used in normal
# signup. hopefully this doesn't bite us later.
self.log_in_user(request, user)
messages.add_message(request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {
"user": user_display(user)
}
)
# @@@ honor custom redirect more fully (this is used primarily for
# the default fallback)
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url, self.redirect_field_name)
return HttpResponseRedirect(success_url)
else:
form = RegistrationForm(
initial = request.openid and self.initial_from_sreg(
request.openid.sreg
) or {},
openid = openid,
reserved_usernames = self.reserved_usernames,
no_duplicate_emails = self.no_duplicate_emails
)
return self.render(request, self.register_template, {
"form": form,
"message": message,
"openid": request.openid,
"logo": self.logo_path or (urlparse.urljoin(
request.path, "../logo/"
)),
"no_thanks": self.sign_next(request.path),
"action": request.path,
})