def get_api_url(self):
"""
Returns what api url the recipient of this notification should
query for the latest data. This is team dependent if the team
has a custom base url.
"""
from teams.models import Application
if self.language:
url = universal_url('api:subtitles', kwargs={
'video_id': self.language.video.video_id,
'language_code': self.language.language_code
})
if self.version:
url += '?version_no={}'.format(self.version.version_number)
return url
elif self.video:
return universal_url('api:video-detail', kwargs={
'video_id': self.video.video_id,
})
elif self.application_pk:
application = Application.objects.get(pk=self.application_pk)
return universal_url('api:team-application-detail', kwargs={
'team_slug': application.team.slug,
'id': application.id,
})
else:
return None
def test_universal_urls(self):
from localeurl.utils import universal_url
domain = Site.objects.get_current().domain
vid = self.video.video_id
self.assertEqual(
"http://%s/videos/%s/info/" % (domain, vid),
universal_url("videos:video", kwargs={"video_id": vid}))
self.assertEqual("http://%s/videos/%s/info/" % (domain, vid),
universal_url("videos:video", args=(vid, )))
def test_universal_urls(self):
domain = settings.HOSTNAME
vid = 'test-video-id'
correct_url = "%s://%s/videos/%s/info/" % (
DEFAULT_PROTOCOL, domain, vid)
self.assertEqual(correct_url,
universal_url("videos:video",
kwargs={"video_id":vid}))
self.assertEqual(correct_url,
universal_url("videos:video", args=(vid,)))
def test_universal_urls(self):
domain = Site.objects.get_current().domain
vid = self.video.video_id
correct_url = "%s://%s/videos/%s/info/" % (DEFAULT_PROTOCOL, domain,
vid)
self.assertEqual(
correct_url, universal_url("videos:video",
kwargs={"video_id": vid}))
self.assertEqual(correct_url,
universal_url("videos:video", args=(vid, )))
def send_messages(self, note, user_list):
subject = fmt(_(u'%(user)s added a note while editing %(title)s'),
user=unicode(note.user),
title=self.video.title_display())
tasks_url = universal_url('teams:team_tasks',
kwargs={
'slug': self.team.slug,
})
filter_query = '?team_video={0}&assignee=anyone&lang={1}'
filter_query = filter_query.format(self.team_video.pk,
self.language_code)
data = {
'note_user': unicode(note.user),
'body': note.body,
'tasks_url': tasks_url + filter_query,
'video': self.video.title_display(),
'language': translation.get_language_label(self.language_code),
}
email_template = ("messages/email/"
"task-team-editor-note-notifiction.html")
message_template = 'messages/task-team-editor-note.html'
for user in user_list:
send_templated_email(user,
subject,
email_template,
data,
fail_silently=not settings.DEBUG)
Message.objects.create(user=user,
subject=subject,
message_type="S",
content=render_to_string(
message_template, data))
def youtube_oauth_callback(request):
"""
Stores the oauth tokes. We identify which team this belongs to
since we've passed the pk on the state param for the authorize request
"""
import atom
code = request.GET.get("code", None)
if code is None:
raise Exception("No code in youtube oauth callback")
state = request.GET.get("state", None)
if state is None:
raise Exception("No state in youtube oauth callback")
values = state.split("-")
team_pk = values[0]
if len(values) > 1:
project_pk = values[1]
team = Team.objects.get(pk=team_pk)
base = "https://accounts.google.com/o/oauth2/token"
state = team.pk
params = {
"client_id": settings.YOUTUBE_CLIENT_ID,
"client_secret": settings.YOUTUBE_CLIENT_SECRET,
"redirect_uri": universal_url("accountlinker:youtube-oauth-callback"),
"code": code,
"grant_type": "authorization_code",
}
response = requests.post(
base,
data=params,
headers={"Content-Type": "application/x-www-form-urlencoded"})
if response.status_code != 200:
logger.error("Error on requesting Youtube Oauth token",
extra={
"data": {
"sent_params": params,
"original_request": request,
},
})
content = json.loads(response.content)
bridge = YouTubeApiBridge(content['access_token'],
content['refresh_token'], None)
feed = bridge.GetUserFeed(username='******')
author = [x for x in feed.get_elements() if type(x) == atom.data.Author][0]
# make sure we don't store multiple auth tokes for the same account
account, created = ThirdPartyAccount.objects.get_or_create(
type=VIDEO_TYPE_YOUTUBE,
username=author.name.text,
defaults={
'oauth_refresh_token': content['refresh_token'],
'oauth_access_token': content['access_token'],
})
team.third_party_accounts.add(account)
return redirect(
reverse("teams:third-party-accounts", kwargs={"slug": team.slug}))
def _generate_youtube_oauth_request_link(state_str=None):
state_str = state_str or ""
base = "https://accounts.google.com/o/oauth2/auth?"
state = state_str
params = {
"client_id": settings.YOUTUBE_CLIENT_ID,
"redirect_uri": universal_url("accountlinker:youtube-oauth-callback"),
"scope": "https://gdata.youtube.com",
"state": state,
"response_type": "code",
"approval_prompt": "force",
"access_type": "offline",
}
return "%s%s" % (base, urllib.urlencode(params))
def google_callback_url():
return universal_url(
'externalsites:google-callback',
protocol_override=settings.OAUTH_CALLBACK_PROTOCOL)
def test_universal_urls(self):
from localeurl.utils import universal_url
domain= Site.objects.get_current().domain
vid = self.video.video_id
self.assertEqual("http://%s/videos/%s/info/" % (domain, vid) , universal_url( "videos:video", kwargs={"video_id":vid} ))
self.assertEqual("http://%s/videos/%s/info/" % (domain, vid) , universal_url( "videos:video", args=(vid,) ))
def send_video_comment_notification(comment_pk_or_instance, version_pk=None):
"""
Comments can be attached to a video (appear in the videos:video (info)) page) OR
sublanguage (appear in the videos:translation_history page)
Approval / Reviews notes are also stored as comments.
"""
from comments.models import Comment
from videos.models import Video
from subtitles.models import SubtitleLanguage, SubtitleVersion
if not isinstance(comment_pk_or_instance, Comment):
try:
comment = Comment.objects.get(pk=comment_pk_or_instance)
except Comment.DoesNotExist:
return
else:
comment = comment_pk_or_instance
version = None
if version_pk:
try:
version = SubtitleVersion.objects.get(pk=version_pk)
except SubtitleVersion.DoesNotExist:
pass
ct = comment.content_object
if isinstance(ct, Video):
video = ct
version = None
language = None
elif isinstance(ct, SubtitleLanguage):
video = ct.video
language = ct
domain = settings.HOSTNAME
protocol = getattr(settings, 'DEFAULT_PROTOCOL', 'https')
if language:
language_url = universal_url("videos:translation_history",
kwargs={
"video_id": video.video_id,
"lang": language.language_code,
"lang_id": language.pk,
})
else:
language_url = None
if version:
version_url = universal_url(
"videos:subtitleversion_detail",
kwargs={
'video_id': version.video.video_id,
'lang': version.subtitle_language.language_code,
'lang_id': version.subtitle_language.pk,
'version_id': version.pk,
})
else:
version_url = None
subject = fmt(ugettext(u'%(user)s left a comment on the video %(title)s'),
user=unicode(comment.user),
title=video.title_display())
followers = set(video.notification_list(comment.user))
for user in followers:
send_templated_email(
user,
subject,
"messages/email/comment-notification.html", {
"video": video,
"user": user,
"hash": user.hash_for_video(video.video_id),
"commenter": unicode(comment.user),
"commenter_url": comment.user.get_absolute_url(),
"version_url": version_url,
"language_url": language_url,
"domain": domain,
"version": version,
"body": comment.content,
"STATIC_URL": settings.STATIC_URL,
},
fail_silently=not settings.DEBUG)
if language:
obj = language
object_pk = language.pk
content_type = ContentType.objects.get_for_model(language)
exclude = [
u for u in language.followers.filter(notify_by_message=False)
]
exclude.append(comment.user)
message_followers = language.notification_list(exclude)
else:
obj = video
object_pk = video.pk
content_type = ContentType.objects.get_for_model(video)
exclude = list(video.followers.filter(notify_by_message=False))
exclude.append(comment.user)
message_followers = video.notification_list(exclude)
for user in message_followers:
Message.objects.create(
user=user,
subject=subject,
object_pk=object_pk,
content_type=content_type,
object=obj,
message_type="S",
content=render_to_string(
'messages/new-comment.html', {
"video": video,
"language": language,
"commenter": unicode(comment.user),
"commenter_url": comment.user.get_absolute_url(),
"version_url": version_url,
"language_url": language_url,
"domain": domain,
"protocol": protocol,
"version": version,
"body": comment.content
}))
def _youtube_request_uri():
if getattr(settings, 'YOUTUBE_CLIENT_FORCE_HTTPS', True):
return universal_url("accountlinker:youtube-oauth-callback",
protocol_override='https')
else:
return universal_url("accountlinker:youtube-oauth-callback")
def notify_comment_by_email(comment,
version=None,
moderator=None,
is_rejection=False):
"""
Comments can be attached to a video (appear in the videos:video (info)) page) OR
sublanguage (appear in the videos:translation_history page)
Since version rejection becomes comments for videos we also need to cater for this in the email
"""
ct = comment.content_object
if isinstance(ct, Video):
video = ct
version = None
language = None
elif isinstance(ct, SubtitleLanguage):
video = ct.video
language = ct
domain = Site.objects.get_current().domain
email_body = render_to_string(
"comments/email/comment-notification.html", {
"video": video,
"version": version,
"moderator": moderator,
"domain": domain,
"body": comment.content,
"language": language,
"is_rejection": is_rejection,
"STATIC_URL": settings.STATIC_URL,
})
if language:
language_url = universal_url("videos:translation_history",
kwargs={
"video_id": video.video_id,
"lang": language.language,
"lang_id": language.pk,
})
else:
language_url = None
if version:
version_url = universal_url("videos:revision",
kwargs={
"pk": version.pk,
})
else:
version_url = None
user = moderator or comment.user
user_url = universal_url("profiles:profile", args=(user.id, ))
if is_rejection:
subject = SUBJECT_EMAIL_VERSION_REJECTED % video.title_display()
else:
subject = SUBJECT_EMAIL_VIDEO_COMMENTED % (comment.user.username,
video.title_display())
followers = set(video.notification_list(comment.user))
if language:
followers.update(language.notification_list(comment.user))
for user in followers:
send_templated_email_async.delay(
user.email,
subject,
"comments/email/comment-notification.html", {
"video": video,
"commenter": unicode(comment.user),
"commenter_url": comment.user.get_absolute_url(),
"version_url": version_url,
"language_url": language_url,
"domain": domain,
"version": version,
"body": comment.content,
"STATIC_URL": settings.STATIC_URL,
},
fail_silently=not settings.DEBUG)
def notify_comment_by_email(comment, version=None, moderator=None, is_rejection=False):
"""
Comments can be attached to a video (appear in the videos:video (info)) page) OR
sublanguage (appear in the videos:translation_history page)
Since version rejection becomes comments for videos we also need to cater for this in the email
"""
ct = comment.content_object
if isinstance( ct, Video):
video = ct
version = None
language = None
elif isinstance(ct, SubtitleLanguage ):
video = ct.video
language = ct
domain = Site.objects.get_current().domain
email_body = render_to_string("comments/email/comment-notification.html", {
"video": video,
"version": version,
"moderator": moderator,
"domain":domain,
"body": comment.content,
"language":language,
"is_rejection":is_rejection,
"STATIC_URL": settings.STATIC_URL,
})
if language:
language_url = universal_url("videos:translation_history", kwargs={
"video_id": video.video_id,
"lang": language.language,
"lang_id": language.pk,
})
else:
language_url = None
if version:
version_url = universal_url("videos:revision", kwargs={
"pk": version.pk,
})
else:
version_url = None
user = moderator or comment.user
user_url = universal_url("profiles:profile", args=(user.id,))
if is_rejection:
subject = SUBJECT_EMAIL_VERSION_REJECTED % video.title_display()
else:
subject = SUBJECT_EMAIL_VIDEO_COMMENTED % (comment.user.username, video.title_display())
followers = set(video.notification_list(comment.user))
if language:
followers.update(language.notification_list(comment.user))
for user in followers:
send_templated_email_async.delay(
user.email,
subject,
"comments/email/comment-notification.html",
{
"video": video,
"commenter": unicode(comment.user),
"commenter_url": comment.user.get_absolute_url(),
"version_url":version_url,
"language_url":language_url,
"domain":domain,
"version": version,
"body": comment.content,
"STATIC_URL": settings.STATIC_URL,
},
fail_silently=not settings.DEBUG)
def universal_url(view_name, *args, **kwargs):
return utils.universal_url(view_name, args=args, kwargs=kwargs)
