def feedback(request):
if request.method == "POST":
form = FeedbackForm(request.POST)
if form.is_valid():
context = {'user': request.user}
if not request.user.is_authenticated:
context['email'] = form.cleaned_data.get('email', None)
context['message'] = form.cleaned_data['message']
context['name'] = form.cleaned_data.get('name', None)
recipients = [(adm.username, adm.email)
for adm in User.objects.filter(is_superuser=True)]
send_email(
settings.EMAIL_SUBJECT_PREFIX +
_("Feedback message from %(site_name)s") %
{'site_name': settings.APP_SHORT_NAME}, recipients,
"notifications/feedback.html", context)
msg = _('Thanks for the feedback!')
request.user.message_set.create(message=msg)
return HttpResponseRedirect(get_next_url(request))
else:
form = FeedbackForm(initial={'next': get_next_url(request)})
return render_to_response('feedback.html', {'form': form},
context_instance=RequestContext(request))
def request_temp_login(request):
if request.method == 'POST':
form = TemporaryLoginRequestForm(request.POST)
if form.is_valid():
user = form.user_cache
try:
hash = get_object_or_404(ValidationHash, user=user, type='templogin')
if hash.expiration < datetime.datetime.now():
hash.delete()
return request_temp_login(request)
except:
hash = ValidationHash.objects.create_new(user, 'templogin', [user.id])
send_email(_("Temporary login link"), [(user.username, user.email)], "auth/temp_login_email.html", {
'temp_login_code': hash,
'user': user
})
request.user.message_set.create(message=_("An email has been sent with your temporary login key"))
return HttpResponseRedirect(reverse('index'))
else:
form = TemporaryLoginRequestForm()
return render_to_response(
'auth/temp_login_request.html', {'form': form},
context_instance=RequestContext(request))
def request_temp_login(request):
if request.method == 'POST':
form = TemporaryLoginRequestForm(request.POST)
if form.is_valid():
user = form.user_cache
try:
hash = get_object_or_404(ValidationHash, user=user, type='templogin')
if hash.expiration < datetime.datetime.now():
hash.delete()
return request_temp_login(request)
except:
hash = ValidationHash.objects.create_new(user, 'templogin', [user.id])
send_email(_("Temporary login link"), [(user.username, user.email)], "auth/temp_login_email.html", {
'temp_login_code': hash,
'user': user
})
request.user.message_set.create(message=_("An email has been sent with your temporary login key"))
return HttpResponseRedirect(reverse('index'))
else:
form = TemporaryLoginRequestForm()
return render_to_response(
'auth/temp_login_request.html', {'form': form},
context_instance=RequestContext(request))
def question_posted(instance, **kwargs):
question = instance
subscribers = User.objects.values('email', 'username').filter(
Q(subscription_settings__enable_notifications=True, subscription_settings__new_question='i') |
(Q(subscription_settings__new_question_watched_tags='i') &
Q(marked_tags__name__in=question.tagnames.split(' ')) &
Q(tag_selections__reason='good'))
).exclude(id=question.author.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("New question on %(app_name)s") % dict(app_name=settings.APP_SHORT_NAME),
recipients, "notifications/newquestion.html", {
'question': question,
})
if question.author.subscription_settings.questions_asked:
subscription = QuestionSubscription(question=question, user=question.author)
subscription.save()
new_subscribers = User.objects.filter(
Q(subscription_settings__all_questions=True) |
Q(subscription_settings__all_questions_watched_tags=True,
marked_tags__name__in=question.tagnames.split(' '),
tag_selections__reason='good'))
for user in new_subscribers:
create_subscription_if_not_exists(question, user)
def question_posted(sender, instance, **kwargs):
question = instance.content_object
subscribers = User.objects.values('email', 'username').filter(
Q(subscription_settings__enable_notifications=True, subscription_settings__new_question='i') |
(Q(subscription_settings__new_question_watched_tags='i') &
Q(marked_tags__name__in=question.tagnames.split(' ')) &
Q(tag_selections__reason='good'))
).exclude(id=question.author.id)
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("New question on %s") % settings.APP_SHORT_NAME,
recipients, "notifications/newquestion.html", {
'question': question,
})
if question.author.subscription_settings.questions_asked:
subscription = QuestionSubscription(question=question, user=question.author)
subscription.save()
new_subscribers = User.objects.filter(
Q(subscription_settings__all_questions=True) |
Q(subscription_settings__all_questions_watched_tags=True,
marked_tags__name__in=question.tagnames.split(' '),
tag_selections__reason='good'))
for user in new_subscribers:
create_subscription_if_not_exists(question, user)
def answer_posted(instance, **kwargs):
answer = instance
question = answer.question
subscribers = (
question.subscribers.values("email", "username")
.filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_answers=True,
subscription_settings__subscribed_questions="i",
)
.exclude(id=answer.author.id)
.distinct()
)
recipients = create_recipients_dict(subscribers)
send_email(
settings.EMAIL_SUBJECT_PREFIX + _("New answer to '%(question_title)s'") % dict(question_title=question.title),
recipients,
"notifications/newanswer.html",
{"question": question, "answer": answer},
)
if answer.author.subscription_settings.questions_answered:
create_subscription_if_not_exists(question, answer.author)
def member_joined(action, new):
subscribers = User.objects.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__member_joins='i'
).exclude(id=action.user.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("%(username)s is a new member on %(app_name)s") % dict(username=action.user.username, app_name=settings.APP_SHORT_NAME),
recipients, "notifications/newmember.html", {
'newmember': action.user,
}, threaded=False)
def answer_accepted(action, new):
question = action.node.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_accepted=True,
subscription_settings__subscribed_questions='i'
).exclude(id=action.node.accepted.by.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("An answer to '%(question_title)s' was accepted") % dict(question_title=question.title),
recipients, "notifications/answeraccepted.html", {
'question': question,
'answer': action.node
}, threaded=False)
def answer_accepted(sender, instance, **kwargs):
answer = instance.content_object
question = answer.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_accepted=True,
subscription_settings__subscribed_questions='i'
).exclude(id=question.author.id)
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("An answer to '%s' was accepted") % question.title,
recipients, "notifications/answeraccepted.html", {
'question': question,
'answer': answer
})
def answer_accepted(instance, created, **kwargs):
if not created and 'accepted' in instance.get_dirty_fields() and instance.accepted:
question = instance.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_accepted=True,
subscription_settings__subscribed_questions='i'
).exclude(id=instance.accepted_by.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("An answer to '%(question_title)s' was accepted") % dict(question_title=question.title),
recipients, "notifications/answeraccepted.html", {
'question': question,
'answer': instance
})
def answer_accepted(instance, created, **kwargs):
if not created and 'accepted' in instance.get_dirty_fields() and instance.accepted:
question = instance.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_accepted=True,
subscription_settings__subscribed_questions='i'
).exclude(id=instance.accepted_by.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("An answer to '%(question_title)s' was accepted") % dict(question_title=question.title),
recipients, "notifications/answeraccepted.html", {
'question': question,
'answer': instance
})
def member_joined(sender, instance, created, **kwargs):
if not created:
return
subscribers = User.objects.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__member_joins='i'
).exclude(id=instance.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("%(username)s is a new member on %(app_name)s") % dict(username=instance.username, app_name=settings.APP_SHORT_NAME),
recipients, "notifications/newmember.html", {
'newmember': instance,
})
sub_settings = SubscriptionSettings(user=instance)
sub_settings.save()
def member_joined(sender, instance, **kwargs):
if not instance._is_new:
return
subscribers = User.objects.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__member_joins='i'
).exclude(id=instance.id)
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("%s is a new member on %s") % (instance.username, settings.APP_SHORT_NAME),
recipients, "notifications/newmember.html", {
'newmember': instance,
})
sub_settings = SubscriptionSettings(user=instance)
sub_settings.save()
def answer_posted(action, new):
answer = action.node
question = answer.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_answers=True,
subscription_settings__subscribed_questions='i'
).exclude(id=answer.author.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("New answer to '%(question_title)s'") % dict(question_title=question.title),
recipients, "notifications/newanswer.html", {
'question': question,
'answer': answer
}, threaded=False)
if answer.author.subscription_settings.questions_answered:
create_subscription_if_not_exists(question, answer.author)
def answer_posted(instance, **kwargs):
answer = instance
question = answer.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_answers=True,
subscription_settings__subscribed_questions='i'
).exclude(id=answer.author.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("New answer to '%(question_title)s'") % dict(question_title=question.title),
recipients, "notifications/newanswer.html", {
'question': question,
'answer': answer
})
if answer.author.subscription_settings.questions_answered:
create_subscription_if_not_exists(question, answer.author)
def answer_posted(sender, instance, **kwargs):
answer = instance.content_object
question = answer.question
subscribers = question.subscribers.values('email', 'username').filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_answers=True,
subscription_settings__subscribed_questions='i'
).exclude(id=answer.author.id)
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("New answer to '%s'") % question.title,
recipients, "notifications/newanswer.html", {
'question': question,
'answer': answer
})
if answer.author.subscription_settings.questions_answered:
create_subscription_if_not_exists(question, answer.author)
def comment_posted(instance, **kwargs):
comment = instance
post = comment.content_object
if post.__class__ == Question:
question = post
else:
question = post.question
subscribers = question.subscribers.values("email", "username")
q_filter = Q(subscription_settings__notify_comments=True) | Q(
subscription_settings__notify_comments_own_post=True, id=post.author.id
)
inreply = re.search("@\w+", comment.comment)
if inreply is not None:
q_filter = q_filter | Q(
subscription_settings__notify_reply_to_comments=True,
username__istartswith=inreply.group(0)[1:],
comments__object_id=post.id,
comments__content_type=ContentType.objects.get_for_model(post.__class__),
)
subscribers = (
subscribers.filter(
q_filter, subscription_settings__subscribed_questions="i", subscription_settings__enable_notifications=True
)
.exclude(id=comment.user.id)
.distinct()
)
recipients = create_recipients_dict(subscribers)
send_email(
settings.EMAIL_SUBJECT_PREFIX + _("New comment on %(question_title)s") % dict(question_title=question.title),
recipients,
"notifications/newcomment.html",
{"comment": comment, "post": post, "question": question},
)
if comment.user.subscription_settings.questions_commented:
create_subscription_if_not_exists(question, comment.user)
def comment_posted(sender, instance, **kwargs):
comment = instance.content_object
post = comment.content_object
if post.__class__ == Question:
question = post
else:
question = post.question
subscribers = question.subscribers.values('email', 'username')
q_filter = Q(subscription_settings__notify_comments=True) | Q(
subscription_settings__notify_comments_own_post=True,
id=post.author.id)
#inreply = re.search('@\w+', comment.comment)
#if inreply is not None:
# q_filter = q_filter | Q(subscription_settings__notify_reply_to_comments=True,
# username__istartswith=inreply.group(0)[1:],
# comments__object_id=post.id,
# comments__content_type=ContentType.objects.get_for_model(post.__class__)
# )
subscribers = subscribers.filter(
q_filter,
subscription_settings__subscribed_questions='i',
subscription_settings__enable_notifications=True).exclude(
id=comment.user.id)
recipients = create_recipients_dict(subscribers)
send_email(
settings.EMAIL_SUBJECT_PREFIX +
_("New comment on %s") % question.title, recipients,
"notifications/newcomment.html", {
'comment': comment,
'post': post,
'question': question,
})
if comment.user.subscription_settings.questions_commented:
create_subscription_if_not_exists(question, comment.user)
def question_posted(instance, **kwargs):
question = instance
subscribers = (
User.objects.values("email", "username")
.filter(
Q(subscription_settings__enable_notifications=True, subscription_settings__new_question="i")
| (
Q(subscription_settings__new_question_watched_tags="i")
& Q(marked_tags__name__in=question.tagnames.split(" "))
& Q(tag_selections__reason="good")
)
)
.exclude(id=question.author.id)
.distinct()
)
recipients = create_recipients_dict(subscribers)
send_email(
settings.EMAIL_SUBJECT_PREFIX + _("New question on %(app_name)s") % dict(app_name=settings.APP_SHORT_NAME),
recipients,
"notifications/newquestion.html",
{"question": question},
)
if question.author.subscription_settings.questions_asked:
subscription = QuestionSubscription(question=question, user=question.author)
subscription.save()
new_subscribers = User.objects.filter(
Q(subscription_settings__all_questions=True)
| Q(
subscription_settings__all_questions_watched_tags=True,
marked_tags__name__in=question.tagnames.split(" "),
tag_selections__reason="good",
)
)
for user in new_subscribers:
create_subscription_if_not_exists(question, user)
def feedback(request):
if request.method == "POST":
form = FeedbackForm(request.POST)
if form.is_valid():
context = {'user': request.user}
if not request.user.is_authenticated:
context['email'] = form.cleaned_data.get('email',None)
context['message'] = form.cleaned_data['message']
context['name'] = form.cleaned_data.get('name',None)
recipients = [(adm.username, adm.email) for adm in User.objects.filter(is_superuser=True)]
send_email(settings.EMAIL_SUBJECT_PREFIX + _("Feedback message from %(site_name)s") % {'site_name': settings.APP_SHORT_NAME},
recipients, "notifications/feedback.html", context)
msg = _('Thanks for the feedback!')
request.user.message_set.create(message=msg)
return HttpResponseRedirect(get_next_url(request))
else:
form = FeedbackForm(initial={'next':get_next_url(request)})
return render_to_response('feedback.html', {'form': form}, context_instance=RequestContext(request))
def comment_posted(instance, **kwargs):
comment = instance
post = comment.content_object
if post.__class__ == Question:
question = post
else:
question = post.question
subscribers = question.subscribers.values('email', 'username')
q_filter = Q(subscription_settings__notify_comments=True) | Q(subscription_settings__notify_comments_own_post=True, id=post.author.id)
inreply = re.search('@\w+', comment.comment)
if inreply is not None:
q_filter = q_filter | Q(subscription_settings__notify_reply_to_comments=True,
username__istartswith=inreply.group(0)[1:],
comments__object_id=post.id,
comments__content_type=ContentType.objects.get_for_model(post.__class__)
)
subscribers = subscribers.filter(
q_filter, subscription_settings__subscribed_questions='i', subscription_settings__enable_notifications=True
).exclude(id=comment.user.id).distinct()
recipients = create_recipients_dict(subscribers)
send_email(settings.EMAIL_SUBJECT_PREFIX + _("New comment on %(question_title)s") % dict(question_title=question.title),
recipients, "notifications/newcomment.html", {
'comment': comment,
'post': post,
'question': question,
})
if comment.user.subscription_settings.questions_commented:
create_subscription_if_not_exists(question, comment.user)
def member_joined(sender, instance, created, **kwargs):
if not created:
return
subscribers = (
User.objects.values("email", "username")
.filter(subscription_settings__enable_notifications=True, subscription_settings__member_joins="i")
.exclude(id=instance.id)
.distinct()
)
recipients = create_recipients_dict(subscribers)
send_email(
settings.EMAIL_SUBJECT_PREFIX
+ _("%(username)s is a new member on %(app_name)s")
% dict(username=instance.username, app_name=settings.APP_SHORT_NAME),
recipients,
"notifications/newmember.html",
{"newmember": instance},
)
sub_settings = SubscriptionSettings(user=instance)
sub_settings.save()
def send_validation_email(user):
hash = ValidationHash.objects.create_new(user, 'email', [user.email])
send_email(_("Email Validation"), [(user.username, user.email)], "auth/email_validation.html", {
'validation_code': hash,
'user': user
})
def send_validation_email(user):
hash = ValidationHash.objects.create_new(user, 'email', [user.email])
send_email(_("Email Validation"), [(user.username, user.email)], "auth/email_validation.html", {
'validation_code': hash,
'user': user
})
def send_digest(self, name, char_in_db, control_date):
new_questions, question_records = self.prepare_activity(control_date)
new_users = User.objects.filter(date_joined__gt=control_date)
digest_subject = settings.EMAIL_SUBJECT_PREFIX + _('Daily digest')
users = User.objects.filter(
subscription_settings__enable_notifications=True)
msgs = []
for u in users:
context = {
'user': u,
'digest_type': name,
}
if u.subscription_settings.member_joins == char_in_db:
context['new_users'] = new_users
else:
context['new_users'] = False
if u.subscription_settings.subscribed_questions == char_in_db:
activity_in_subscriptions = []
for id, r in question_records.items():
try:
subscription = QuestionSubscription.objects.get(
question=r.question, user=u)
record = r.get_activity_since(subscription.last_view)
if not u.subscription_settings.notify_answers:
del record['answers']
if not u.subscription_settings.notify_comments:
if u.subscription_settings.notify_comments_own_post:
record.comments = [
a for a in record.comments if
a.content_object.content_object.author == u
]
record['own_comments_only'] = True
else:
del record['comments']
if not u.subscription_settings.notify_accepted:
del record['accepted']
if record.get('answers', False) or record.get(
'comments', False) or record.get(
'accepted', False):
activity_in_subscriptions.append({
'question': r.question,
'activity': record
})
except:
pass
context[
'activity_in_subscriptions'] = activity_in_subscriptions
else:
context['activity_in_subscriptions'] = False
if u.subscription_settings.new_question == char_in_db:
context['new_questions'] = new_questions
context['watched_tags_only'] = False
elif u.subscription_settings.new_question_watched_tags == char_in_db:
context['new_questions'] = [
q for q in new_questions
if q.tags.filter(id__in=u.marked_tags.filter(
user_selections__reason='good')).count() > 0
]
context['watched_tags_only'] = True
else:
context['new_questions'] = False
if context['new_users'] or context[
'activity_in_subscriptions'] or context['new_questions']:
send_email(digest_subject, (u.username, u.email),
"notifications/digest.html",
context,
threaded=False)
def send_digest(self, name, char_in_db, control_date):
new_questions, question_records = self.prepare_activity(control_date)
new_users = User.objects.filter(date_joined__gt=control_date)
digest_subject = settings.EMAIL_SUBJECT_PREFIX + _('Daily digest')
users = User.objects.filter(subscription_settings__enable_notifications=True)
msgs = []
for u in users:
context = {
'user': u,
'digest_type': name,
}
if u.subscription_settings.member_joins == char_in_db:
context['new_users'] = new_users
else:
context['new_users'] = False
if u.subscription_settings.subscribed_questions == char_in_db:
activity_in_subscriptions = []
for id, r in question_records.items():
try:
subscription = QuestionSubscription.objects.get(question=r.question, user=u)
record = r.get_activity_since(subscription.last_view)
if not u.subscription_settings.notify_answers:
del record['answers']
if not u.subscription_settings.notify_comments:
if u.subscription_settings.notify_comments_own_post:
record.comments = [a for a in record.comments if a.user == u]
record['own_comments_only'] = True
else:
del record['comments']
if not u.subscription_settings.notify_accepted:
del record['accepted']
if record.get('answers', False) or record.get('comments', False) or record.get('accepted', False):
activity_in_subscriptions.append({'question': r.question, 'activity': record})
except:
pass
context['activity_in_subscriptions'] = activity_in_subscriptions
else:
context['activity_in_subscriptions'] = False
if u.subscription_settings.new_question == char_in_db:
context['new_questions'] = new_questions
context['watched_tags_only'] = False
elif u.subscription_settings.new_question_watched_tags == char_in_db:
context['new_questions'] = [q for q in new_questions if
q.tags.filter(id__in=u.marked_tags.filter(user_selections__reason='good')).count() > 0]
context['watched_tags_only'] = True
else:
context['new_questions'] = False
if context['new_users'] or context['activity_in_subscriptions'] or context['new_questions']:
send_email(digest_subject, [(u.username, u.email)], "notifications/digest.html", context, threaded=False)
