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 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_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))