def send_wall_notification(self):
"""Send update notifications for messages posted to a study group wall."""
if not self.project:
return
project = self.project
ulang = get_language()
subject = {}
body = {}
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = render_to_string(
"statuses/emails/wall_updated_subject.txt", {
'status': self,
'project': project,
}).strip()
body[l[0]] = render_to_string("statuses/emails/wall_updated.txt", {
'status': self,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
activate(ulang)
for participation in project.participants():
if self.author != participation.user and (self.important or not participation.no_wall_updates):
pl = participation.user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async(
(participation.user, subject[pl], body[pl]))
def send_sign_up_notification(self):
"""Send sign_up notifications."""
if self.page.slug != 'sign-up':
return
project = self.page.project
is_answer = not self.reply_to
subject = render_to_string(
"content/emails/sign_up_updated_subject.txt", {
'comment': self,
'is_answer': is_answer,
'project': project,
}).strip()
body = render_to_string(
"content/emails/sign_up_updated.txt", {
'comment': self,
'is_answer': is_answer,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
recipients = {project.created_by.username: project.created_by}
if self.reply_to:
comment = self
while comment.reply_to:
comment = comment.reply_to
recipients[comment.author.username] = comment.author
for username in recipients:
if recipients[username] != self.author:
SendUserEmail.apply_async(
(recipients[username], subject, body))
def submission_thanks_handler(sender, **kwargs):
submission = kwargs.get('instance', None)
if not isinstance(submission, Submission):
return
challenge = submission.get_challenge()
if not challenge:
return
user = submission.created_by
share_url = reverse('submission_edit_share', kwargs={
'slug': challenge.slug,
'submission_id': submission.pk
})
submission_url = reverse('submission_show', kwargs={
'slug': challenge.slug,
'submission_id': submission.pk
})
subj = _('Thanks for entering in the Knight-Mozilla Innovation Challenge!')
body = render_to_string('challenges/emails/submission_thanks.txt', {
'share_url': share_url,
'submission_url': submission_url,
})
SendUserEmail.apply_async((user, subj, body))
def follow_handler(sender, **kwargs):
rel = kwargs.get("instance", None)
if not isinstance(rel, Relationship):
return
user_subject = _("%(name)s is following you on Drumbeat!" % {"name": rel.source.name})
project_subject = _("%(name)s is following your project on Drumbeat!" % {"name": rel.source.name})
activity = Activity(actor=rel.source, verb="http://activitystrea.ms/schema/1.0/follow")
subject = _(u"%(name)s is now following")
if rel.target_user:
activity.target_user = rel.target_user
user = rel.target_user
pref_key = "no_email_new_follower"
subject = user_subject
else:
activity.project = rel.target_project
user = rel.target_project.created_by
pref_key = "no_email_new_project_follower"
subject = project_subject
activity.save()
preferences = AccountPreferences.objects.filter(user=user)
for pref in preferences:
if pref.value and pref.key == pref_key:
return
body = render_to_string(
"relationships/emails/new_follower.txt", {"user": rel.source, "project": rel.target_project}
)
SendUserEmail.apply_async((user, subject, body))
def publish(self):
self.is_published = True
self.save()
challenge = self.get_challenge()
# Create activity
msg = '<a href="%s">%s</a>: %s | <a href="%s">Read more</a>' % (
challenge.get_absolute_url(), challenge.title, self.title,
self.get_absolute_url())
status = Status(author=self.created_by,
project=challenge.project,
status=msg)
status.save()
# Send thanks email
user = self.created_by
share_url = reverse('submission_edit_share',
kwargs={
'slug': challenge.slug,
'submission_id': self.pk
})
submission_url = reverse('submission_show',
kwargs={
'slug': challenge.slug,
'submission_id': self.pk
})
subj = _(
'Thanks for entering in the Knight-Mozilla Innovation Challenge!')
body = render_to_string('challenges/emails/submission_thanks.txt', {
'share_url': share_url,
'submission_url': submission_url,
})
SendUserEmail.apply_async((user, subj, body))
def submission_thanks_handler(sender, **kwargs):
submission = kwargs.get('instance', None)
if not isinstance(submission, Submission):
return
challenge = submission.get_challenge()
if not challenge:
return
user = submission.created_by
share_url = reverse('submission_edit_share',
kwargs={
'slug': challenge.slug,
'submission_id': submission.pk
})
submission_url = reverse('submission_show',
kwargs={
'slug': challenge.slug,
'submission_id': submission.pk
})
subj = _('Thanks for entering in the Knight-Mozilla Innovation Challenge!')
body = render_to_string('challenges/emails/submission_thanks.txt', {
'share_url': share_url,
'submission_url': submission_url,
})
SendUserEmail.apply_async((user, subj, body))
def send_wall_notification(self):
"""Send update notifications for messages posted to a study group wall."""
if not self.project:
return
project = self.project
ulang = get_language()
subject = {}
body = {}
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = render_to_string(
"statuses/emails/wall_updated_subject.txt", {
'status': self,
'project': project,
}).strip()
body[l[0]] = render_to_string(
"statuses/emails/wall_updated.txt", {
'status': self,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
activate(ulang)
for participation in project.participants():
if self.author != participation.user and (
self.important or not participation.no_wall_updates):
pl = participation.user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async(
(participation.user, subject[pl], body[pl]))
def follow_handler(sender, **kwargs):
rel = kwargs.get('instance', None)
if not isinstance(rel, Relationship):
return
user_subject = _("%(name)s is following you on Drumbeat!" % {
'name': rel.source.name,
})
project_subject = _("%(name)s is following your project on Drumbeat!" % {
'name': rel.source.name,
})
activity = Activity(actor=rel.source,
verb='http://activitystrea.ms/schema/1.0/follow')
subject = _(u"%(name)s is now following")
if rel.target_user:
activity.target_user = rel.target_user
user = rel.target_user
pref_key = 'no_email_new_follower'
subject = user_subject
else:
activity.project = rel.target_project
user = rel.target_project.created_by
pref_key = 'no_email_new_project_follower'
subject = project_subject
activity.save()
preferences = AccountPreferences.objects.filter(user=user)
for pref in preferences:
if pref.value and pref.key == pref_key:
return
body = render_to_string("relationships/emails/new_follower.txt", {
'user': rel.source,
'project': rel.target_project,
})
SendUserEmail.apply_async((user, subject, body))
def send_creation_notification(self):
"""Send notification when a new project is created."""
project = self
ulang = get_language()
subject = {}
body = {}
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = render_to_string(
"projects/emails/project_created_subject.txt", {
'project': project,
}).strip()
body[l[0]] = render_to_string(
"projects/emails/project_created.txt", {
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
activate(ulang)
for organizer in project.organizers():
if not organizer.no_updates:
ol = organizer.user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async(
(organizer.user, subject[ol], body[ol]))
admin_subject = render_to_string(
"projects/emails/admin_project_created_subject.txt", {
'project': project,
}).strip()
admin_body = render_to_string(
"projects/emails/admin_project_created.txt", {
'project': project,
}).strip()
send_mail(admin_subject, admin_body, '*****@*****.**', ['*****@*****.**'], fail_silently=True)
def report_abuse(request, obj, type):
"""Report abusive or irrelavent content."""
if request.method == "POST":
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
body = """
User %s has reported the following content as objectionable:
Model: %s, ID: %s
""" % (
request.user.get_profile().name,
type,
obj,
)
subject = "Abuse Report"
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
SendUserEmail.apply_async(args=(profile, subject, body))
except:
pass
return render_to_response("drumbeat/report_received.html", {}, context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response(
"drumbeat/report_abuse.html", {"form": form, "obj": obj, "type": type}, context_instance=RequestContext(request)
)
def message_sent_handler(sender, **kwargs):
message = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(message, Message):
return
user = message.recipient
preferences = AccountPreferences.objects.filter(
user=user.get_profile())
for preference in preferences:
if preference.value and preference.key == 'no_email_message_received':
return
sender = message.sender.get_profile()
ulang = get_language()
activate(user.get_profile().preflang or settings.LANGUAGE_CODE)
subject = ugettext('New Message from %(sender)s') % {
'sender': sender,
}
body = render_to_string('drumbeatmail/emails/direct_message.txt', {
'sender': sender,
'message': message.body,
'domain': Site.objects.get_current().domain,
'reply_url': reverse('drumbeatmail_reply', kwargs={
'message': message.pk,
}),
})
activate(ulang)
SendUserEmail.apply_async((user.get_profile(), subject, body))
def report_abuse(request, obj, type):
"""Report abusive or irrelavent content."""
if request.method == 'POST':
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
body = """
User %s has reported the following content as objectionable:
Model: %s, ID: %s
""" % (request.user.get_profile().name, type, obj)
subject = "Abuse Report"
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
SendUserEmail.apply_async(args=(profile, subject, body))
except:
pass
return render_to_response('drumbeat/report_received.html', {},
context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response('drumbeat/report_abuse.html', {
'form': form,
'obj': obj,
'type': type,
},
context_instance=RequestContext(request))
def publish(self):
self.is_published = True
self.save()
challenge = self.get_challenge()
# Create activity
msg = '<a href="%s">%s</a>: %s | <a href="%s">Read more</a>' % (
challenge.get_absolute_url(), challenge.title, self.title,
self.get_absolute_url())
status = Status(author=self.created_by,
project=challenge.project,
status=msg)
status.save()
# Send thanks email
user = self.created_by
share_url = reverse('submission_edit_share', kwargs={
'slug': challenge.slug,
'submission_id': self.pk
})
submission_url = reverse('submission_show', kwargs={
'slug': challenge.slug,
'submission_id': self.pk
})
subj = _('Thanks for entering in the Knight-Mozilla Innovation Challenge!')
body = render_to_string('challenges/emails/submission_thanks.txt', {
'share_url': share_url,
'submission_url': submission_url,
})
SendUserEmail.apply_async((user, subj, body))
def send_sign_up_notification(self):
"""Send sign_up notifications."""
if self.page.slug != 'sign-up':
return
project = self.page.project
is_answer = not self.reply_to
subject = render_to_string("content/emails/sign_up_updated_subject.txt", {
'comment': self,
'is_answer': is_answer,
'project': project,
}).strip()
body = render_to_string("content/emails/sign_up_updated.txt", {
'comment': self,
'is_answer': is_answer,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
recipients = {project.created_by.username: project.created_by}
if self.reply_to:
comment = self
while comment.reply_to:
comment = comment.reply_to
recipients[comment.author.username] = comment.author
for username in recipients:
if recipients[username] != self.author:
SendUserEmail.apply_async((recipients[username], subject, body))
def message_sent_handler(sender, **kwargs):
message = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(message, Message):
return
user = message.recipient
preferences = AccountPreferences.objects.filter(user=user.get_profile())
for preference in preferences:
if preference.value and preference.key == 'no_email_message_received':
return
sender = message.sender.get_profile().display_name
subject = ugettext('New Message from %(display_name)s' % {
'display_name': sender,
})
body = render_to_string(
'drumbeatmail/emails/direct_message.txt', {
'sender':
sender,
'message':
message.body,
'domain':
Site.objects.get_current().domain,
'reply_url':
reverse('drumbeatmail_reply', kwargs={
'message': message.pk,
}),
})
SendUserEmail.apply_async((user.get_profile(), subject, body))
def report_abuse(request, model, app_label, pk):
"""Report abusive or irrelavent content."""
if request.method == 'POST':
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
content_type_cls = get_object_or_404(ContentType, model=model, app_label=app_label).model_class()
instance = get_object_or_404(content_type_cls, pk=pk)
try:
url = request.build_absolute_uri(instance.get_absolute_url())
except NoReverseMatch:
url = request.build_absolute_uri(reverse('dashboard_index'))
body = """
User %s has reported the following content as objectionable:
%s
(model: %s, app_label: %s, pk: %s)
""" % (request.user.get_profile().display_name, url, model, app_label, pk)
subject = "Abuse Report"
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
SendUserEmail.apply_async(args=(profile, subject, body))
except:
pass
return render_to_response('drumbeat/report_received.html', {},
context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response('drumbeat/report_abuse.html', {
'form': form,
'model': model,
'app_label': app_label,
'pk': pk,
}, context_instance=RequestContext(request))
def send_content_notification(instance, is_comment):
"""Send notification when a new page or comment is posted."""
project = instance.project
if not is_comment and not instance.listed:
return
ulang = get_language()
subject = {}
body = {}
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = render_to_string(
"content/emails/content_update_subject.txt", {
'instance': instance,
'is_comment': is_comment,
'project': project,
}).strip()
body[l[0]] = render_to_string(
"content/emails/content_update.txt", {
'instance': instance,
'is_comment': is_comment,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
activate(ulang)
for participation in project.participants():
if instance.author != participation.user and not participation.no_updates:
pl = participation.user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async(
(participation.user, subject[pl], body[pl]))
def follow_handler(sender, **kwargs):
rel = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(rel, Relationship):
return
activity = Activity(actor=rel.source,
verb='http://activitystrea.ms/schema/1.0/follow')
receipts = []
ulang = get_language()
subject = {}
body = {}
if rel.target_user:
activity.target_user = rel.target_user
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = ugettext(
'%(display_name)s is following you on P2PU!') % {
'display_name': rel.source.display_name,
}
preferences = AccountPreferences.objects.filter(user=rel.target_user)
for pref in preferences:
if pref.value and pref.key == 'no_email_new_follower':
break
else:
receipts.append(rel.target_user)
else:
activity.project = rel.target_project
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = ugettext(
'%(display_name)s is following %(project)s on P2PU!') % {
'display_name': rel.source.display_name,
'project': rel.target_project
}
for organizer in rel.target_project.organizers():
if organizer.user != rel.source:
preferences = AccountPreferences.objects.filter(
user=organizer.user)
for pref in preferences:
if pref.value and pref.key == 'no_email_new_project_follower':
break
else:
receipts.append(organizer.user)
activity.save()
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
body[l[0]] = render_to_string(
"relationships/emails/new_follower.txt", {
'user': rel.source,
'project': rel.target_project,
'domain': Site.objects.get_current().domain,
})
activate(ulang)
for user in receipts:
pl = user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async((user, subject[pl], body[pl]))
def send_notification(self):
"""Send notification when a new submission is posted."""
context = {
'submission': self,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'badges/emails/new_submission_subject.txt',
'badges/emails/new_submission.txt', context)
for adopter in self.badge.get_adopters():
SendUserEmail.apply_async((adopter.user, subjects, bodies))
def send_new_signup_answer_notification(answer):
context = {
'answer': answer,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'signups/emails/new_signup_answer_subject.txt',
'signups/emails/new_signup_answer.txt', context)
for organizer in answer.sign_up.project.organizers():
SendUserEmail.apply_async((organizer.user,
subjects, bodies))
def send_comment_notification(self):
context = {
'comment': self,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'replies/emails/post_comment_subject.txt',
'replies/emails/post_comment.txt', context)
recipients = self.page_object.comment_notification_recipients(self)
for recipient in recipients:
if self.author != recipient:
SendUserEmail.apply_async((recipient, subjects, bodies))
def follow_handler(sender, **kwargs):
rel = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(rel, Relationship) or rel.deleted:
return
activity = Activity(actor=rel.source,
verb=verbs['follow'],
target_object=rel)
receipts = []
ulang = get_language()
subject = {}
body = {}
if rel.target_user:
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = ugettext(
'%(user)s is following you on P2PU!') % {
'user': rel.source}
preferences = AccountPreferences.objects.filter(user=rel.target_user)
for pref in preferences:
if pref.value and pref.key == 'no_email_new_follower':
break
else:
receipts.append(rel.target_user)
else:
activity.scope_object = rel.target_project
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
msg = ugettext(
'%(user)s is following %(project)s on P2PU!')
subject[l[0]] = msg % {'user': rel.source,
'project': rel.target_project}
for organizer in rel.target_project.organizers():
if organizer.user != rel.source:
preferences = AccountPreferences.objects.filter(
user=organizer.user, key='no_email_new_project_follower')
for pref in preferences:
if pref.value:
break
else:
receipts.append(organizer.user)
activity.save()
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
body[l[0]] = render_to_string(
"relationships/emails/new_follower.txt", {'user': rel.source,
'project': rel.target_project,
'domain': Site.objects.get_current().domain})
activate(ulang)
for user in receipts:
pl = user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async((user, subject[pl], body[pl]))
def send_comment_notification(self):
context = {
'comment': self,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'replies/emails/post_comment_subject.txt',
'replies/emails/post_comment.txt', context)
recipients = self.page_object.comment_notification_recipients(self)
for recipient in recipients:
if self.author != recipient:
SendUserEmail.apply_async((recipient, subjects, bodies))
def send_creation_notification(self):
"""Send notification when a new project is created."""
context = {"project": self, "domain": Site.objects.get_current().domain}
subjects, bodies = localize_email(
"projects/emails/project_created_subject.txt", "projects/emails/project_created.txt", context
)
for organizer in self.organizers():
SendUserEmail.apply_async((organizer.user, subjects, bodies))
admin_subject = render_to_string("projects/emails/admin_project_created_subject.txt", context).strip()
admin_body = render_to_string("projects/emails/admin_project_created.txt", context).strip()
for admin_email in settings.ADMIN_PROJECT_CREATE_EMAIL:
send_mail(admin_subject, admin_body, admin_email, [admin_email], fail_silently=True)
def send_email_notification(instance):
project = instance.project
if not instance.listed:
return
context = {"instance": instance, "project": project, "domain": Site.objects.get_current().domain}
subjects, bodies = localize_email(
"content/emails/content_update_subject.txt", "content/emails/content_update.txt", context
)
from_organizer = project.organizers().filter(user=instance.author).exists()
for participation in project.participants():
is_author = instance.author == participation.user
if from_organizer:
unsubscribed = participation.no_organizers_content_updates
else:
unsubscribed = participation.no_participants_content_updates
if not is_author and not unsubscribed:
SendUserEmail.apply_async((participation.user, subjects, bodies))
def send_wall_notification(self):
"""Send update notifications for messages posted to a study group wall."""
if not self.project:
return
project = self.project
subject = render_to_string(
"statuses/emails/wall_updated_subject.txt", {"status": self, "project": project}
).strip()
body = render_to_string(
"statuses/emails/wall_updated.txt",
{"status": self, "project": project, "domain": Site.objects.get_current().domain},
).strip()
for participation in project.participants():
if self.author != participation.user and (self.important or not participation.no_wall_updates):
SendUserEmail.apply_async((participation.user, subject, body))
if self.author != project.created_by:
SendUserEmail.apply_async((project.created_by, subject, body))
def send_email_notification(instance):
project = instance.project
if not instance.listed:
return
context = {
'instance': instance,
'project': project,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'content/emails/content_update_subject.txt',
'content/emails/content_update.txt', context)
for participation in project.participants():
is_author = (instance.author == participation.user)
if not is_author and not participation.no_updates:
SendUserEmail.apply_async(
(participation.user, subjects, bodies))
def send_creation_notification(self):
"""Send notification when a new project is created."""
context = {
'project': self,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'projects/emails/project_created_subject.txt',
'projects/emails/project_created.txt', context)
for organizer in self.organizers():
SendUserEmail.apply_async((organizer.user, subjects, bodies))
admin_subject = render_to_string(
"projects/emails/admin_project_created_subject.txt",
context).strip()
admin_body = render_to_string(
"projects/emails/admin_project_created.txt", context).strip()
for admin_email in settings.ADMIN_PROJECT_CREATE_EMAIL:
send_mail(admin_subject, admin_body, admin_email,
[admin_email], fail_silently=True)
def send_update_notification(self, activity, wall=True):
"""Send update notifications."""
subject = _('[p2pu-%(slug)s-updates] Study group %(name)s was updated') % {
'slug': self.slug,
'name': self.name,
}
body = render_to_string("projects/emails/course_updated.txt", {
'activity': activity,
'project': self,
'wall': wall,
'domain': Site.objects.get_current().domain,
})
for participation in self.participants():
if activity.actor == participation.user:
continue
if (wall and participation.no_wall_updates) or (not wall and participation.no_updates):
continue
SendUserEmail.apply_async((participation.user, subject, body))
if activity.actor != self.created_by:
SendUserEmail.apply_async((self.created_by, subject, body))
def report_abuse(request, model, app_label, pk):
"""Report abusive or irrelavent content."""
if request.method == 'POST':
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
content_type_cls = get_object_or_404(
ContentType, model=model, app_label=app_label).model_class()
instance = get_object_or_404(content_type_cls, pk=pk)
try:
url = request.build_absolute_uri(instance.get_absolute_url())
except NoReverseMatch:
url = request.build_absolute_uri(reverse('dashboard'))
ulang = get_language()
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
activate(profile.preflang or settings.LANGUAGE_CODE)
body = render_to_string(
"drumbeat/emails/abuse_report.txt", {
'user': request.user.get_profile(),
'url': url,
'model': model,
'app_label': app_label,
'pk': pk
}).strip()
subject = _("Abuse Report")
SendUserEmail.apply_async(args=(profile, subject, body))
except:
log.debug("Error sending abuse report: %s" % sys.exc_info()[0])
pass
activate(ulang)
return render_to_response('drumbeat/report_received.html', {},
context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response('drumbeat/report_abuse.html', {
'form': form,
'model': model,
'app_label': app_label,
'pk': pk,
},
context_instance=RequestContext(request))
def send_content_notification(instance, is_comment):
"""Send notification when a new page or comment is posted."""
project = instance.project
if not is_comment and not instance.listed:
return
subject = render_to_string("content/emails/content_update_subject.txt", {
'instance': instance,
'is_comment': is_comment,
'project': project,
}).strip()
body = render_to_string("content/emails/content_update.txt", {
'instance': instance,
'is_comment': is_comment,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
for participation in project.participants():
if instance.author != participation.user and not participation.no_updates:
SendUserEmail.apply_async((participation.user, subject, body))
if instance.author != project.created_by:
SendUserEmail.apply_async((project.created_by, subject, body))
def send_email_notification(instance):
project = instance.project
if not instance.listed:
return
context = {
'instance': instance,
'project': project,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'content/emails/content_update_subject.txt',
'content/emails/content_update.txt', context)
from_organizer = project.organizers().filter(user=instance.author).exists()
for participation in project.participants():
is_author = (instance.author == participation.user)
if from_organizer:
unsubscribed = participation.no_organizers_content_updates
else:
unsubscribed = participation.no_participants_content_updates
if not is_author and not unsubscribed:
SendUserEmail.apply_async((participation.user, subjects, bodies))
def message_sent_handler(sender, **kwargs):
message = kwargs.get("instance", None)
if not isinstance(message, Message):
return
user = message.recipient
preferences = AccountPreferences.objects.filter(user=user.get_profile())
for preference in preferences:
if preference.value and preference.key == "no_email_message_received":
return
sender = message.sender.get_profile().display_name
subject = _("New Message from %(display_name)s" % {"display_name": sender})
body = render_to_string(
"drumbeatmail/emails/direct_message.txt",
{
"sender": sender,
"message": message.body,
"domain": Site.objects.get_current().domain,
"reply_url": reverse("drumbeatmail_reply", kwargs={"message": message.pk}),
},
)
SendUserEmail.apply_async((user.get_profile(), subject, body))
def follow_handler(sender, **kwargs):
rel = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(rel, Relationship):
return
user_subject = ugettext('%(display_name)s is following you on P2PU!') % {
'display_name': rel.source.display_name,
}
project_subject = ugettext(
'%(display_name)s is following %(project)s on P2PU!') % {
'display_name': rel.source.display_name,
'project': rel.target_project,
}
activity = Activity(actor=rel.source,
verb='http://activitystrea.ms/schema/1.0/follow')
subject = ugettext('%(display_name)s is now following')
if rel.target_user:
activity.target_user = rel.target_user
user = rel.target_user
pref_key = 'no_email_new_follower'
subject = user_subject
else:
activity.project = rel.target_project
user = rel.target_project.created_by
pref_key = 'no_email_new_project_follower'
subject = project_subject
activity.save()
preferences = AccountPreferences.objects.filter(user=user)
for pref in preferences:
if pref.value and pref.key == pref_key:
return
body = render_to_string(
"relationships/emails/new_follower.txt", {
'user': rel.source,
'project': rel.target_project,
'domain': Site.objects.get_current().domain,
})
SendUserEmail.apply_async((user, subject, body))
def message_sent_handler(sender, **kwargs):
message = kwargs.get('instance', None)
if not isinstance(message, Message):
return
user = message.recipient
preferences = AccountPreferences.objects.filter(
user=user.get_profile())
for preference in preferences:
if preference.value and preference.key == 'no_email_message_received':
return
sender = message.sender.get_profile().name
subject = _('New Message from %(name)s' % {
'name': sender,
})
body = render_to_string('drumbeatmail/emails/direct_message.txt', {
'sender': sender,
'message': message.body,
'reply_url': reverse('drumbeatmail_reply', kwargs={
'message': message.pk,
}),
})
SendUserEmail.apply_async((user.get_profile(), subject, body))
def send_content_notification(instance, is_comment):
"""Send notification when a new page or comment is posted."""
project = instance.project
if not is_comment and not instance.listed:
return
subject = render_to_string("content/emails/content_update_subject.txt", {
'instance': instance,
'is_comment': is_comment,
'project': project,
}).strip()
body = render_to_string(
"content/emails/content_update.txt", {
'instance': instance,
'is_comment': is_comment,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
for participation in project.participants():
if instance.author != participation.user and not participation.no_updates:
SendUserEmail.apply_async((participation.user, subject, body))
if instance.author != project.created_by:
SendUserEmail.apply_async((project.created_by, subject, body))
def follow_handler(sender, **kwargs):
rel = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(rel, Relationship) or rel.deleted:
return
activity = Activity(actor=rel.source,
verb=verbs['follow'],
target_object=rel)
receipts = []
if rel.target_user:
preferences = AccountPreferences.objects.filter(
user=rel.target_user, key='no_email_new_follower')
for pref in preferences:
if pref.value:
break
else:
receipts.append(rel.target_user)
else:
activity.scope_object = rel.target_project
for organizer in rel.target_project.organizers():
if organizer.user != rel.source:
preferences = AccountPreferences.objects.filter(
user=organizer.user, key='no_email_new_project_follower')
for pref in preferences:
if pref.value:
break
else:
receipts.append(organizer.user)
activity.save()
context = {
'user': rel.source,
'project': rel.target_project,
'domain': Site.objects.get_current().domain
}
subjects, bodies = localize_email(
'relationships/emails/new_follower_subject.txt',
'relationships/emails/new_follower.txt', context)
for user in receipts:
SendUserEmail.apply_async((user, subjects, bodies))
def report_abuse(request, model, app_label, pk):
"""Report abusive or irrelavent content."""
if request.method == 'POST':
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
content_type_cls = get_object_or_404(ContentType, model=model, app_label=app_label).model_class()
instance = get_object_or_404(content_type_cls, pk=pk)
try:
url = request.build_absolute_uri(instance.get_absolute_url())
except NoReverseMatch:
url = request.build_absolute_uri(reverse('dashboard_index'))
ulang = get_language()
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
activate(profile.preflang or settings.LANGUAGE_CODE)
body = _("""
User %(display_name)s has reported the following content as objectionable:
%(url)s
(model: %(model)s, app_label: %(app_label)s, pk: %(pk)s)
""" % dict(display_name = request.user.get_profile().display_name,
url = url, model = model, app_label = app_label, pk = pk))
subject = _("Abuse Report")
SendUserEmail.apply_async(args=(profile, subject, body))
except:
log.debug("Error sending abuse report: %s" % sys.exc_info()[0])
pass
activate(ulang)
return render_to_response('drumbeat/report_received.html', {},
context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response('drumbeat/report_abuse.html', {
'form': form,
'model': model,
'app_label': app_label,
'pk': pk,
}, context_instance=RequestContext(request))
def send_creation_notification(self):
"""Send notification when a new project is created."""
project = self
ulang = get_language()
subject = {}
body = {}
domain = Site.objects.get_current().domain
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = render_to_string(
"projects/emails/project_created_subject.txt", {
'project': project,
}).strip()
body[l[0]] = render_to_string(
"projects/emails/project_created.txt", {
'project': project,
'domain': domain,
}).strip()
activate(ulang)
for organizer in project.organizers():
if not organizer.no_updates:
ol = organizer.user.preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async(
(organizer.user, subject[ol], body[ol]))
admin_subject = render_to_string(
"projects/emails/admin_project_created_subject.txt", {
'project': project,
}).strip()
admin_body = render_to_string(
"projects/emails/admin_project_created.txt", {
'project': project,
'domain': domain,
}).strip()
for admin_email in settings.ADMIN_PROJECT_CREATE_EMAIL:
send_mail(admin_subject,
admin_body,
admin_email, [admin_email],
fail_silently=True)
def send_sign_up_notification(self):
"""Send sign_up notifications."""
if self.page.slug != 'sign-up':
return
project = self.page.project
is_answer = not self.reply_to
ulang = get_language()
subject = {}
body = {}
for l in settings.SUPPORTED_LANGUAGES:
activate(l[0])
subject[l[0]] = render_to_string(
"content/emails/sign_up_updated_subject.txt", {
'comment': self,
'is_answer': is_answer,
'project': project,
}).strip()
body[l[0]] = render_to_string(
"content/emails/sign_up_updated.txt", {
'comment': self,
'is_answer': is_answer,
'project': project,
'domain': Site.objects.get_current().domain,
}).strip()
activate(ulang)
recipients = {}
for organizer in project.organizers():
recipients[organizer.user.username] = organizer.user
if self.reply_to:
comment = self
while comment.reply_to:
comment = comment.reply_to
recipients[comment.author.username] = comment.author
for username in recipients:
if recipients[username] != self.author:
pl = recipients[username].preflang or settings.LANGUAGE_CODE
SendUserEmail.apply_async((recipients[username],
subject[pl], body[pl]))
def follow_handler(sender, **kwargs):
rel = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(rel, Relationship):
return
user_subject = ugettext('%(display_name)s is following you on P2PU!') % {
'display_name': rel.source.display_name,
}
project_subject = ugettext('%(display_name)s is following %(project)s on P2PU!') % {
'display_name': rel.source.display_name,
'project': rel.target_project,
}
activity = Activity(actor=rel.source,
verb='http://activitystrea.ms/schema/1.0/follow')
subject = ugettext('%(display_name)s is now following')
if rel.target_user:
activity.target_user = rel.target_user
user = rel.target_user
pref_key = 'no_email_new_follower'
subject = user_subject
else:
activity.project = rel.target_project
user = rel.target_project.created_by
pref_key = 'no_email_new_project_follower'
subject = project_subject
activity.save()
preferences = AccountPreferences.objects.filter(user=user)
for pref in preferences:
if pref.value and pref.key == pref_key:
return
body = render_to_string("relationships/emails/new_follower.txt", {
'user': rel.source,
'project': rel.target_project,
'domain': Site.objects.get_current().domain,
})
SendUserEmail.apply_async((user, subject, body))
def message_sent_handler(sender, **kwargs):
message = kwargs.get("instance", None)
created = kwargs.get("created", False)
if not created or not isinstance(message, Message):
return
recipient = message.recipient.get_profile()
preferences = AccountPreferences.objects.filter(user=recipient, key="no_email_message_received")
for preference in preferences:
if preference.value:
return
sender = message.sender.get_profile()
reply_url = reverse("drumbeatmail_reply", kwargs={"message": message.pk})
msg_body = clean_html("rich", message.body)
context = {
"sender": sender,
"message": msg_body,
"domain": Site.objects.get_current().domain,
"reply_url": reply_url,
}
subjects, bodies = localize_email(
"drumbeatmail/emails/direct_message_subject.txt", "drumbeatmail/emails/direct_message.txt", context
)
SendUserEmail.apply_async((recipient, subjects, bodies))
def send_sign_up_notification(self):
"""Send sign_up notifications."""
if self.page.slug != 'sign-up':
return
project = self.page.project
subject = _('[p2pu-%(slug)s-signup] Study group %(name)s\'s signup page was updated') % {
'slug': project.slug,
'name': project.name,
}
body = render_to_string("content/emails/sign_up_updated.txt", {
'comment': self,
'project': project,
'domain': Site.objects.get_current().domain,
})
recipients = {project.created_by.username: project.created_by}
if self.reply_to:
comment = self
while comment.reply_to:
comment = comment.reply_to
recipients[comment.author.username] = comment.author
for username in recipients:
if recipients[username] != self.author:
SendUserEmail.apply_async((recipients[username], subject, body))
def send_wall_notification(self):
if not self.project:
return
context = {
'status': self,
'project': self.project,
'domain': Site.objects.get_current().domain,
}
subjects, bodies = localize_email(
'statuses/emails/wall_updated_subject.txt',
'statuses/emails/wall_updated.txt', context)
from_organizer = self.project.organizers().filter(
user=self.author).exists()
for participation in self.project.participants():
if self.important:
unsubscribed = False
elif from_organizer:
unsubscribed = participation.no_organizers_wall_updates
else:
unsubscribed = participation.no_participants_wall_updates
if self.author != participation.user and not unsubscribed:
SendUserEmail.apply_async(
(participation.user, subjects, bodies))
def report_abuse(request, model, app_label, pk):
"""Report abusive or irrelavent content."""
if request.method == 'POST':
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
content_type_cls = get_object_or_404(
ContentType, model=model, app_label=app_label).model_class()
instance = get_object_or_404(content_type_cls, pk=pk)
try:
url = request.build_absolute_uri(instance.get_absolute_url())
except NoReverseMatch:
url = request.build_absolute_uri(reverse('dashboard_index'))
body = """
User %s has reported the following content as objectionable:
%s
(model: %s, app_label: %s, pk: %s)
""" % (request.user.get_profile().display_name, url, model, app_label,
pk)
subject = "Abuse Report"
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
SendUserEmail.apply_async(args=(profile, subject, body))
except:
pass
return render_to_response('drumbeat/report_received.html', {},
context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response('drumbeat/report_abuse.html', {
'form': form,
'model': model,
'app_label': app_label,
'pk': pk,
},
context_instance=RequestContext(request))
def report_abuse(request, model, app_label, pk):
"""Report abusive or irrelavent content."""
if request.method == 'POST':
# we only use the form for the csrf middleware. skip validation.
form = AbuseForm(request.POST)
content_type_cls = get_object_or_404(ContentType, model=model,
app_label=app_label).model_class()
instance = get_object_or_404(content_type_cls, pk=pk)
try:
url = request.build_absolute_uri(instance.get_absolute_url())
except NoReverseMatch:
url = request.build_absolute_uri(reverse('dashboard'))
context = {
'user': request.user.get_profile(),
'url': url, 'model': model,
'app_label': app_label, 'pk': pk,
}
subjects, bodies = localize_email(
'drumbeat/emails/abuse_report_subject.txt',
'drumbeat/emails/abuse_report.txt', context)
try:
profile = UserProfile.objects.get(email=settings.ADMINS[0][1])
SendUserEmail.apply_async(args=(profile, subjects, bodies))
except:
log.debug("Error sending abuse report: %s" % sys.exc_info()[0])
pass
return render_to_response('drumbeat/report_received.html', {},
context_instance=RequestContext(request))
else:
form = AbuseForm()
return render_to_response('drumbeat/report_abuse.html', {
'form': form,
'model': model,
'app_label': app_label,
'pk': pk,
}, context_instance=RequestContext(request))
def message_sent_handler(sender, **kwargs):
message = kwargs.get('instance', None)
created = kwargs.get('created', False)
if not created or not isinstance(message, Message):
return
recipient = message.recipient.get_profile()
preferences = AccountPreferences.objects.filter(
user=recipient, key='no_email_message_received')
for preference in preferences:
if preference.value:
return
sender = message.sender.get_profile()
reply_url = reverse('drumbeatmail_reply', kwargs={'message': message.pk})
msg_body = clean_html('rich', message.body)
context = {
'sender': sender,
'message': msg_body,
'domain': Site.objects.get_current().domain,
'reply_url': reply_url,
}
subjects, bodies = localize_email(
'drumbeatmail/emails/direct_message_subject.txt',
'drumbeatmail/emails/direct_message.txt', context)
SendUserEmail.apply_async((recipient, subjects, bodies))
