def team_member_new(member_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import TeamMember
member = TeamMember.objects.get(pk=member_pk)
if not _team_sends_notification(member.team,
'block_team_member_new_message'):
return False
from videos.models import Action
from teams.models import TeamMember
# the feed item should appear on the timeline for all team members
# as a team might have thousands of members, this one item has
# to show up on all of them
Action.create_new_member_handler(member)
# notify admins and owners through messages
notifiable = TeamMember.objects.filter(
team=member.team,
role__in=[TeamMember.ROLE_ADMIN,
TeamMember.ROLE_OWNER]).exclude(pk=member.pk)
for m in notifiable:
context = {
"new_member": member.user,
"team": member.team,
"user": m.user,
"role": member.role,
"url_base": get_url_base(),
}
body = render_to_string("messages/team-new-member.txt", context)
subject = ugettext("%s team has a new member" % (member.team))
if m.user.notify_by_message:
msg = Message()
msg.subject = subject
msg.content = body
msg.user = m.user
msg.object = m.team
msg.save()
template_name = "messages/email/team-new-member.html"
Meter('templated-emails-sent-by-type.teams.new-member').inc()
send_templated_email(m.user, subject, template_name, context)
# now send welcome mail to the new member
template_name = "messages/team-welcome.txt"
context = {
"team": member.team,
"url_base": get_url_base(),
"role": member.role,
"user": member.user,
}
body = render_to_string(template_name, context)
msg = Message()
msg.subject = ugettext("You've joined the %s team!" % (member.team))
msg.content = body
msg.user = member.user
msg.object = member.team
msg.save()
template_name = "messages/email/team-welcome.html"
Meter('templated-emails-sent-by-type.teams.welcome').inc()
send_templated_email(msg.user, msg.subject, template_name, context)
def team_member_leave(team_pk, user_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import TeamMember, Team
user = User.objects.get(pk=user_pk)
team = Team.objects.get(pk=team_pk)
if not team_sends_notification(
team, 'block_team_member_leave_message') or not user.is_active:
return False
# the feed item should appear on the timeline for all team members
# as a team might have thousands of members, this one item has
# to show up on all of them
# notify admins and owners through messages
notifiable = TeamMember.objects.filter(
team=team,
user__is_active=True,
role__in=[TeamMember.ROLE_ADMIN, TeamMember.ROLE_OWNER])
subject = fmt(ugettext(u"%(user)s has left the %(team)s team"),
user=user,
team=team)
for m in notifiable:
context = {
"parting_member": user,
"team": team,
"user": m.user,
"url_base": get_url_base(),
}
body = render_to_string("messages/team-member-left.txt", context)
if m.user.notify_by_message:
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = body
msg.user = m.user
msg.object = team
msg.save()
send_templated_email(m.user, subject,
"messages/email/team-member-left.html", context)
context = {
"team": team,
"user": user,
"url_base": get_url_base(),
}
subject = fmt(ugettext("You've left the %(team)s team!"), team=team)
if user.notify_by_message:
template_name = "messages/team-member-you-have-left.txt"
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = render_to_string(template_name, context)
msg.user = user
msg.object = team
msg.save()
template_name = "messages/email/team-member-you-have-left.html"
send_templated_email(user, subject, template_name, context)
def team_member_leave(team_pk, user_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import TeamMember, Team
user = User.objects.get(pk=user_pk)
team = Team.objects.get(pk=team_pk)
from videos.models import Action
# the feed item should appear on the timeline for all team members
# as a team might have thousands of members, this one item has
# to show up on all of them
Action.create_member_left_handler(team, user)
# notify admins and owners through messages
notifiable = TeamMember.objects.filter(
team=team, role__in=[TeamMember.ROLE_ADMIN, TeamMember.ROLE_OWNER])
subject = ugettext(u"%(user)s has left the %(team)s team" %
dict(user=user, team=team))
for m in notifiable:
context = {
"parting_member": user,
"team": team,
"user": m.user,
"url_base": get_url_base(),
}
body = render_to_string("messages/team-member-left.txt", context)
if m.user.notify_by_message:
msg = Message()
msg.subject = subject
msg.content = body
msg.user = m.user
msg.object = team
msg.save()
Meter('templated-emails-sent-by-type.teams.someone-left').inc()
send_templated_email(m.user, subject,
"messages/email/team-member-left.html", context)
context = {
"team": team,
"user": user,
"url_base": get_url_base(),
}
subject = ugettext("You've left the %s team!" % (team))
if user.notify_by_message:
template_name = "messages/team-member-you-have-left.txt"
msg = Message()
msg.subject = subject
msg.content = render_to_string(template_name, context)
msg.user = user
msg.object = team
msg.save()
template_name = "messages/email/team-member-you-have-left.html"
Meter('templated-emails-sent-by-type.teams.you-left').inc()
send_templated_email(user, subject, template_name, context)
def team_application_denied(application_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import Application
application = Application.objects.get(pk=application_pk)
if not team_sends_notification(application.team,
'block_application_denided_message'
) or not application.user.is_active:
return False
template_name = "messages/email/team-application-denied.html"
context = {
"team": application.team,
"user": application.user,
"url_base": get_url_base(),
"note": application.note,
}
subject = fmt(ugettext(u'Your application to join the %(team)s '
u'team has been declined'),
team=application.team.name)
if application.user.notify_by_message:
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = render_to_string("messages/team-application-denied.txt",
context)
msg.user = application.user
msg.object = application.team
msg.save()
send_templated_email(application.user, subject, template_name, context)
def send_reject_notification(task_pk, sent_back):
raise NotImplementedError()
from teams.models import Task
from videos.models import Action
from messages.models import Message
try:
task = Task.objects.select_related(
"team_video__video", "team_video", "assignee", "subtitle_version").get(
pk=task_pk)
except Task.DoesNotExist:
return False
if task.new_review_base_version:
user = task.new_review_base_version.author
else:
user = version.author
if not user.is_active:
return False
version = task.get_subtitle_version()
subject = ugettext(u"Your subtitles were not accepted")
task_language = get_language_label(task.language)
reviewer = task.assignee
video = task.team_video.video
subs_url = "%s%s" % (get_url_base(), reverse("videos:translation_history", kwargs={
'video_id': video.video_id,
'lang': task.language,
'lang_id': version.subtitle_language.pk,
}))
reviewer_message_url = "%s%s?user=%s" % (
get_url_base(), reverse("messages:new"), reviewer.username)
context = {
"team":task.team,
"title": version.subtitle_language.get_title(),
"user":user,
"task_language": task_language,
"url_base":get_url_base(),
"task":task,
"reviewer":reviewer,
"note":task.body,
"sent_back": sent_back,
"subs_url": subs_url,
"reviewer_message_url": reviewer_message_url,
}
msg = None
if user.notify_by_message:
template_name = "messages/team-task-rejected.txt"
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = render_to_string(template_name,context)
msg.user = user
msg.object = task.team
msg.save()
template_name = "messages/email/team-task-rejected.html"
email_res = send_templated_email(user, subject, template_name, context)
Action.create_rejected_video_handler(version, reviewer)
return msg, email_res
def team_application_denied(application_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import Application
application = Application.objects.get(pk=application_pk)
template_name = "messages/email/team-application-denied.html"
context = {
"team": application.team,
"user": application.user,
"url_base": get_url_base(),
"note": application.note,
}
if application.user.notify_by_message:
msg = Message()
msg.subject = ugettext(
u'Your application to join the %s team has been declined' %
application.team.name)
msg.content = render_to_string("messages/team-application-denied.txt",
context)
msg.user = application.user
msg.object = application.team
msg.save()
Meter('templated-emails-sent-by-type.teams.application-declined').inc()
send_templated_email(msg.user, msg.subject, template_name, context)
application.delete()
def application_sent(application_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import Application, TeamMember
application = Application.objects.get(pk=application_pk)
notifiable = TeamMember.objects.filter(
team=application.team,
role__in=[TeamMember.ROLE_ADMIN, TeamMember.ROLE_OWNER])
for m in notifiable:
template_name = "messages/application-sent.txt"
context = {
"applicant": application.user,
"url_base": get_url_base(),
"team": application.team,
"note": application.note,
"user": m.user,
}
body = render_to_string(template_name, context)
subject = ugettext(u'%(user)s is applying for team %(team)s') % dict(
user=application.user, team=application.team.name)
if m.user.notify_by_message:
msg = Message()
msg.subject = subject
msg.content = body
msg.user = m.user
msg.object = application.team
msg.author = application.user
msg.save()
Meter('templated-emails-sent-by-type.teams.application-sent').inc()
send_templated_email(m.user, subject,
"messages/email/application-sent-email.html",
context)
return True
def send_complete_message(self):
msg = Message()
msg.user = self.user
msg.subject = u'Your request was completed'
msg.object = self
msg.save()
return msg
def send_complete_message(self):
msg = Message()
msg.user = self.user
msg.subject = u'Your request was completed'
msg.object = self
msg.save()
return msg
def invite_send_message(sender, instance, created, **kwargs):
if created:
msg = Message()
msg.subject = ugettext(u'Invitation to join a team')
msg.user = instance.user
msg.object = instance
msg.author = instance.author
msg.save()
def invite_send_message(sender, instance, created, **kwargs):
if created:
msg = Message()
msg.subject = ugettext(u'Invitation to join a team')
msg.user = instance.user
msg.object = instance
msg.author = instance.author
msg.save()
def team_invitation_sent(invite_pk):
from messages.models import Message
from teams.models import Invite, Setting, TeamMember
invite = Invite.objects.get(pk=invite_pk)
if not team_sends_notification(
invite.team,
'block_invitation_sent_message') or not invite.user.is_active:
return False
# does this team have a custom message for this?
team_default_message = None
messages = Setting.objects.messages().filter(team=invite.team)
if messages.exists():
data = {}
for m in messages:
data[m.get_key_display()] = m.data
mapping = {
TeamMember.ROLE_ADMIN: data['messages_admin'],
TeamMember.ROLE_MANAGER: data['messages_manager'],
TeamMember.ROLE_CONTRIBUTOR: data['messages_invite'],
}
team_default_message = mapping.get(invite.role, None)
context = {
'invite': invite,
'role': invite.role,
"user": invite.user,
"inviter": invite.author,
"team": invite.team,
"invite_pk": invite_pk,
'note': invite.note,
'custom_message': team_default_message,
'url_base': get_url_base(),
}
title = fmt(ugettext(u"You've been invited to team %(team)s on Amara"),
team=invite.team.name)
if invite.user.notify_by_message:
body = render_to_string("messages/team-you-have-been-invited.txt",
context)
msg = Message()
msg.message_type = 'S'
msg.subject = title
msg.user = invite.user
msg.object = invite
msg.author = invite.author
msg.content = body
msg.save()
template_name = 'messages/email/team-you-have-been-invited.html'
return send_templated_email(invite.user, title, template_name, context)
def team_task_assigned(task_pk):
from teams.models import Task
from messages.models import Message
try:
task = Task.objects.select_related("team_video__video", "team_video",
"assignee").get(
pk=task_pk,
assignee__isnull=False)
except Task.DoesNotExist:
return False
task_type = Task.TYPE_NAMES[task.type]
subject = ugettext(u"You have a new task assignment on Amara!")
user = task.assignee
if not team_sends_notification(
task.team, 'block_task_assigned_message') or not user.is_active:
return False
task_language = None
if task.language:
task_language = get_language_label(task.language)
context = {
"team": task.team,
"user": user,
"task_type": task_type,
"task_language": task_language,
"url_base": get_url_base(),
"task": task,
}
msg = None
if user.notify_by_message:
template_name = "messages/team-task-assigned.txt"
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = render_to_string(template_name, context)
msg.user = user
msg.object = task.team
msg.save()
template_name = "messages/email/team-task-assigned.html"
email_res = send_templated_email(user, subject, template_name, context)
return msg, email_res
def save(self):
messages = []
team = self.cleaned_data['team']
languages = self.cleaned_data['languages']
members = team.users.exclude(pk=self.author.pk)
if languages:
members = members.filter(userlanguage__language__in=languages).distinct()
for user in members:
message = Message(user=user)
message.author = self.author
message.content = self.cleaned_data['content']
message.subject = self.cleaned_data['subject']
message.object = team
message.save()
messages.append(message)
return messages
def save(self):
messages = []
team = self.cleaned_data['team']
languages = self.cleaned_data['languages']
members = team.users.exclude(pk=self.author.pk)
if languages:
members = members.filter(userlanguage__language__in=languages).distinct()
for user in members:
message = Message(user=user)
message.author = self.author
message.content = self.cleaned_data['content']
message.subject = self.cleaned_data['subject']
message.object = team
message.save()
messages.append(message)
return messages
def _reviewed_notification(task_pk, status):
from teams.models import Task
from videos.models import Action
from messages.models import Message
try:
task = Task.objects.select_related("team_video__video", "team_video",
"assignee").get(pk=task_pk)
except Task.DoesNotExist:
return False
subject = ugettext(u"Your subtitles have been reviewed")
if status == REVIEWED_AND_PUBLISHED:
subject += ugettext(" and published")
if task.review_base_version:
user = task.review_base_version.user
else:
user = task.subtitle_version.user
task_language = get_language_label(task.language)
reviewer = task.assignee
video = task.team_video.video
subs_url = "%s%s" % (get_url_base(),
reverse("videos:translation_history",
kwargs={
'video_id': video.video_id,
'lang': task.language,
'lang_id':
task.subtitle_version.language.pk,
}))
reviewer_message_url = "%s%s?user=%s" % (
get_url_base(), reverse("messages:new"), reviewer.username)
reviewer_profile_url = "%s%s" % (get_url_base(),
reverse("profiles:profile",
kwargs={'user_id': reviewer.id}))
perform_task_url = "%s%s" % (get_url_base(),
reverse("teams:perform_task",
kwargs={
'slug': task.team.slug,
'task_pk': task_pk
}))
context = {
"team": task.team,
"title": task.subtitle_version.language.get_title(),
"user": user,
"task_language": task_language,
"url_base": get_url_base(),
"task": task,
"reviewer": reviewer,
"note": task.body,
"reviewed_and_pending_approval":
status == REVIEWED_AND_PENDING_APPROVAL,
"sent_back": status == REVIEWED_AND_SENT_BACK,
"reviewed_and_published": status == REVIEWED_AND_PUBLISHED,
"subs_url": subs_url,
"reviewer_message_url": reviewer_message_url,
"reviewer_profile_url": reviewer_profile_url,
"perform_task_url": perform_task_url,
}
msg = None
if user.notify_by_message:
template_name = "messages/team-task-reviewed.txt"
msg = Message()
msg.subject = subject
msg.content = render_to_string(template_name, context)
msg.user = user
msg.object = task.team
msg.save()
template_name = "messages/email/team-task-reviewed.html"
Meter('templated-emails-sent-by-type.teams.task-reviewed').inc()
email_res = send_templated_email(user, subject, template_name, context)
if status == REVIEWED_AND_SENT_BACK:
if task.type == Task.TYPE_IDS['Review']:
Action.create_declined_video_handler(task.subtitle_version,
reviewer)
else:
Action.create_rejected_video_handler(task.subtitle_version,
reviewer)
elif status == REVIEWED_AND_PUBLISHED:
Action.create_approved_video_handler(task.subtitle_version, reviewer)
elif status == REVIEWED_AND_PENDING_APPROVAL:
Action.create_accepted_video_handler(task.subtitle_version, reviewer)
return msg, email_res
def invite_send_message(sender, instance, created, **kwargs):
if created:
msg = Message()
msg.user = instance.user
msg.object = instance
msg.save()
def invite_send_message(sender, instance, created, **kwargs):
if created:
msg = Message()
msg.user = instance.user
msg.object = instance
msg.save()
def approved_notification(task_pk, published=False):
"""
On approval, it can be sent back (published=False) or
approved and published
"""
from teams.models import Task
from activity.models import ActivityRecord
from messages.models import Message
from teams.models import TeamNotificationSetting
try:
task = Task.objects.select_related("team_video__video", "team_video",
"assignee",
"subtitle_version").get(pk=task_pk)
if not team_sends_notification(task.team, 'block_approved_message'):
return False
except Task.DoesNotExist:
return False
# some tasks are being created without subtitles version, see
# https://unisubs.sifterapp.com/projects/12298/issues/552092/comments
users_to_notify = set()
version = task.get_subtitle_version()
if task.new_review_base_version:
user = task.new_review_base_version.author
else:
user = version.author
if user.is_active:
users_to_notify.add(user)
if published:
subject = ugettext(u"Your subtitles have been approved and published!")
template_txt = "messages/team-task-approved-published.txt"
template_html = "messages/email/team-task-approved-published.html"
# Not sure whether it is the right place to send notification
# but should work around the approval when there is no new sub version
TeamNotificationSetting.objects.notify_team(
task.team.pk,
TeamNotificationSetting.EVENT_SUBTITLE_APPROVED,
video_id=version.video.video_id,
language_pk=version.subtitle_language.pk,
version_pk=version.pk)
subtitler = task.get_subtitler()
if subtitler is not None and \
subtitler.is_active:
users_to_notify.add(subtitler)
else:
template_txt = "messages/team-task-approved-sentback.txt"
template_html = "messages/email/team-task-approved-sentback.html"
subject = ugettext(
u"Your subtitles have been returned for further editing")
reviewer = task.assignee
ActivityRecord.objects.create_for_version_approved(version, reviewer)
if len(users_to_notify) > 0:
task_language = get_language_label(task.language)
video = task.team_video.video
subs_url = "%s%s" % (get_url_base(),
reverse("videos:translation_history",
kwargs={
'video_id': video.video_id,
'lang': task.language,
'lang_id':
version.subtitle_language.pk,
}))
reviewer_message_url = "%s%s?user=%s" % (
get_url_base(), reverse("messages:new"), reviewer.username)
context = {
"team": task.team,
"title": version.subtitle_language.get_title(),
"task_language": task_language,
"url_base": get_url_base(),
"task": task,
"reviewer": reviewer,
"note": task.body,
"subs_url": subs_url,
"reviewer_message_url": reviewer_message_url,
}
for user in users_to_notify:
context['user'] = user
msg = None
if user.notify_by_message:
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = render_to_string(template_txt, context)
msg.user = user
msg.object = task.team
msg.save()
email_res = send_templated_email(user, subject, template_html,
context)
def _reviewed_notification(task_pk, status):
from teams.models import Task
from activity.models import ActivityRecord
from messages.models import Message
try:
task = Task.objects.select_related("team_video__video", "team_video",
"assignee").get(pk=task_pk)
except Task.DoesNotExist:
return False
notification_setting_name = {
REVIEWED_AND_PUBLISHED: 'block_reviewed_and_published_message',
REVIEWED_AND_PENDING_APPROVAL:
'block_reviewed_and_pending_approval_message',
REVIEWED_AND_SENT_BACK: 'block_reviewed_and_sent_back_message',
}[status]
version = task.get_subtitle_version()
if task.new_review_base_version:
user = task.new_review_base_version.author
else:
user = version.author
if not team_sends_notification(
task.team, notification_setting_name) or not user.is_active:
return False
subject = ugettext(u"Your subtitles have been reviewed")
if status == REVIEWED_AND_PUBLISHED:
subject += ugettext(" and published")
if status == REVIEWED_AND_SENT_BACK:
subject = ugettext(u"Needed: additional changes on your subtitles!")
task_language = get_language_label(task.language)
reviewer = task.assignee
video = task.team_video.video
subs_url = "%s%s" % (get_url_base(),
reverse("videos:translation_history",
kwargs={
'video_id': video.video_id,
'lang': task.language,
'lang_id': version.subtitle_language.pk,
}))
reviewer_message_url = "%s%s?user=%s" % (
get_url_base(), reverse("messages:new"), reviewer.username)
reviewer_profile_url = "%s%s" % (get_url_base(),
reverse("profiles:profile",
kwargs={'user_id': reviewer.id}))
perform_task_url = "%s%s" % (get_url_base(),
reverse("teams:perform_task",
kwargs={
'slug': task.team.slug,
'task_pk': task_pk
}))
context = {
"team": task.team,
"title": version.subtitle_language.get_title(),
"user": user,
"task_language": task_language,
"url_base": get_url_base(),
"task": task,
"reviewer": reviewer,
"note": task.body,
"reviewed_and_pending_approval":
status == REVIEWED_AND_PENDING_APPROVAL,
"sent_back": status == REVIEWED_AND_SENT_BACK,
"reviewed_and_published": status == REVIEWED_AND_PUBLISHED,
"subs_url": subs_url,
"reviewer_message_url": reviewer_message_url,
"reviewer_profile_url": reviewer_profile_url,
"perform_task_url": perform_task_url,
}
msg = None
if user.notify_by_message:
template_name = "messages/team-task-reviewed.txt"
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = render_to_string(template_name, context)
msg.user = user
msg.object = task.team
msg.save()
template_name = "messages/email/team-task-reviewed.html"
email_res = send_templated_email(user, subject, template_name, context)
if status == REVIEWED_AND_SENT_BACK:
if task.type == Task.TYPE_IDS['Review']:
ActivityRecord.objects.create_for_version_declined(
version, reviewer)
else:
ActivityRecord.objects.create_for_version_rejected(
version, reviewer)
elif status == REVIEWED_AND_PUBLISHED:
ActivityRecord.objects.create_for_version_approved(version, reviewer)
elif status == REVIEWED_AND_PENDING_APPROVAL:
ActivityRecord.objects.create_for_version_accepted(version, reviewer)
return msg, email_res
def approved_notification(task_pk, published=False):
"""
On approval, it can be sent back (published=False) or
approved and published
"""
from teams.models import Task
from videos.models import Action
from messages.models import Message
try:
task = Task.objects.select_related(
"team_video__video", "team_video", "assignee", "subtitle_version").get(
pk=task_pk)
if not _team_sends_notification(task.team, 'block_approved_message'):
return False
except Task.DoesNotExist:
return False
# some tasks are being created without subtitles version, see
# https://unisubs.sifterapp.com/projects/12298/issues/552092/comments
if published:
subject = ugettext(u"Your subtitles have been approved and published!")
template_txt = "messages/team-task-approved-published.txt"
template_html ="messages/email/team-task-approved-published.html"
else:
template_txt = "messages/team-task-approved-sentback.txt"
template_html ="messages/email/team-task-approved-sentback.html"
subject = ugettext(u"Your subtitles have been returned for further editing")
version = task.get_subtitle_version()
if task.new_review_base_version:
user = task.new_review_base_version.author
else:
user = version.author
task_language = get_language_label(task.language)
reviewer = task.assignee
video = task.team_video.video
subs_url = "%s%s" % (get_url_base(), reverse("videos:translation_history", kwargs={
'video_id': video.video_id,
'lang': task.language,
'lang_id': version.subtitle_language.pk,
}))
reviewer_message_url = "%s%s?user=%s" % (
get_url_base(), reverse("messages:new"), reviewer.username)
context = {
"team":task.team,
"title": version.subtitle_language.get_title(),
"user":user,
"task_language": task_language,
"url_base":get_url_base(),
"task":task,
"reviewer":reviewer,
"note":task.body,
"subs_url": subs_url,
"reviewer_message_url": reviewer_message_url,
}
msg = None
if user.notify_by_message:
template_name = template_txt
msg = Message()
msg.subject = subject
msg.content = render_to_string(template_name,context)
msg.user = user
msg.object = task.team
msg.save()
template_name = template_html
Meter('templated-emails-sent-by-type.teams.approval-result').inc()
email_res = send_templated_email(user, subject, template_name, context)
Action.create_approved_video_handler(version, reviewer)
return msg, email_res
def team_member_new(member_pk):
if getattr(settings, "MESSAGES_DISABLED", False):
return
from messages.models import Message
from teams.models import TeamMember, Setting
member = TeamMember.objects.get(pk=member_pk)
if not team_sends_notification(member.team,
'block_team_member_new_message'):
return False
from teams.models import TeamMember
# the feed item should appear on the timeline for all team members
# as a team might have thousands of members, this one item has
# to show up on all of them
# notify admins and owners through messages
notifiable = TeamMember.objects.filter(
team=member.team,
user__is_active=True,
role__in=[TeamMember.ROLE_ADMIN,
TeamMember.ROLE_OWNER]).exclude(pk=member.pk)
for m in notifiable:
context = {
"new_member": member.user,
"team": member.team,
"user": m.user,
"role": member.role,
"url_base": get_url_base(),
}
body = render_to_string("messages/team-new-member.txt", context)
subject = fmt(ugettext("%(team)s team has a new member"),
team=member.team)
if m.user.notify_by_message:
msg = Message()
msg.message_type = 'S'
msg.subject = subject
msg.content = body
msg.user = m.user
msg.object = m.team
msg.save()
template_name = "messages/email/team-new-member.html"
send_templated_email(m.user, subject, template_name, context)
# does this team have a custom message for this?
team_default_message = None
messages = Setting.objects.messages().filter(team=member.team)
if messages.exists():
for m in messages:
if m.get_key_display() == 'messages_joins':
team_default_message = m.data
break
for ul in UserLanguage.objects.filter(
user=member.user).order_by("priority"):
localized_message = Setting.objects.messages().filter(
team=member.team, language_code=ul.language)
if len(localized_message) == 1:
if team_default_message:
team_default_message += u'\n\n----------------\n\n' + localized_message[
0].data
else:
team_default_message = localized_message[0].data
break
# now send welcome mail to the new member
template_name = "messages/team-welcome.txt"
context = {
"team": member.team,
"url_base": get_url_base(),
"role": member.role,
"user": member.user,
"custom_message": team_default_message,
}
body = render_to_string(template_name, context)
msg = Message()
msg.message_type = 'S'
msg.subject = fmt(ugettext("You've joined the %(team)s team!"),
team=member.team)
msg.content = body
msg.user = member.user
msg.object = member.team
msg.save()
template_name = "messages/email/team-welcome.html"
send_templated_email(msg.user, msg.subject, template_name, context)
