Backend / Event and related endpoints

backend/api/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'api.apps.ApiConfig'

backend/api/apps.py

@@ -3,3 +3,6 @@
 
 class ApiConfig(AppConfig):
     name = 'api'
+
+    def ready(self):
+        import api.handlers

backend/api/handlers.py

@@ -0,0 +1,17 @@
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import F
+from django.db.models.signals import post_save, pre_delete
+from django.dispatch import receiver
+
+from api.models import FollowStatus
+
+
+@receiver(post_save, sender=FollowStatus, dispatch_uid='increment_follower_count')
+def increment_follower_count(sender, instance, **kwargs):
+    instance.content_type.model_class().objects.\
+        filter(id=instance.object_id).update(follower_count=F('follower_count')+1)
+
+@receiver(pre_delete, sender=FollowStatus, dispatch_uid='decrement_follower_count')
+def decrement_follower_count(sender, instance, **kwargs):
+    instance.content_type.model_class().objects.\
+        filter(id=instance.object_id).update(follower_count=F('follower_count')-1)

backend/api/models.py

@@ -1,3 +1,174 @@
+from django.conf import settings
+from django.contrib.contenttypes.fields import (GenericForeignKey,
+                                                GenericRelation)
+from django.contrib.contenttypes.models import ContentType
 from django.db import models
+from django.utils import timezone
 
-# Create your models here.
+
+class OwnerMixin(models.Model):
+    """
+    Each model that belongs to a `User` must use this mixin.
+    """
+    owner = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='%(class)s_set', on_delete=models.CASCADE)
+
+    class Meta:
+        abstract = True
+
+
+class CommentMixin(models.Model):
+    """
+    Each model that contains `Comment`s must use this mixin.
+    """
+    comments = GenericRelation('Comment')
+
+    class Meta:
+        abstract = True
+
+
+class FollowMixin(models.Model):
+    """
+    Each model that can be followed by a user must use this mixin.
+    """
+    followers = GenericRelation('FollowStatus')
+    follower_count = models.IntegerField(default=0)
+
+    class Meta:
+        abstract = True
+
+
+class LocationMixin(models.Model):
+    """
+    Each model that contains a `Location` must use this mixin.
+    """
+    location = GenericRelation('Location')
+
+    class Meta:
+        abstract = True
+
+
+class MediaMixin(models.Model):
+    """
+    Each model that contains `Media`s must use this mixin.
+    """
+    medias = GenericRelation('Media')
+
+    class Meta:
+        abstract = True
+
+
+class VoteMixin(models.Model):
+    """
+    Each model that can be voted by a user must use this mixin.
+    """
+    votes = GenericRelation('VoteStatus')
+    vote_count = models.IntegerField(default=0)
+
+    class Meta:
+        abstract = True
+
+    def update_vote_count(self, vote_value, voted_before):
+        if voted_before:
+            vote_value = vote_value * 2
+        self.vote_count = self.vote_count + vote_value
+        self.save()
+
+
+class GenericModelMixin(models.Model):
+    """
+    Allows generic relations between different models.
+    See https://docs.djangoproject.com/en/2.1/ref/contrib/contenttypes/
+    """
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey('content_type', 'object_id')
+
+    class Meta:
+        abstract = True
+
+
+class Event(OwnerMixin, CommentMixin, FollowMixin, LocationMixin, MediaMixin, VoteMixin):
+    # Related fields
+    # TODO Decide if an artist must be a User in our system.
+    artists = models.ManyToManyField(settings.AUTH_USER_MODEL, db_table='event_artists',
+                                     related_name='performed_events', blank=True)
+    tags = models.ManyToManyField('Tag', db_table='event_tags', related_name='events',
+                                  blank=True)
+
+    # Own fields
+    title = models.CharField(max_length=100)
+    description = models.TextField()
+    date = models.DateTimeField(default=timezone.now)
+    price = models.DecimalField(max_digits=6, decimal_places=2, blank=True, default=0.0)
+    organizer_url = models.URLField(blank=True, null=True)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+
+
+class AttendanceStatus(OwnerMixin):
+    ATTENDANCE_STATUS = (
+        ('Y', 'Yes'),
+        ('N', 'No'),
+        ('M', 'Maybe'),
+        ('A', 'Attended'),
+        ('B', 'Blocked'),
+    )
+    event = models.ForeignKey(Event, related_name='attendance_status', on_delete=models.CASCADE)
+    status = models.CharField(max_length=1, choices=ATTENDANCE_STATUS)
+
+    class Meta:
+        # There can be only one attendance status between User and Event.
+        unique_together = ('owner', 'event')
+
+
+class Comment(GenericModelMixin, OwnerMixin):
+    content = models.TextField()
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+
+
+class FollowStatus(GenericModelMixin, OwnerMixin):
+    class Meta:
+        # A user cannot follow the same item more than once
+        unique_together = ('owner', 'content_type', 'object_id')
+
+
+class Location(GenericModelMixin, OwnerMixin):
+    # TODO Add required fields after doing research about Google Maps / Places API
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        # A model (User, Event etc.) cannot have more than one Location.
+        unique_together = ('content_type', 'object_id')
+
+
+class Media(GenericModelMixin, OwnerMixin):
+    url = models.URLField()
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+
+
+class Tag(models.Model):
+    name = models.CharField(max_length=20)
+
+
+class VoteStatus(GenericModelMixin, OwnerMixin):
+    VOTE_CHOICES = (
+        ('U', 'Up'),
+        ('D', 'Down'),
+    )
+    vote = models.CharField(max_length=1, choices=VOTE_CHOICES)
+
+    class Meta:
+        # A user cannot vote for the same item more than once
+        unique_together = ('owner', 'content_type', 'object_id')
+
+    @property
+    def vote_value(self):
+        vote_value = 0
+        if self.vote == 'U':
+            vote_value = 1
+        elif self.vote == 'D':
+            vote_value = -1
+        return  vote_value

backend/api/permissions.py

@@ -0,0 +1,9 @@
+from rest_framework import permissions
+
+
+class IsOwnerOrReadOnly(permissions.BasePermission):
+
+    def has_object_permission(self, request, view, obj):
+        if request.method in permissions.SAFE_METHODS:
+            return True
+        return obj.owner == request.user