Exemple #1
0
def new_user(username, provider):
    "Creates a new user with a temporary password taking care of any same usernames"
    same_name_count = User.objects.filter(username__startswith = username).count()
    if same_name_count:
        username = '******' % (username, same_name_count + 1)
    if provider == 'Twitter':
        username = '******'+username #for Twitter
    name_count = AuthUser.objects.filter(username__startswith = username).count()
    if name_count:
        username = '******'%(username, name_count + 1)                        
    user = User(username =  username)
    temp_password = User.objects.make_random_password(length=12)
    user.set_password(temp_password)
    return user
Exemple #2
0
    def test_author(self):
        def _get_tip_author():
            sl = SubtitleLanguage.objects.get(video=self.video,
                                              language_code='en')
            return sl.get_tip(full=True).author

        def _add(*args, **kwargs):
            pipeline.add_subtitles(self.video, 'en', None, *args, **kwargs)

        # Not passing at all.
        _add()
        self.assertEqual(_get_tip_author(), self.anon)

        # Passing nil.
        _add(author=None)
        self.assertEqual(_get_tip_author(), self.anon)

        # Passing anonymous.
        _add(author=User.get_anonymous())
        self.assertEqual(_get_tip_author(), self.anon)

        # Passing u1.
        _add(author=self.u1)
        self.assertEqual(_get_tip_author().id, self.u1.id)

        # Passing u2.
        _add(author=self.u2)
        self.assertEqual(_get_tip_author().id, self.u2.id)

        # Passing nonsense
        self.assertRaises(ValueError, lambda: _add(author='dogs'))
        self.assertRaises(ValueError, lambda: _add(author=-1234))
        self.assertRaises(ValueError, lambda: _add(author=[self.u1]))
Exemple #3
0
    def setUp(self):
        self.video = make_video()
        self.u1 = UserFactory()
        self.u2 = UserFactory()
        self.anon = User.get_anonymous()

        v = self.video
        self.en1 = pipeline.add_subtitles(v,
                                          'en',
                                          title="title 1",
                                          description="desc 1",
                                          subtitles=[(100, 200, "sub 1")],
                                          author=self.u1)
        self.en2 = pipeline.add_subtitles(v,
                                          'en',
                                          title="title 2",
                                          description="desc 2",
                                          subtitles=[(100, 200, "sub 2")],
                                          author=self.u2)
        self.en3 = pipeline.add_subtitles(v,
                                          'en',
                                          title="title 3",
                                          description="desc 3",
                                          subtitles=[(100, 200, "sub 3")],
                                          author=self.u1)
Exemple #4
0
    def _get_subtitles_from_youtube(self, video_obj):
        from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle

        url = 'http://www.youtube.com/watch_ajax?action_get_caption_track_all&v=%s' % video_obj.youtube_videoid

        h = httplib2.Http()
        resp, content = h.request(url, "GET")

        if resp.status < 200 or resp.status >= 400:
            logger.warning("Youtube subtitles error",
                           extra={
                               'data': {
                                   "url": url,
                                   "video_id": video_obj.youtube_videoid,
                                   "status_code": resp.status,
                                   "response": content
                               }
                           })
            return
        parser = YoutubeSubtitleParser(content)

        if not parser:
            return

        language, create = SubtitleLanguage.objects.get_or_create(
            video=video_obj, language=parser.language)
        language.is_original = False
        language.is_forked = True
        language.save()

        try:
            version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
                .get().version_no + 1
        except SubtitleVersion.DoesNotExist:
            version_no = 0

        version = SubtitleVersion(language=language)
        version.version_no = version_no
        version.datetime_started = datetime.now()
        version.user = User.get_youtube_anonymous()
        version.note = u'From youtube'
        version.is_forked = True
        version.save()

        for i, item in enumerate(parser):
            subtitle = Subtitle(**item)
            subtitle.version = version
            subtitle.subtitle_id = int(random.random() * 10e12)
            subtitle.subtitle_order = i + 1
            subtitle.save()
        version.finished = True
        version.save()

        language.had_version = True
        language.is_complete = True
        language.save()
Exemple #5
0
        def test_contribuitors_do_bypass_moderation(self):
            lang = self.video.subtitle_language()
            member, created = TeamMember.objects.get_or_create(user=self.user, team=self.team)
            member.role=TeamMember.ROLE_MANAGER
            member.save()
            add_moderation(self.video, self.team, self.user)
            joe_doe = User(username="******", password="******", email="*****@*****.**")
            joe_doe.save()
            joe_member, c = TeamMember.objects.get_or_create(user=joe_doe, team=self.team)
            joe_member.save()
            v0 = self._create_versions(lang, 1, user=joe_doe)[0]
            self.assertEquals(v0.moderation_status,WAITING_MODERATION)
            joe_member.promote_to_contributor()
            joe_doe = refresh_obj(joe_doe)

            self.assertTrue(self.team.is_contributor(joe_doe, authenticated=False))
            v1 = self._create_versions(lang, 1, user=joe_doe)[0]
            metadata_manager.update_metadata(self.video.pk)
            v1 = refresh_obj(v1)
            self.assertEquals(v1.moderation_status, APPROVED)
Exemple #6
0
    def _create_user(self, access_token, data):
        username = self._find_available_username(data)

        twitter_username = data.screen_name
        first_name, last_name = self._get_first_last_name(data)
        avatar = data.profile_image_url

        email = '%s@twitteruser.%s.com' % (twitter_username, settings.SITE_NAME)

        user = User(username=username, email=email, first_name=first_name,
                    last_name=last_name)
        temp_password = User.objects.make_random_password(length=24)
        user.set_password(temp_password)
        user.save()

        TwitterAccount.objects.create(user=user, username=twitter_username,
                                      access_token=access_token.key,
                                      avatar=avatar)

        return user
Exemple #7
0
    def _get_subtitles_from_youtube(self, video_obj):
        from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle
        
        url = 'http://www.youtube.com/watch_ajax?action_get_caption_track_all&v=%s' % video_obj.youtube_videoid

        h = httplib2.Http()
        resp, content = h.request(url, "GET")

        if resp.status < 200 or resp.status >= 400:
            logger.warning("Youtube subtitles error", extra={
                    'data': {
                        "url": url,
                        "video_id": video_obj.youtube_videoid,
                        "status_code": resp.status,
                        "response": content
                        }
                    })
            return
        parser = YoutubeSubtitleParser(content)

        if not parser:
            return
        
        language, create = SubtitleLanguage.objects.get_or_create(video=video_obj, language = parser.language)
        language.is_original = False
        language.is_forked = True
        language.save()
        
        try:
            version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
                .get().version_no + 1
        except SubtitleVersion.DoesNotExist:
            version_no = 0
            
        version = SubtitleVersion(language=language)
        version.version_no = version_no
        version.datetime_started = datetime.now()
        version.user = User.get_youtube_anonymous()
        version.note = u'From youtube'
        version.is_forked = True
        version.save()

        for i, item in enumerate(parser):
            subtitle = Subtitle(**item)
            subtitle.version = version
            subtitle.subtitle_id = int(random.random()*10e12)
            subtitle.subtitle_order = i+1
            subtitle.save()
        version.finished = True
        version.save()

        language.had_version = True
        language.is_complete = True
        language.save()
Exemple #8
0
def user_videos_activity(context, user=None):
    user = user or context['user']

    if user.is_authenticated():
        context['users_actions'] = Action.objects.select_related('video', 'language', 'language__video', 'user') \
            .filter(video__customuser=user) \
            .exclude(user=user) \
            .exclude(user=User.get_anonymous())[:ACTIONS_ON_PAGE]
    else:
        context['users_actions'] = Action.objects.none()
    return context
def user_videos_activity(context, user=None):
    user = user or context['user']
    
    if user.is_authenticated():
        context['users_actions'] = Action.objects.select_related('video', 'language', 'language__video', 'user') \
            .filter(video__customuser=user) \
            .exclude(user=user) \
            .exclude(user=User.get_youtube_anonymous())[:ACTIONS_ON_PAGE]
    else:
        context['users_actions'] = Action.objects.none()
    return context
Exemple #10
0
def user_videos_activity(context, user=None):
    user = user or context['user']
    
    if user.is_authenticated():
        videos_ids = Video.objects.filter(subtitlelanguage__subtitleversion__user=user).distinct() \
            .values_list('id', flat=True)
        context['users_actions'] = Action.objects.filter(Q(video__pk__in=videos_ids)| \
            Q(action_type=Action.ADD_VIDEO, user=user)) \
            .exclude(user=user) \
            .exclude(user=User.get_youtube_anonymous())[:ACTIONS_ON_PAGE]
    else:
        context['users_actions'] = Action.objects.none()
    return context
Exemple #11
0
    def authenticate(self, access_token):
        '''authenticates the token by requesting user information from twitter
        '''
        twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, access_token)

        try:
            userinfo = twitter.GetUserInfo()
        except:
            # If we cannot get the user information, user cannot be authenticated
            raise

        screen_name = userinfo.screen_name
        img_url = userinfo.profile_image_url
        
        try:
            user_profile = TwitterUserProfile.objects.get(screen_name = screen_name)
            if user_profile.user.is_active:
                return user_profile.user
            else:
                return        
        except TwitterUserProfile.DoesNotExist:
            #Create new user
            same_name_count = User.objects.filter(username__startswith = screen_name).count()
            if same_name_count:
                username = '******' % (screen_name, same_name_count + 1)
            else:
                username = screen_name
            username = '******'+username
            
            name_count = AuthUser.objects.filter(username__startswith = username).count()
                
            if name_count:
                username = '******'%(username, name_count + 1)
                            
            user = User(username =  username)
            temp_password = User.objects.make_random_password(length=12)
            user.set_password(temp_password)
            name_data = userinfo.name.split()
            try:
                first_name, last_name = name_data[0], ' '.join(name_data[1:])
            except:
                first_name, last_name =  screen_name, ''
            user.first_name, user.last_name = first_name, last_name
            if img_url:
                img = ContentFile(urlopen(img_url).read())
                name = img_url.split('/')[-1]
                user.picture.save(name, img, False)            
            #user.email = '%s@twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
            user.save()
            userprofile = TwitterUserProfile(user = user, screen_name = screen_name)
            userprofile.access_token = access_token.key
            userprofile.url = userinfo.url
            userprofile.location = userinfo.location
            userprofile.description = userinfo.description
            userprofile.profile_image_url = userinfo.profile_image_url
            userprofile.save()
            AuthMeta(user=user, provider='Twitter').save()
            return user
Exemple #12
0
    def authenticate(self, access_token):
        '''authenticates the token by requesting user information from twitter
        '''
        twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, access_token)

        try:
            userinfo = twitter.GetUserInfo()
        except:
            # If we cannot get the user information, user cannot be authenticated
            raise

        screen_name = userinfo.screen_name
        img_url = userinfo.profile_image_url
        
        try:
            user_profile = TwitterUserProfile.objects.get(screen_name = screen_name)
            if user_profile.user.is_active:
                return user_profile.user
            else:
                return        
        except TwitterUserProfile.DoesNotExist:
            #Create new user
            same_name_count = User.objects.filter(username__startswith = screen_name).count()
            if same_name_count:
                username = '******' % (screen_name, same_name_count + 1)
            else:
                username = screen_name
            username = '******'+username
            
            name_count = AuthUser.objects.filter(username__startswith = username).count()
                
            if name_count:
                username = '******'%(username, name_count + 1)
                            
            user = User(username =  username)
            temp_password = User.objects.make_random_password(length=12)
            user.set_password(temp_password)
            name_data = userinfo.name.split()
            try:
                first_name, last_name = name_data[0], ' '.join(name_data[1:])
            except:
                first_name, last_name =  screen_name, ''
            user.first_name, user.last_name = first_name, last_name
            if img_url:
                img = ContentFile(urlopen(img_url).read())
                name = img_url.split('/')[-1]
                user.picture.save(name, img, False)            
            #user.email = '%s@twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
            user.save()
            userprofile = TwitterUserProfile(user = user, screen_name = screen_name)
            userprofile.access_token = access_token.key
            userprofile.url = userinfo.url
            userprofile.location = userinfo.location
            userprofile.description = userinfo.description
            userprofile.profile_image_url = userinfo.profile_image_url
            userprofile.save()
            AuthMeta(user=user, provider='Twitter').save()
            return user
Exemple #13
0
def user_videos_activity(context, user=None):
    user = user or context['user']

    if user.is_authenticated():
        videos_ids = Video.objects.filter(subtitlelanguage__subtitleversion__user=user).distinct() \
            .values_list('id', flat=True)

        context['users_actions'] = Action.objects.select_related('video', 'language', 'language__video', 'user').filter(Q(video__pk__in=videos_ids)| \
            Q(action_type=Action.ADD_VIDEO, user=user)) \
            .exclude(user=user) \
            .exclude(user=User.get_youtube_anonymous())[:ACTIONS_ON_PAGE]
    else:
        context['users_actions'] = Action.objects.none()
    return context
Exemple #14
0
    def _create_user(self, access_token, data, email):
        username = self._find_available_username(data)

        twitter_username = data.screen_name
        first_name, last_name = self._get_first_last_name(data)
        avatar = data.profile_image_url
        if email is None:
            email = TwitterAuthBackend._generate_email(twitter_username)

        user = User(username=username,
                    email=email,
                    first_name=first_name,
                    last_name=last_name)
        temp_password = User.objects.make_random_password(length=24)
        user.set_password(temp_password)
        user.save()

        TwitterAccount.objects.create(user=user,
                                      username=twitter_username,
                                      access_token=access_token.key,
                                      avatar=avatar)

        return user
Exemple #15
0
    def _import_srt(self, video, videosrt_url):
        h = httplib2.Http()
        resp, content = h.request(videosrt_url, "GET")

        if resp.status == 200:
            data = {'video': video.id,
                    'language': 'en',
                    'video_language': 'en',
                    'is_complete': True }
            file_data = {'subtitles': SimpleUploadedFile('subs.srt', content)}
            form = SubtitlesUploadForm(
                CustomUser.get_youtube_anonymous(), data, file_data)
            if form.is_valid():
                form.save()
            else:
                print('url {0} did not return valid srt data'.format(videosrt_url))
Exemple #16
0
    def _import_srt(self, video, videosrt_url):
        h = httplib2.Http()
        resp, content = h.request(videosrt_url, "GET")

        if resp.status == 200:
            data = {
                'video': video.id,
                'language': 'en',
                'video_language': 'en',
                'is_complete': True
            }
            file_data = {'subtitles': SimpleUploadedFile('subs.srt', content)}
            form = SubtitlesUploadForm(CustomUser.get_youtube_anonymous(),
                                       data, file_data)
            if form.is_valid():
                form.save()
            else:
                print('url {0} did not return valid srt data'.format(
                    videosrt_url))
Exemple #17
0
    def _get_subtitles_from_youtube(self, video_obj):
        from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle

        url = 'http://www.youtube.com/watch_ajax?action_get_caption_track_all&v=%s' % video_obj.youtube_videoid
        d = urllib.urlopen(url)
        parser = YoutubeSubtitleParser(d.read())

        if not parser:
            return

        language, create = SubtitleLanguage.objects.get_or_create(
            video=video_obj, language=parser.language)
        language.is_original = False
        language.is_forked = True
        language.save()

        try:
            version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
                .get().version_no + 1
        except SubtitleVersion.DoesNotExist:
            version_no = 0

        version = SubtitleVersion(language=language)
        version.version_no = version_no
        version.datetime_started = datetime.now()
        version.user = User.get_youtube_anonymous()
        version.note = u'From youtube'
        version.is_forked = True
        version.save()

        for i, item in enumerate(parser):
            subtitle = Subtitle(**item)
            subtitle.version = version
            subtitle.subtitle_id = int(random.random() * 10e12)
            subtitle.subtitle_order = i + 1
            subtitle.save()
        version.finished = True
        version.save()

        language.had_version = True
        language.is_complete = True
        language.save()
Exemple #18
0
    def _get_subtitles_from_youtube(self, video_obj):
        from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle
        
        url = 'http://www.youtube.com/watch_ajax?action_get_caption_track_all&v=%s' % video_obj.youtube_videoid
        d = urllib.urlopen(url)
        parser = YoutubeSubtitleParser(d.read())

        if not parser:
            return
        
        language, create = SubtitleLanguage.objects.get_or_create(video=video_obj, language = parser.language)
        language.is_original = False
        language.is_forked = True
        language.save()
        
        try:
            version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
                .get().version_no + 1
        except SubtitleVersion.DoesNotExist:
            version_no = 0
            
        version = SubtitleVersion(language=language)
        version.version_no = version_no
        version.datetime_started = datetime.now()
        version.user = User.get_youtube_anonymous()
        version.note = u'From youtube'
        version.is_forked = True
        version.save()

        for i, item in enumerate(parser):
            subtitle = Subtitle(**item)
            subtitle.version = version
            subtitle.subtitle_id = int(random.random()*10e12)
            subtitle.subtitle_order = i+1
            subtitle.save()
        version.finished = True
        version.save()

        language.was_complete = True
        language.is_complete = True
        language.save()
Exemple #19
0
    def _get_subtitles_from_youtube(self):
        if not self.youtube_videoid:
            return 

        url = 'http://www.youtube.com/watch_ajax?action_get_caption_track_all&v=%s' % self.youtube_videoid
        d = urllib.urlopen(url)
        parser = YoutubeSubtitleParser(d.read())
        
        if not parser:
            return
        
        language = SubtitleLanguage(video=self)
        language.is_original = False
        language.is_forked = True
        language.language = parser.language
        language.save()
        
        version = SubtitleVersion(language=language)
        version.datetime_started = datetime.now()
        version.user = User.get_youtube_anonymous()
        version.note = u'From youtube'
        version.save()
        
        for i, item in enumerate(parser):
            subtitle = Subtitle(**item)
            subtitle.version = version
            subtitle.subtitle_id = int(random.random()*10e12)
            subtitle.sub_order = i+1
            subtitle.save()
        
        version.finished = True
        version.save()
        
        language.was_complete = True
        language.is_complete = True
        language.save()
Exemple #20
0
def save_subtitles_for_lang(lang, video_pk, youtube_id):
    from videos.models import Video

    yt_lc = lang.get('lang_code')
    lc = LanguageCode(yt_lc, "youtube").encode("unisubs")

    if not lc in SUPPORTED_LANGUAGE_CODES:
        logger.warn(
            "Youtube import did not find language code",
            extra={"data": {
                "language_code": lc,
                "youtube_id": youtube_id,
            }})
        return

    try:
        video = Video.objects.get(pk=video_pk)
    except Video.DoesNotExist:
        return

    from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle

    url = u'http://www.youtube.com/api/timedtext?v=%s&lang=%s&name=%s'
    url = url % (youtube_id, yt_lc, urlquote(lang.get('name', u'')))

    xml = YoutubeVideoType._get_response_from_youtube(url)

    if xml is None:
        return

    parser = YoutubeXMLParser(xml)

    if not parser:
        return

    language, create = SubtitleLanguage.objects.get_or_create(
        video=video, language=lc, defaults={
            'created': datetime.now(),
        })
    language.is_original = False
    language.is_forked = True
    language.save()

    try:
        version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
            .get().version_no + 1
    except SubtitleVersion.DoesNotExist:
        version_no = 0

    version = SubtitleVersion(language=language)
    version.title = video.title
    version.description = video.description
    version.version_no = version_no
    version.datetime_started = datetime.now()
    version.user = User.get_anonymous()
    version.note = u'From youtube'
    version.is_forked = True
    version.save()

    for i, item in enumerate(parser):
        subtitle = Subtitle()
        subtitle.subtitle_text = item['subtitle_text']
        subtitle.start_time = item['start_time']
        subtitle.end_time = item['end_time']
        subtitle.version = version
        subtitle.subtitle_id = int(random.random() * 10e12)
        subtitle.subtitle_order = i + 1
        subtitle.save()
        assert subtitle.start_time or subtitle.end_time, item['subtitle_text']
    version.finished = True
    version.save()

    language.has_version = True
    language.had_version = True
    language.is_complete = True
    language.save()

    from videos.tasks import video_changed_tasks
    video_changed_tasks.delay(video.pk)
Exemple #21
0
def tutorial_shown(request):
    User.tutorial_was_shown(request.user.id)
    return HttpResponse(json.dumps({'success': True}))
Exemple #22
0
def secure_id_lookup(secure_id):
    return User.lookup_by_secure_id(secure_id)
Exemple #23
0
def save_subtitles_for_lang(lang, video_pk, youtube_id):
    from videos.models import Video
    
    lc = lang.get('lang_code')

    if not lc in SUPPORTED_LANGUAGES_DICT:
        return
    
    try:
        video = Video.objects.get(pk=video_pk)
    except Video.DoesNotExist:
        return
    
    from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle

    url = u'http://www.youtube.com/api/timedtext?v=%s&lang=%s&name=%s'
    url = url % (youtube_id, lc, urlquote(lang.get('name', u'')))

    xml = YoutubeVideoType._get_response_from_youtube(url)

    if xml is None:
        return

    parser = YoutubeXMLParser(xml)

    if not parser:
        return
    
    language, create = SubtitleLanguage.objects.get_or_create(video=video, language=lc)
    language.is_original = False
    language.is_forked = True
    language.save()
    
    try:
        version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
            .get().version_no + 1
    except SubtitleVersion.DoesNotExist:
        version_no = 0
        
    version = SubtitleVersion(language=language)
    version.version_no = version_no
    version.datetime_started = datetime.now()
    version.user = User.get_anonymous()
    version.note = u'From youtube'
    version.is_forked = True
    version.save()

    for i, item in enumerate(parser):
        subtitle = Subtitle()
        subtitle.subtitle_text = item['subtitle_text']
        subtitle.start_time = item['start_time']
        subtitle.end_time = item['end_time']
        subtitle.version = version
        subtitle.subtitle_id = int(random.random()*10e12)
        subtitle.subtitle_order = i+1
        subtitle.save()
        assert subtitle.start_time or subtitle.end_time, item['subtitle_text']
    version.finished = True
    version.save()
    
    language.has_version = True
    language.had_version = True
    language.is_complete = True
    language.save()
    
    from videos.tasks import video_changed_tasks
    video_changed_tasks.delay(video.pk)
Exemple #24
0
def compute_statistics(team, stats_type):
    """computes a bunch of statistics for the team, either at
    the video or member levels.
    """
    from views import TableCell
    summary = ''
    graph = ''
    graph_recent = ''
    summary_recent = ''
    graph_additional = ''
    graph_additional_recent = ''
    summary_additional = ''
    summary_additional_recent = ''
    summary_table = ''
    if stats_type == 'videosstats':
        (complete_languages, incomplete_languages) = team.get_team_languages()
        languages = complete_languages + incomplete_languages
        unique_languages = set(languages)
        total = 0
        numbers = []
        y_title = "Number of edited subtitles"
        for l in unique_languages:
            count_complete = complete_languages.count(l)
            count_incomplete = incomplete_languages.count(l)
            numbers.append(
                (get_language_label(l), count_complete + count_incomplete,
                 "Published: %s, total edits:" % count_complete))
            total += count_complete + count_incomplete
        summary = 'Top languages (all time)'
        title = ""
        graph = plot(numbers,
                     title=title,
                     graph_type='HorizontalBar',
                     labels=True,
                     max_entries=20,
                     y_title=y_title)

        (complete_languages_recent, incomplete_languages_recent,
         new_languages) = team.get_team_languages(since=30)
        languages_recent = complete_languages_recent + incomplete_languages_recent
        unique_languages_recent = set(languages_recent)
        summary_recent = "Top languages (past 30 days)"
        numbers_recent = []
        total_recent = 0
        for l in unique_languages_recent:
            count_complete_recent = complete_languages_recent.count(l)
            count_incomplete_recent = incomplete_languages_recent.count(l)
            numbers_recent.append(
                (get_language_label(l),
                 count_complete_recent + count_incomplete_recent,
                 "Published: %s, total edits:" % count_complete_recent))
            total_recent += count_complete_recent + count_incomplete_recent
        title_recent = ""
        graph_recent = plot(numbers_recent,
                            title=title_recent,
                            graph_type='HorizontalBar',
                            labels=True,
                            max_entries=20,
                            y_title=y_title)

        summary_table = []
        summary_table.append([
            TableCell("", header=True),
            TableCell("all time", header=True),
            TableCell("past 30 days", header=True)
        ])
        summary_table.append([
            TableCell("videos added", header=True),
            TableCell(str(team.videos_count)),
            TableCell(str(team.videos_count_since(30)))
        ])
        summary_table.append([
            TableCell("languages edited", header=True),
            TableCell(str(len(unique_languages))),
            TableCell(str(len(unique_languages_recent)))
        ])
        summary_table.append([
            TableCell("subtitles edited", header=True),
            TableCell(str(total)),
            TableCell(str(total_recent))
        ])

    elif stats_type == 'teamstats':
        languages = list(team.languages())
        unique_languages = set(languages)
        summary = u'Members by language (all time)'
        numbers = []
        for l in unique_languages:
            numbers.append((get_language_label(l), languages.count(l),
                            get_language_label(l)))
        title = ''
        graph = plot(numbers,
                     graph_type='HorizontalBar',
                     title=title,
                     max_entries=25,
                     labels=True,
                     total_label="Members: ")
        languages_recent = list(team.languages(members_joined_since=30))
        unique_languages_recent = set(languages_recent)
        summary_recent = u'New members by language (past 30 days)'
        numbers_recent = []
        for l in unique_languages_recent:
            numbers_recent.append(
                (get_language_label(l), languages_recent.count(l),
                 get_language_label(l), "%s://%s%s" %
                 (DEFAULT_PROTOCOL, Site.objects.get_current().domain,
                  reverse('teams:members', args=[], kwargs={'slug': team.slug})
                  + "?sort=-joined&lang=%s" % l)))
        title_recent = ''
        graph_recent = plot(numbers_recent,
                            graph_type='HorizontalBar',
                            title=title_recent,
                            max_entries=25,
                            labels=True,
                            xlinks=True,
                            total_label="Members: ")

        summary_table = []
        summary_table.append([
            TableCell("", header=True),
            TableCell("all time", header=True),
            TableCell("past 30 days", header=True)
        ])
        summary_table.append([
            TableCell("members joined", header=True),
            TableCell(str(team.members_count)),
            TableCell(str(team.members_count_since(30)))
        ])
        summary_table.append([
            TableCell("member languages", header=True),
            TableCell(str(len(unique_languages))),
            TableCell(str(len(unique_languages_recent)))
        ])

        active_users = {}
        for sv in team.active_users():
            if sv[0] in active_users:
                active_users[sv[0]].add(sv[1])
            else:
                active_users[sv[0]] = set([sv[1]])

        most_active_users = active_users.items()
        most_active_users.sort(reverse=True, key=lambda x: len(x[1]))
        if len(most_active_users) > 20:
            most_active_users = most_active_users[:20]

        active_users_recent = {}
        for sv in team.active_users(since=30):
            if sv[0] in active_users_recent:
                active_users_recent[sv[0]].add(sv[1])
            else:
                active_users_recent[sv[0]] = set([sv[1]])

        most_active_users_recent = active_users_recent.items()
        most_active_users_recent.sort(reverse=True, key=lambda x: len(x[1]))
        if len(most_active_users_recent) > 20:
            most_active_users_recent = most_active_users_recent[:20]

        def displayable_user(user, users_details):
            user_details = users_details[user[0]]
            return ("%s %s (%s)" %
                    (user_details[1], user_details[2], user_details[3]),
                    len(user[1]), "%s %s (%s)" %
                    (user_details[1], user_details[2], user_details[3]),
                    "%s://%s%s" %
                    (DEFAULT_PROTOCOL, Site.objects.get_current().domain,
                     reverse("profiles:profile",
                             kwargs={'user_id': str(user[0])})))

        user_details = User.displayable_users(
            map(lambda x: int(x[0]), most_active_users))
        user_details_dict = {}
        for user in user_details:
            user_details_dict[user[0]] = user

        most_active_users = map(
            lambda x: displayable_user(x, user_details_dict),
            most_active_users)

        summary_additional = u'Top contributors (all time)'
        graph_additional = plot(most_active_users,
                                graph_type='HorizontalBar',
                                title='',
                                labels=True,
                                xlinks=True,
                                total_label="Contributions: ")

        user_details_recent = User.displayable_users(
            map(lambda x: int(x[0]), most_active_users_recent))
        user_details_dict_recent = {}
        for user in user_details_recent:
            user_details_dict_recent[user[0]] = user

        most_active_users_recent = map(
            lambda x: displayable_user(x, user_details_dict_recent),
            most_active_users_recent)

        summary_additional_recent = u'Top contributors (past 30 days)'
        graph_additional_recent = plot(most_active_users_recent,
                                       graph_type='HorizontalBar',
                                       title='',
                                       labels=True,
                                       xlinks=True,
                                       total_label="Contributions: ")

    statistics = {
        'computed_on':
        datetime.utcnow().replace(
            tzinfo=utc).strftime("%A %d. %B %Y %H:%M:%S UTC"),
        'summary':
        summary,
        'summary_recent':
        summary_recent,
        'activity_tab':
        stats_type,
        'graph':
        graph,
        'graph_recent':
        graph_recent,
        'graph_additional':
        graph_additional,
        'graph_additional_recent':
        graph_additional_recent,
        'summary_additional':
        summary_additional,
        'summary_additional_recent':
        summary_additional_recent,
        'summary_table':
        summary_table,
    }
    return statistics
Exemple #25
0
 def setup_amara_db(self, db):
     from auth.models import CustomUser
     CustomUser.get_amara_anonymous()
Exemple #26
0
def facebook_login(request,
                   next=None,
                   confirmed=False,
                   email=None,
                   form_data=None):
    data = parse_signed_request(
        request.COOKIES['fbsr_' + settings.FACEBOOK_APP_ID],
        settings.FACEBOOK_SECRET_KEY)
    if data is None or \
       datetime.datetime.now() - datetime.datetime.fromtimestamp(data['issued_at']) > datetime.timedelta(minutes=2):
        return redirect('auth:login')
    next = request.GET.get('next', settings.LOGIN_REDIRECT_URL)
    try:
        account = FacebookAccount.objects.get(uid=data['user_id'])
        user = account.user
        if user.is_active:
            user = authenticate(facebook=True, user=user)
            auth_login(request, user)
            return redirect(next)
        else:
            account.delete()
            raise FacebookAccount.DoesNotExist
    except FacebookAccount.DoesNotExist:
        if confirmed:
            if form_data is not None and \
               'avatar' in form_data and \
               'first_name' in form_data and \
               'last_name' in form_data and \
               len(form_data['first_name'] + form_data['last_name']) > 0:
                user_created = False
                first_name = form_data['first_name']
                last_name = form_data['last_name']
                facebook_uid = data['user_id']
                img_url = form_data['avatar']
                email = email
                username_to_try = username_base = form_data['first_name']
                index = 1
                temp_password = User.objects.make_random_password(length=24)
                while not user_created:
                    try:
                        user = User(username=username_to_try,
                                    email=email,
                                    first_name=first_name,
                                    last_name=last_name)
                        user.set_password(temp_password)
                        user.save()
                        user_created = True
                    except:
                        username_to_try = '%s%d' % (username_base, index)
                        index += 1
                if img_url:
                    img = ContentFile(requests.get(img_url).content)
                    name = img_url.split('/')[-1]
                    user.picture.save(name, img, False)
                    FacebookAccount.objects.create(uid=facebook_uid,
                                                   user=user,
                                                   avatar=img_url)
                user = authenticate(facebook=True, user=user)
                auth_login(request, user)
                return redirect('/')
        else:
            return redirect('auth:confirm_create_user', 'facebook', email)
    return redirect('auth:login')
Exemple #27
0
def save_subtitles_for_lang(lang, video_pk, youtube_id):
    from videos.models import Video

    lc = lang.get('lang_code')

    if not lc in SUPPORTED_LANGUAGES_DICT:
        return

    try:
        video = Video.objects.get(pk=video_pk)
    except Video.DoesNotExist:
        return

    from videos.models import SubtitleLanguage, SubtitleVersion, Subtitle

    url = u'http://www.youtube.com/api/timedtext?v=%s&lang=%s&name=%s'
    url = url % (youtube_id, lc, urlquote(lang.get('name', u'')))

    xml = YoutubeVideoType._get_response_from_youtube(url)

    if not xml:
        return

    parser = YoutubeXMLParser(xml)

    if not parser:
        return

    language, create = SubtitleLanguage.objects.get_or_create(video=video,
                                                              language=lc)
    language.is_original = False
    language.is_forked = True
    language.save()

    try:
        version_no = language.subtitleversion_set.order_by('-version_no')[:1] \
            .get().version_no + 1
    except SubtitleVersion.DoesNotExist:
        version_no = 0

    version = SubtitleVersion(language=language)
    version.version_no = version_no
    version.datetime_started = datetime.now()
    version.user = User.get_youtube_anonymous()
    version.note = u'From youtube'
    version.is_forked = True
    version.save()

    for i, item in enumerate(parser):
        subtitle = Subtitle()
        subtitle.subtitle_text = item['subtitle_text']
        subtitle.start_time = item['start_time']
        subtitle.end_time = item['end_time']
        subtitle.version = version
        subtitle.subtitle_id = int(random.random() * 10e12)
        subtitle.subtitle_order = i + 1
        subtitle.save()
        assert subtitle.start_time or subtitle.end_time, item['subtitle_text']
    version.finished = True
    version.save()

    language.has_version = True
    language.had_version = True
    language.is_complete = True
    language.save()

    from videos.tasks import video_changed_tasks
    video_changed_tasks.delay(video.pk)
    def test_email_diff_subtitles(self):
        initial_count = len(mail.outbox)
        # set a user who can receive notification
        # make sure we have a different author, else he won't get notified
        author = User(username='******',
                      email='*****@*****.**',
                      notify_by_email=True,
                      valid_email=True)
        author.save(send_email_confirmation=False)
        # bypass logic from hell
        author.valid_email = True
        author.save()

        # this is needed for the non_editor template check
        user2 = User(username='******',
                     email='*****@*****.**',
                     notify_by_email=True,
                     valid_email=True)
        user2.save(send_email_confirmation=False)
        # bypass logic from hell
        user2.valid_email = True
        user2.save()
        # version is indentical to previous one
        video, video_url = Video.add("http://wwww.example.com/video-diff.mp4",
                                     None)
        video.followers.add(author)
        video.followers.add(user2)

        language = SubtitleLanguage(video=video, language_code='en')
        language.save()
        subs_data = [
            [0, 1000, '1'],
            [1000, 2000, '2'],
        ]

        subtitles_1 = SubtitleSet.from_list('en', subs_data)
        old_version = language.add_version(subtitles=subtitles_1,
                                           author=author)

        # now we change the text on the second sub
        subs_data[1][2] = '2 changed'
        # add a regular sub
        subs_data.append([2000, 3000, 'new sub'])
        # add an unsyced
        subs_data.append([None, None, 'no sync'])
        subtitles_2 = SubtitleSet.from_list('en', subs_data)
        new_version = language.add_version(subtitles=subtitles_2)
        self.assertTrue(len(video.notification_list()) > 0)

        res = send_new_version_notification(new_version.pk)
        self.assertNotEqual(res, None)
        # we expect two emails, one is the new-edits-non-editor, and
        # the other for mail_notification.html
        self.assertEqual(len(mail.outbox), initial_count + 2)
        for email_number, email_msg in enumerate(mail.outbox):
            # make sure this is the right message
            self.assertIn("New edits to ", email_msg.subject)
            self.assertIn("video-diff.mp4", email_msg.subject)
            html = BeautifulSoup(email_msg.body)
            html_text = "".join(html.body(text=True)).replace("\n", "")
            if email_number == 0:
                # assert text and timing changes are correct
                self.assertIn('67% of the text', html_text)
                self.assertIn('33% of the timing was changed.', html_text)
            # find the listed text changes to make sure they match
            diff_table = html.findAll('table', attrs={'class': 'diffs'})[0]
            old_version_changes = []
            new_version_changes = []
            for i, node in enumerate(diff_table.findAll('td')):
                if i % 2 == 0:
                    old_version_changes.append(node.text)
                else:
                    new_version_changes.append(node.text)
            self.assertEqual(old_version_changes, [u'2', u'', u''])
            self.assertEqual(new_version_changes, [
                u'2 changed',
                u'new sub',
                u'no sync',
            ])
Exemple #29
0
 def setUp(self):
     self.video = make_video()
     self.u1 = UserFactory()
     self.u2 = UserFactory()
     self.anon = User.get_amara_anonymous()
Exemple #30
0
 def test_notfications(self):
     self.assertEqual(len(mail.outbox), 0)
     user = User(email='*****@*****.**', username='******')
     user.set_password("secret")
     user.save()
     self.assertEqual(len(mail.outbox), 1)
Exemple #31
0
def setup_amara_db(db):
    CustomUser.get_amara_anonymous()