Backend: Refactoring of models

2 files changed, 138 insertions, 153 deletions

diff --git a/backend/models.py b/backend/models.py
index 6af8879..5a68429 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -5,35 +5,31 @@ from django.db import models
 from django.contrib import auth
 from django.contrib import admin
 
+import json
 
 class SJSettingsModel(models.Model):
     """ ScannerJammer abstract settings model
     """
-    settings = models.TextField(blank=True)
+    settings_text = models.TextField(blank=True)
 
     class Meta:
         abstract = True
 
-    def freeze_settings(self, settings_dict):
-        """ Serialize settings dictionary into settings text field
-        """
-        self.settings = '\n'.join('%s\t%s' % (str(key), str(value)) for key, value in settings_dict.iteritems())
+    @property
+    def settings(self):
+        if not self.settings_text:
+            return dict()
+        return json.loads(self.settings_text, parse_float=True, parse_int=True)
 
-    def thaw_settings(self):
-        """ Deserialize settings text field into settings dictionary
-        """
-        settings_dict = {}
-        if self.settings:
-            for line in self.settings.split('\n'):
-                row = line.split('\t')
-                if len(row) == 2:
-                    settings_dict[row[0]] = row[1]
-        return settings_dict
+    @settings.setter
+    def settings(self, settings):
+        if isinstance(settings, dict):
+            self.settings_text = json.dumps(settings)
+
+    @settings.deleter
+    def settings(self):
+        self.settings_text = '{}'
 
-    def merge_settings(self, settings_dict):
-        """ Merge current setting with settings dictionary
-        """
-        self.freeze_settings(self.thaw_settings().update(settings_dict))
 
 class SJUserProfile(SJSettingsModel):
     """ ScannerJammer user model
@@ -57,100 +53,93 @@ class SJUserProfile(SJSettingsModel):
             return "%s (%s)" % (self.username or self.user.username, self.nickname)
         return "%s" % (self.username or self.user.username)
 
-class SJRoom(SJSettingsModel):
-    """ ScannerJammer room model
-    """
-    name = models.CharField(max_length=32)
-    date = models.DateTimeField()
-    private = models.BooleanField(default=False)
-    tokbox = models.CharField(max_length=64)
-
-    class Meta:
-        verbose_name = "SJ Room"
-
-    def __unicode__(self):
-        return self.name
+class SJUserProfileAdmin(admin.ModelAdmin):
+    list_display = (
+        'user',
+        'nickname',
+        'score',
+        'access',
+        'bio',
+        'joindate',
+        'seendate',
+    )
 
-class SJSiteModel(models.Model):
-    """ ScannerJammer abstract site base model
+class SJUserActivity(models.Model):
+    """ ScannerJammer abstract user activity model
     """
     user = models.ForeignKey(auth.models.User)
-    room = models.ForeignKey(SJRoom)
-    date = models.DateTimeField()
-    url = models.URLField(blank=True, verbose_name="URL")
+    datetime = models.DateTimeField(blank=True)
 
     class Meta:
         abstract = True
 
-    def __unicode__(self):
-        return self.url
 
-class SJBackground(SJSiteModel):
-    """ ScannerJammer background model
+class SJRoom(SJUserActivity, SJSettingsModel):
+    """ ScannerJammer room model
     """
+    name = models.CharField(max_length=32)
+    private = models.BooleanField(default=False)
+
     class Meta:
-        verbose_name = "SJ Background"
+        verbose_name = "SJ Room"
 
-class SJURL(SJSiteModel):
-    """ ScannerJammer url model
-    """
-    likes = models.IntegerField(default=0)
+    def __unicode__(self):
+        return self.name
 
-    class Meta:
-        verbose_name = "SJ URL"
+class SJRoomAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'private',
+        'user',
+        'datetime',
+    )
 
-class SJVideo(SJSiteModel):
-    """ ScannerJammer video model
+class SJContent(SJUserActivity, SJSettingsModel):
+    """ ScannerJammer model to encapsulate site content
     """
-    title = models.CharField(max_length=100)
-    likes = models.IntegerField(default=0)
-    views = models.IntegerField(default=0)
-    removed = models.BooleanField(default=False)
-    thumbnail = models.CharField(max_length=64)
+    CONTENT_TYPE = (
+        (u'url', u'URL'),
+        (u'html', u'HTML'),
+        (u'text', u'Plane Text'),
+        (u'image', u'Image'),
+        (u'video', u'Video'),
+        (u'audio', u'Audio'),
+        (u'background', u'Background'),
+    )
+
+    room = models.ForeignKey(SJRoom)
+    content_type = models.CharField(max_length=32, choices=CONTENT_TYPE)
 
     class Meta:
-        verbose_name = "SJ Video"
+        verbose_name = "SJ Content"
 
     def __unicode__(self):
-        return self.title
+        return '%s\'s %s' % (self.user, self.content_type)
 
-class SJChat(SJSiteModel):
-    """ ScannerJammer chat model
-    """
-    msg = models.TextField(verbose_name="Message")
 
-    class Meta:
-        verbose_name = "SJ Chat"
+class SJContentAdmin(admin.ModelAdmin):
+    list_display = (
+        'room',
+        'content_type',
+        'settings_text',
+    )
 
-class SJLike(models.Model):
+class SJLike(SJUserActivity):
     """ ScannerJammer like model
     """
-    user = models.ForeignKey(auth.models.User)
-    video = models.ForeignKey(SJVideo)
-    url = models.ForeignKey(SJURL, verbose_name="URL")
-    date = models.DateTimeField()
+    content = models.ForeignKey(SJContent)
 
     class Meta:
         verbose_name = "SJ Like"
 
-class SJSearchLog(models.Model):
-    """ SannerJammer search log
-    """
-    date = models.DateTimeField()
-    query = models.CharField(max_length=255)
-    matches = models.IntegerField(default=0)
-
-    class Meta:
-        verbose_name = "SJ Search Log"
-
-    def __unicode__(self):
-        return '%s "%s" matched %d' % (self.date, self.query, self.matches)
+class SJLikeAdmin(admin.ModelAdmin):
+    list_display = (
+        'user',
+        'datetime',
+        'content',
+    )
 
-admin.site.register(SJUserProfile)
-admin.site.register(SJRoom)
-admin.site.register(SJBackground)
-admin.site.register(SJURL)
-admin.site.register(SJVideo)
-admin.site.register(SJChat)
-admin.site.register(SJLike)
-admin.site.register(SJSearchLog)
+admin.site.register(SJUserProfile, SJUserProfileAdmin)
+admin.site.register(SJRoom, SJRoomAdmin)
+admin.site.register(SJContent, SJContentAdmin)
+admin.site.register(SJLike, SJLikeAdmin)
diff --git a/backend/views.py b/backend/views.py
index fa1f761..132649b 100644
--- a/backend/views.py
+++ b/backend/views.py
@@ -1,21 +1,22 @@
 # Create your views here.
 
+from django.conf import settings
 from django.contrib import auth
-from django.views.decorators.http import require_POST
 from django.http import HttpResponse
 from django.http import HttpResponsePermanentRedirect
 from django.template import loader
 from django.template import Context
 from django.shortcuts import render_to_response
-from django.conf import settings
+from django.views.decorators.http import require_POST
 from django.db.models import Q
 from datetime import datetime
 
 import sha
 
-from backend.models import SJUserProfile
-from backend.models import SJVideo
 from backend.models import SJLike
+from backend.models import SJRoom
+from backend.models import SJContent
+from backend.models import SJUserProfile
 
 API_HEADER = '#@scanjam 0.3b\n'
 
@@ -34,22 +35,15 @@ def set_cors_headers(response):
     response['Access-Control-Max-Age'] = '3628800'
     response['Content-type'] = 'text/plain; charset=UTF-8'
 
-def api_error(error, response=None):
-    """ Add API error name to response
-    """
-    if not response:
-        response = HttpResponse()
-    response.write(API_HEADER)
-    response.write('0\t%s\n' % error)
-    return response
-
 def api_error_headers(error, response=None):
     """ Add API error name with setup headers to response
     """
     if not response:
         response = HttpResponse()
     set_cors_headers(response)
-    return api_error(error, response)
+    response.write(API_HEADER)
+    response.write('0\t%s\n' % error)
+    return response
 
 def api_ok_headers(response=None):
     """ Add API OK with setup headers to response
@@ -231,62 +225,64 @@ def api_auth_password(request):
 def api_user_videos(request):
     """ Get list of user videos. Public API
     """
-    form_fields = ['user']
-    response = check_form_fields(request, form_fields)
-    if response:
-        return response
-    try:
-        query = Q(user=auth.models.User.objects.get(id=request.POST['user']))
-    except auth.models.User.DoesNotExist:
-        return api_error_headers('no such user')
-    except:
-        return api_error_headers('db error')
-    if 'start' in request.POST:
-        try:
-            timestamp = float(request.POST['start'])
-            query = query & Q(date__lte=datetime.fromtimestamp(timestamp))
-        except:
-            pass
-    videos = SJVideo.objects.filter(query).order_by('-date')[0:ROOM_VIDEO_LOG_SIZE]
-    if not videos:
-        return api_error_headers('no videos')
-    response = api_ok_headers()
-    response.write('\n'.join(['\t'.join([str(v.id),
-                                         str(v.date),
-                                         str(v.user.id),
-                                         v.user.username,
-                                         v.url,
-                                         v.title]) for v in videos]))
-    return response
+#    form_fields = ['user']
+#    response = check_form_fields(request, form_fields)
+#    if response:
+#        return response
+#    try:
+#        query = Q(user=auth.models.User.objects.get(id=request.POST['user']))
+#    except auth.models.User.DoesNotExist:
+#        return api_error_headers('no such user')
+#    except:
+#        return api_error_headers('db error')
+#    if 'start' in request.POST:
+#        try:
+#            timestamp = float(request.POST['start'])
+#            query = query & Q(date__lte=datetime.fromtimestamp(timestamp))
+#        except:
+#            pass
+#    videos = SJVideo.objects.filter(query).order_by('-date')[0:ROOM_VIDEO_LOG_SIZE]
+#    if not videos:
+#        return api_error_headers('no videos')
+#    response = api_ok_headers()
+#    response.write('\n'.join(['\t'.join([str(v.id),
+#                                         str(v.date),
+#                                         str(v.user.id),
+#                                         v.user.username,
+#                                         v.url,
+#                                         v.title]) for v in videos]))
+#    return response
+    return HttpResponse('Not implemented yet!\n')
 
 @require_POST
 def api_user_likes(request):
     """ Get list of liked videos. Public API
     """
-    form_fields = ['user']
-    response = check_form_fields(request, form_fields)
-    if response:
-        return response
-    try:
-        query = Q(sjlike__user=auth.models.User.objects.get(id=request.POST['user']))
-    except auth.models.User.DoesNotExist:
-        return api_error_headers('no such user')
-    except:
-        return api_error_headers('db error')
-    if 'start' in request.POST:
-        try:
-            timestamp = float(request.POST['start'])
-            query = query & Q(date__lte=datetime.fromtimestamp(timestamp))
-        except:
-            pass
-    videos = SJVideo.objects.filter(query).order_by('-date')[0:ROOM_VIDEO_LOG_SIZE]
-    if not videos:
-        return api_error_headers('no videos')
-    response = api_ok_headers()
-    response.write('\n'.join(['\t'.join([str(v.user.id),
-                                         str(v.id),
-                                         str(v.date)]) for v in videos]))
-    return response
+#    form_fields = ['user']
+#    response = check_form_fields(request, form_fields)
+#    if response:
+#        return response
+#    try:
+#        query = Q(sjlike__user=auth.models.User.objects.get(id=request.POST['user']))
+#    except auth.models.User.DoesNotExist:
+#        return api_error_headers('no such user')
+#    except:
+#        return api_error_headers('db error')
+#    if 'start' in request.POST:
+#        try:
+#            timestamp = float(request.POST['start'])
+#            query = query & Q(date__lte=datetime.fromtimestamp(timestamp))
+#        except:
+#            pass
+#    videos = SJVideo.objects.filter(query).order_by('-date')[0:ROOM_VIDEO_LOG_SIZE]
+#    if not videos:
+#        return api_error_headers('no videos')
+#    response = api_ok_headers()
+#    response.write('\n'.join(['\t'.join([str(v.user.id),
+#                                         str(v.id),
+#                                         str(v.date)]) for v in videos]))
+#    return response
+    return HttpResponse('Not implemented yet!\n')
 
 @require_POST
 def api_user_top(request):