Example #1
0
def user_notification_timeline(request, user_id):
    # todo high don't allow others to see the notifications of another user by changing the url (same with tips)
    # TODO high more button to load the next activities
    # I use the low level client (stream_client) instead of the high level feedmanager of the stream django app
    # without specific reason so I can use the feedmanager instead
    get_activities_num = 80
    per_page = 12
    user_notification_feed = stream_client.feed(FeedNames.notification,
                                                user_id)
    # it seems that first the activities are collected and then they are marked as seen. This way I can
    # check if an activity is currently seen or not
    activities = user_notification_feed.get(limit=get_activities_num,
                                            mark_seen=True,
                                            mark_read=True)['results']
    # next_activities = user_notification_feed.get(limit=get_activities_num, id_lt=activities[-1]['id'])['results']
    enricher = Enrich(
        fields=['actor', 'object', 'bet_event', 'total_bet', 'event'])
    enriched_activities = enricher.enrich_aggregated_activities(activities)
    paginator = Paginator(enriched_activities, per_page)
    enriched_activities = zakanda.utils.paginate(request, paginator,
                                                 enriched_activities)
    context = {
        'enriched_activities': enriched_activities,
        'not_started': games.models.Event.not_started
    }
    return TemplateResponse(request, 'feeds/timeline.html', context)
Example #2
0
    def get(self, request, *args, **kwargs):
        if request.GET.get('partial') == 'activities':
            # activities
            try:
                project = self.get_object()
                enricher = Enrich((
                    'actor',
                    'target',
                ))
                feed = feed_manager.get_challenge_feed(challenge_id=project.pk)
                activities = feed.get(limit=6)['results']
                enriched = enricher.enrich_activities(activities)
                return render(request, 'projects/_activities.html',
                              {'activities': enriched})
            except Exception:
                return HttpResponse()

        if request.GET.get('partial') == 'completed':
            # current user status
            data = {'completed': False}
            try:
                user = request.user
                if not user.is_authenticated():
                    raise Exception('not authenticated')

                project = self.get_object()
                user_project = UserProject.objects.get(project=project,
                                                       user=request.user)
                data['complete'] = user_project.is_complete()
            except Exception:
                pass
            return JsonResponse(data)

        return super().get(request, *args, **kwargs)
Example #3
0
def user_timeline(request, user_pk):
    get_activities_num = 80
    per_page = 15
    enricher = Enrich(
        fields=['actor', 'object', 'bet_event', 'total_bet', 'event'])
    logger.debug("getting timeline feed...")
    user_timeline = stream_client.feed(FeedNames.timeline, user_pk)
    # we collect a number of activities and then we can filter or paginate them as we want
    activities = user_timeline.get(limit=get_activities_num)['results']
    # next_activities = user_timeline.get(limit=50, id_lt=activities[-1]['id'])['results']
    # enriched activities is a list of stream_django.enrich.EnrichedActivity instances (they have __getitem__, __iter__)
    enriched_activities = enricher.enrich_activities(activities)
    # # add_isopen_to_tb_enriched_activities(enriched_activities)
    paginator = Paginator(enriched_activities, per_page)
    enriched_activities = zakanda.utils.paginate(request, paginator,
                                                 enriched_activities)
    # enriched_activities_2 = enricher.enrich_activities(next_activities)
    enriched_activities_2 = None
    # # add_isopen_to_tb_enriched_activities(enriched_activities_2)

    context = {
        'enriched_activities': enriched_activities,
        'enriched_activities_2': enriched_activities_2,
        'not_started': games.models.Event.not_started
    }
    return TemplateResponse(request, 'feeds/timeline.html', context)
Example #4
0
def profile_feed(request, username=None):
    enricher = Enrich()
    user = User.objects.get(username=username)
    feed = feed_manager.get_user_feed(user.id)
    activities = feed.get(limit=25)['results']
    enricher.enrich_activities(activities)
    context = {'activities': activities}
    return render(request, 'tweets.html', context)
Example #5
0
def hashtag(request, hashtag):
    enricher = Enrich()
    feed = feed_manager.get_feed('hashtag', hashtag)
    activities = feed.get(limit=25)['results']
    enricher.enrich_activities(activities)
    context = {
        'activities': activities
    }
    return render(request, 'hashtag.html', context)
Example #6
0
def notifications(request):
    user = request.user

    notification_feed = feed_manager.get_notification_feed(user.id)
    notification_stats = notification_feed.get(limit=10, mark_seen=True)
    enricher = Enrich()
    notifications = enricher.enrich_aggregated_activities(
        notification_stats['results'])

    return render(request, 'activity/aggregated/report.html',
                  {'notifications': notifications})
Example #7
0
 def get(self, request):
     if request.GET.get('partial') == 'activities':
         try:
             enricher = Enrich(('actor', 'object', 'target'))
             feed = feed_manager.get_global_challenge_feed()
             activities = feed.get(limit=10)['results']
             enriched = enricher.enrich_aggregated_activities(activities)
             return render(request, 'base/_activities.html',
                           {'activities': enriched})
         except Exception as e:
             return HttpResponse()
     return super().get(request)
Example #8
0
 def get(self, request):
     user = self.request.user
     if request.GET.get('partial') == 'notifications':
         try:
             enricher = Enrich(('actor', 'object', 'target',))
             feed = feed_manager.get_notification_feed(user.id)
             activities = feed.get(limit=10)['results']
             enriched = enricher.enrich_aggregated_activities(activities)
         except Exception:
             enriched = []
         finally:
             return render(request, 'account/_notifications_card_content.html', {'notifications': enriched})
     return super().get(request)
Example #9
0
def Home(request):
    enricher = Enrich()
    feeds = feed_manager.get_news_feeds(request.user.id)
    activities = feeds.get('flat').get()['results']
    activities = enricher.enrich_activities(activities)
    hashtags = Hashtag.objects.order_by('-occurrences')
    SelectedAthlete = get_object_or_404(Athlete, id=request.user.athlete.id)
    TotalAthletes = Athlete.objects.count()
    contextdata = {
        'activities': activities,
        'login_user': request.user,
        'hashtags': hashtags,
        'TotalAthletes': TotalAthletes
    }
    return render(request, 'index.html', contextdata)
Example #10
0
 def get(self, request, cityslug, format=None):
     '''
     enricher = Enrich()
     flat_feed = feed_manager.get_news_feed(cityslug)['flat']
     activities = feed.get(limit=25)['results']
     enriched_activities = enricher.enrich_activities(activities)
     '''
     '''
     UserEventsQuerySet = UserEvent.objects.filter(city__slug = cityslug).order_by('-created_at')[:3600]
     serialized = UserEventSerializer(UserEventsQuerySet, many=True)
     return Response(serialized.data)
     '''
     enricher = Enrich()
     feed = feed_manager.get_feed('cityevents', cityslug)
     activities = feed.get(limit=25)['results']
     enriched_activities = enricher.enrich_activities(activities)
     serialized = UserEventSerializer(enriched_activities, many=True)
     return Response(serialized.data)
Example #11
0
def user_aggregated_timeline(request, user_pk):
    get_activities_num = 80
    per_page = 15
    user_aggr_timeline = stream_client.feed(FeedNames.timeline_aggregated,
                                            user_pk)
    activities = user_aggr_timeline.get(limit=get_activities_num)['results']
    # logger.debug("activities: %s", activities['activities'])
    enricher = Enrich(
        fields=['actor', 'object', 'bet_event', 'total_bet', 'event'])
    enriched_activities = enricher.enrich_aggregated_activities(activities)
    paginator = Paginator(enriched_activities, per_page)
    enriched_activities = zakanda.utils.paginate(request, paginator,
                                                 enriched_activities)
    feeds.utils.print_enriched_aggr_activities(enriched_activities)
    context = {
        'enriched_activities': enriched_activities,
        'not_started': games.models.Event.not_started
    }
    return TemplateResponse(request, 'feeds/timeline.html', context)
Example #12
0
 def get(self, request):
     user = self.request.user
     if request.GET.get("partial") == "notifications":
         try:
             enricher = Enrich(
                 (
                     "actor",
                     "object",
                     "target",
                 )
             )
             feed = feed_manager.get_notification_feed(user.id)
             activities = feed.get(limit=10)["results"]
             enriched = enricher.enrich_aggregated_activities(activities)
         except Exception:
             enriched = []
         finally:
             return render(
                 request,
                 "account/_notifications_card_content.html",
                 {"notifications": enriched},
             )
     return super().get(request)
Example #13
0
from django.views.generic.edit import CreateView
from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth import authenticate, login as auth_login
from django.contrib.auth.models import User
from stream_django.enrich import Enrich
from stream_django.feed_manager import feed_manager
from stream_twitter.forms import FollowForm
from stream_twitter.models import Follow
from stream_twitter.models import Tweet, Hashtag
from pytutorial import settings
import random

enricher = Enrich()


class TimelineView(CreateView):
    model = Tweet
    fields = ['text']
    success_url = "/timeline/"

    def form_valid(self, form):
        form.instance.user = self.request.user
        return super(TimelineView, self).form_valid(form)

    def get(self, request):
        feeds = feed_manager.get_news_feeds(request.user.id)
        activities = feeds.get('timeline').get()['results']
        activities = enricher.enrich_activities(activities)
        hashtags = Hashtag.objects.order_by('-occurrences')
        context = {
            'activities': activities,
 def setUp(self):
     feed_manager.enable_model_tracking()
     self.User = get_user_model()
     self.bogus = self.User.objects.create()
     self.enricher = Enrich()
class PinTest(TestCase):

    def setUp(self):
        feed_manager.enable_model_tracking()
        self.User = get_user_model()
        self.bogus = self.User.objects.create()
        self.enricher = Enrich()

    def register_post_api(self):
        httpretty.register_uri(httpretty.POST, api_url,
              body='{}', status=200,
              content_type='application/json')

    def register_delete_api(self):
        httpretty.register_uri(httpretty.DELETE, api_url,
              body='{}', status=200,
              content_type='application/json')

    @httpretty.activate
    def test_create(self):
        self.register_post_api()
        pin = models.Pin.objects.create(author=self.bogus)
        last_req = httpretty.last_request()
        req_body = last_req.parsed_body
        self.assertEqual(req_body['foreign_id'], 'test_app.Pin:%s' % pin.id)
        self.assertEqual(req_body['object'], 'test_app.Pin:%s' % pin.id)
        self.assertEqual(req_body['verb'], 'pin')
        self.assertEqual(req_body['actor'], 'auth.User:%s' % self.bogus.id)

    @httpretty.activate
    def test_delete(self):
        self.register_post_api()
        self.register_delete_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.delete()
        last_req = httpretty.last_request()
        self.assertEqual(last_req.method, httpretty.DELETE)

    @httpretty.activate
    def test_enrich_instance(self):
        self.register_post_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        activity = pin.create_activity()

        enriched_data = self.enricher.enrich_activities([activity])
        # check object field
        self.assertEqual(enriched_data[0]['object'].id, pin.id)
        self.assertIsInstance(enriched_data[0]['object'], models.Pin)
        # check actor field
        self.assertEqual(enriched_data[0]['actor'].id, pin.author_id)
        self.assertIsInstance(enriched_data[0]['actor'], self.User)

    @httpretty.activate
    def test_enrich_data_with_missing_reference(self):
        self.register_post_api()
        self.register_delete_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        activity = pin.create_activity()
        pin.delete()
        # make sure missing data is correctly tracked
        enriched_data = self.enricher.enrich_activities([activity])
        self.assertFalse(enriched_data[0].enriched)
        self.assertIn('object', enriched_data[0].not_enriched_data)
        self.assertDictContainsSubset(dict(object=activity['object']), enriched_data[0].not_enriched_data)
        self.assertEqual(activity['object'], enriched_data[0]['object'])

    def test_disabled_tracking(self):
        feed_manager.disable_model_tracking()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        pin.delete()
 def setUp(self):
     feed_manager.enable_model_tracking()
     self.User = get_user_model()
     self.bogus = self.User.objects.create()
     self.enricher = Enrich()
class PinTest(TestCase):
    def setUp(self):
        feed_manager.enable_model_tracking()
        self.User = get_user_model()
        self.bogus = self.User.objects.create()
        self.enricher = Enrich()

    def register_post_api(self):
        httpretty.register_uri(httpretty.POST,
                               api_url,
                               body='{}',
                               status=200,
                               content_type='application/json')

    def register_delete_api(self):
        httpretty.register_uri(httpretty.DELETE,
                               api_url,
                               body='{}',
                               status=200,
                               content_type='application/json')

    @httpretty.activate
    def test_create(self):
        self.register_post_api()
        pin = models.Pin.objects.create(author=self.bogus)
        last_req = httpretty.last_request()
        req_body = last_req.parsed_body
        self.assertEqual(req_body['foreign_id'], 'test_app.Pin:%s' % pin.id)
        self.assertEqual(req_body['object'], 'test_app.Pin:%s' % pin.id)
        self.assertEqual(req_body['verb'], 'pin')
        self.assertEqual(req_body['actor'], 'auth.User:%s' % self.bogus.id)

    @httpretty.activate
    def test_delete(self):
        self.register_post_api()
        self.register_delete_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.delete()
        last_req = httpretty.last_request()
        self.assertEqual(last_req.method, httpretty.DELETE)

    @httpretty.activate
    def test_enrich_instance(self):
        self.register_post_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        activity = pin.create_activity()

        enriched_data = self.enricher.enrich_activities([activity])
        # check object field
        self.assertEqual(enriched_data[0]['object'].id, pin.id)
        self.assertIsInstance(enriched_data[0]['object'], models.Pin)
        # check actor field
        self.assertEqual(enriched_data[0]['actor'].id, pin.author_id)
        self.assertIsInstance(enriched_data[0]['actor'], self.User)

    @httpretty.activate
    def test_enrich_data_with_missing_reference(self):
        self.register_post_api()
        self.register_delete_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        activity = pin.create_activity()
        pin.delete()
        # make sure missing data is correctly tracked
        enriched_data = self.enricher.enrich_activities([activity])
        self.assertFalse(enriched_data[0].enriched)
        self.assertIn('object', enriched_data[0].not_enriched_data)
        self.assertDictContainsSubset(dict(object=activity['object']),
                                      enriched_data[0].not_enriched_data)
        self.assertEqual(activity['object'], enriched_data[0]['object'])

    def test_disabled_tracking(self):
        feed_manager.disable_model_tracking()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        pin.delete()
class PinTest(TestCase):
    def setUp(self):
        feed_manager.enable_model_tracking()
        self.User = get_user_model()
        self.bogus = self.User.objects.create()
        self.enricher = Enrich()

    def register_post_api(self):
        httpretty.register_uri(
            httpretty.POST,
            api_url,
            body="{}",
            status=200,
            content_type="application/json",
        )

    def register_delete_api(self):
        httpretty.register_uri(
            httpretty.DELETE,
            api_url,
            body="{}",
            status=200,
            content_type="application/json",
        )

    @httpretty.activate
    def test_create(self):
        self.register_post_api()
        pin = models.Pin.objects.create(author=self.bogus)
        last_req = httpretty.last_request()
        req_body = last_req.parsed_body
        self.assertEqual(req_body["foreign_id"], "test_app.Pin:%s" % pin.id)
        self.assertEqual(req_body["object"], "test_app.Pin:%s" % pin.id)
        self.assertEqual(req_body["verb"], "pin")
        self.assertEqual(req_body["actor"], "auth.User:%s" % self.bogus.id)

    @httpretty.activate
    def test_delete(self):
        self.register_post_api()
        self.register_delete_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.delete()
        last_req = httpretty.last_request()
        self.assertEqual(last_req.method, httpretty.DELETE)

    @httpretty.activate
    def test_enrich_instance(self):
        self.register_post_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        activity = pin.create_activity()

        enriched_data = self.enricher.enrich_activities([activity])
        # check object field
        self.assertEqual(enriched_data[0]["object"].id, pin.id)
        self.assertIsInstance(enriched_data[0]["object"], models.Pin)
        # check actor field
        self.assertEqual(enriched_data[0]["actor"].id, pin.author_id)
        self.assertIsInstance(enriched_data[0]["actor"], self.User)

    @httpretty.activate
    def test_enrich_data_with_missing_reference(self):
        self.register_post_api()
        self.register_delete_api()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        activity = pin.create_activity()
        pin.delete()
        # make sure missing data is correctly tracked
        enriched_data = self.enricher.enrich_activities([activity])
        self.assertFalse(enriched_data[0].enriched)
        self.assertIn("object", enriched_data[0].not_enriched_data)

        activity_obj = set(dict(object=activity["object"]).items())
        enriched_obj = set(enriched_data[0].not_enriched_data.items())
        assert activity_obj.issubset(enriched_obj)

        self.assertEqual(activity["object"], enriched_data[0]["object"])

    def test_disabled_tracking(self):
        feed_manager.disable_model_tracking()
        pin = models.Pin.objects.create(author=self.bogus)
        pin.save()
        pin.delete()
Example #19
0
def CityCommunityPostPage(request, cityslug):
    contextdata = {}
    SelectedCity = get_object_or_404(City, slug = cityslug)
    SelectedAthlete = get_object_or_404(Athlete, id=request.user.athlete.id)
    if request.method == 'POST' and request.is_ajax():
        form = CommunityPostForm(request.POST)
        if form.is_valid():
            user = request.user
            body = form.cleaned_data['body']
            communitypost = CommunityPost(user=user, body=body, city=SelectedCity)
            communitypost.save()
            contextdata = {
                'CommunityPost': communitypost
            }
            html = render_to_string('communitypost.html', contextdata, context_instance = RequestContext(request))
            return JsonResponse({'html': html})
        else:
            msg="AJAX post invalid"
            contextdata = {'form': form}
            return render(request, 'communitylocation/citypostpage.html', contextdata)
    if request.method == 'GET' and request.is_ajax():
        if request.GET.get('postid'):
            if request.GET.get('verifiedathleteslug'):
                postid = request.GET['postid']
                verifiedathleteslug = request.GET['verifiedathleteslug']
                SelectedAthlete = get_object_or_404(Athlete, slug=verifiedathleteslug)
                Comments = Comment.objects.filter(user__username = SelectedAthlete.user.username).filter(object_pk = postid).order_by('submit_date')
                contextdata = {
                    'comment_list': Comments,
                    'postid': postid
                }
                commentshtml = render_to_string("comments/list.html", contextdata, context_instance = RequestContext(request))
                return JsonResponse({'commentshtml': commentshtml})
            else:
                postid = request.GET['postid']
                Comments = Comment.objects.filter(object_pk = postid).order_by('submit_date')
                contextdata = {
                    'comment_list': Comments,
                    'postid': postid
                }
                commentshtml = render_to_string("comments/list.html", contextdata, context_instance = RequestContext(request))
                return JsonResponse({'commentshtml': commentshtml})
        if request.GET.get('postidreq'):
            postidreq = request.GET['postidreq']
            SelectedPost = CommunityPost.objects.get(id = postidreq)
            SelectedPost.delete()
            return JsonResponse({'postID': postidreq})
        if request.GET.get('commentidreq'):
            commentidreq = request.GET['commentidreq']
            comment = get_object_or_404(comments.get_model(), pk=commentidreq, site__pk=settings.SITE_ID)
            perform_delete(request, comment)
            return JsonResponse({'commentID': commentidreq})
    else:
        form = CommunityPostForm()
        enricher = Enrich()
        feed = feed_manager.get_feed('citypost', SelectedCity.name.replace(" ", "_"))
        activities = feed.get(limit=25)['results']
        enricher.enrich_activities(activities)
        contextdata = {
            'City': SelectedCity,
            'form': form,
            'activities': activities
        }
        return render(request, 'communitylocation/citypostpage.html', contextdata)