UUID support for model IDs about stream-django HOT 16 CLOSED

Django==1.10.5
stream-django==1.3.1
stream-python==2.3.9

# core.models
from django.contrib.auth.models import AbstractUser
from django.contrib.postgres.fields import JSONField
from django.db import models
from django.utils.translation import ugettext_lazy as _

class User(AbstractUser):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    is_email_visible = models.BooleanField(default=True)
    avatar = models.ImageField(('avatar'), max_length=1024, upload_to=_avatar_upload_to, blank=True)
    stream_token = models.CharField(_('stream token'), max_length=100, blank=True, null=True,
                                    help_text=_('User token from GetStream'))
    params = JSONField(_('params'), null=True, blank=True,)

# apps.posts.models

# Third-party app imports
from stream_django.activity import Activity
from stream_django.feed_manager import feed_manager

# Imports from local apps
from proj.apps.vote.models import VoteModel
from proj.core.models import User

class Post(VoteModel, Activity):
    user = models.ForeignKey(settings.AUTH_USER_MODEL)
    text = models.TextField(_('text'), )
    created_at = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)

    class Meta:
        verbose_name = _('post')
        verbose_name_plural = _('posts')

    def __str__(self):
        return 'post by {0}'.format(self.user.username)

    @property
    def activity_time(self):
        return self.created

    @property
    def print_self(self):
        print(self.text)

    @property
    def activity_object_attr(self):
        return self

    def save(self, **kwargs):
        self.create_hashtags()
        super(Post, self).save()

    def create_hashtags(self):
        hashtag_set = set(self.parse_hashtags())
        for hashtag in hashtag_set:
            h, _ = Hashtag.objects.get_or_create(name=hashtag)
            h.save()
        Hashtag.objects.filter(name__in=hashtag_set).update(occurrences=F('occurrences')+1)

    def parse_hashtags(self):
        return [slugify(i) for i in self.text.split() if i.startswith("#")]

    def parse_mentions(self):
        mentions = [slugify(i) for i in self.text.split() if i.startswith("@")]
        return User.objects.filter(username__in=mentions)

    def parse_all(self):
        parts = self.text.split()
        hashtag_counter = 0
        mention_counter = 0
        result = {"parsed_text": "", "hashtags": [], "mentions": []}
        for index, value in enumerate(parts):
            if value.startswith("#"):
                parts[index] = "{hashtag" + str(hashtag_counter) + "}"
                hashtag_counter += 1
                result[u'hashtags'].append(slugify(value))
            if value.startswith("@"):
                parts[index] = "{mention" + str(mention_counter) + "}"
                mention_counter += 1
                result[u'mentions'].append(slugify(value))
        result[u'parsed_text'] = " ".join(parts)
        return result

    @property
    def activity_notify(self):
        targets = [feed_manager.get_news_feeds(self.user_id)['timeline']]
        for hashtag in self.parse_hashtags():
            targets.append(feed_manager.get_feed('user', 'hash_%s' % hashtag))
        for user in self.parse_mentions():
            targets.append(feed_manager.get_news_feeds(user.id)['timeline'])
        return targets

http://localhost:8000/api/v1/users/<username  or uuid>/timeline/

class TimelineViewSet(ViewSet):
    """
    View to list user timeline.
    """
    throttle_scope = 'timelines'

    def list(self, request, *args, **kwargs):
        # get user from <username  or uuid>
        user = get_user_from_url(self.kwargs, self.request.user)

        enricher = Enrich()
        # The news feeds (or timelines) store the activities from the people you follow. There is both a simple timeline
        # newsfeed (similar to twitter) and an aggregated version (like facebook).
        feed = feed_manager.get_feed('timeline_aggregated', user.id)
        activities = feed.get(limit=25)['results']
        enriched_activities = enricher.enrich_activities(activities)
`# !!!!!!! need to be serialized and paginated !!!!!`
        return Response(enriched_activities)

[
    {
        "updated_at": "2017-02-24T15:54:37.730000",
        "created_at": "2017-02-24T15:54:37.730000",
        "group": "37326_2017-02-24",
        "actor_count": 1,
        "verb": "post",
        "id": "8b720ea8-faa9-11e6-8080-800060963a97",
        "activity_count": 1,
        "activities": [
            {
                "verb": "post",
                "actor": "core.User:5212346d-1315-4ee4-bb71-5ce3c3df80f3",
                "time": "2017-02-24T15:54:37.730372",
                "id": "8b720ea8-faa9-11e6-8080-800060963a97",
                "to": [
                    "timeline:5212346d-1315-4ee4-bb71-5ce3c3df80f3"
                ],
                "foreign_id": "posts.Post:20",
                "target": null,
                "origin": "user:5212346d-1315-4ee4-bb71-5ce3c3df80f3",
                "object": "posts.Post:20"
            }
        ]
    }
]

feed = feed_manager.get_feed('timeline_aggregated', user.id)
activities = feed.get(limit=25)['results']

[{'activities': [{'actor': 'core.User:5212346d-1315-4ee4-bb71-5ce3c3df80f3',
                  'foreign_id': 'posts.Post:36',
                  'id': 'e24b49bc-fce1-11e6-8080-80011a798ab0',
                  'object': 'posts.Post:36',
                  'origin': 'user:5212346d-1315-4ee4-bb71-5ce3c3df80f3',
                  'target': None,
                  'time': datetime.datetime(2017, 2, 27, 11, 42, 57, 580486),
                  'to': ['timeline:5212346d-1315-4ee4-bb71-5ce3c3df80f3'],
                  'verb': 'post'}],
  'activity_count': 1,
  'actor_count': 1,
  'created_at': datetime.datetime(2017, 2, 27, 11, 42, 57, 580000),
  'group': '37326_2017-02-27',
  'id': 'e24b49bc-fce1-11e6-8080-80011a798ab0',
  'updated_at': datetime.datetime(2017, 2, 27, 11, 42, 57, 580000),
  'verb': 'post'}]

[EnrichedActivity(activity_data={
	'actor_count': 1,
	'activities': [{'object': 'posts.Post:36',
			'target': None,
			'origin': 'user:5212346d-1315-4ee4-bb71-5ce3c3df80f3',
			'foreign_id': 'posts.Post:36', 
			'to': ['timeline:5212346d-1315-4ee4-bb71-5ce3c3df80f3'],
			'time': datetime.datetime(2017, 2, 27, 11, 42, 57, 580486),
			'id': 'e24b49bc-fce1-11e6-8080-80011a798ab0',
			'actor': 'core.User:5212346d-1315-4ee4-bb71-5ce3c3df80f3',
			'verb': 'post'}], 
	'group': '37326_2017-02-27',
	'id': 'e24b49bc-fce1-11e6-8080-80011a798ab0',
	'activity_count': 1,
	'updated_at': datetime.datetime(2017, 2, 27, 11, 42, 57, 580000),
	'verb': 'post',
	'created_at': datetime.datetime(2017, 2, 27, 11, 42, 57, 580000)}, 
	not_enriched_data={})
]

        for activity, field in itertools.product(activities, fields):
            if not self.is_ref(activity, field):
                continue

    def is_ref(self, activity, field):
        return len(activity[field].split(':')) == 2 if activity.get(field) else False

model = get_model(*f_ct.split('.'))
f_id = model._meta.pk._**to_python**_(f_id)