app refactored and redesigned

handlers class created
static dir included

.gitignore

@@ -1 +1,2 @@
 *.py[co]
+.DS_Store

chatrooms.egg-info/SOURCES.txt

@@ -2,9 +2,10 @@ README.txt
 setup.cfg
 setup.py
 chatrooms/__init__.py
+chatrooms/__views.py
 chatrooms/admin.py
 chatrooms/models.py
-chatrooms/test_urls.py
+chatrooms/signals.py
 chatrooms/tests.py
 chatrooms/urls.py
 chatrooms/views.py
@@ -24,4 +25,5 @@ chatrooms/management/commands/__init__.py
 chatrooms/management/commands/test_gevent.py
 chatrooms/utils/__init__.py
 chatrooms/utils/auth.py
-chatrooms/utils/decorators.py
+chatrooms/utils/decorators.py
+chatrooms/utils/examples.py

chatrooms/ajax/chat.py

@@ -6,27 +6,27 @@
 from collections import deque
 
 from django.conf import settings
-from django.contrib.auth.models import User
-from django.db.models import Max
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.http import (HttpResponse,
                         HttpResponseNotFound,
                         HttpResponseBadRequest)
+from django.shortcuts import get_object_or_404
 from django.utils.decorators import method_decorator
 
 from gevent.event import Event
 
-from ..models import Room, Message
+from ..models import Room
 from ..signals import chat_message_received
 from ..utils.auth import check_user_passes_test
 from ..utils.decorators import ajax_user_passes_test_or_403
 from ..utils.decorators import ajax_login_required
+from ..utils.handlers import MessageHandlerFactory
 
 
 TIME_FORMAT = '%Y-%m-%dT%H:%M:%S:%f'
 
-TIMEOUT = 20
+TIMEOUT = 30
 if settings.DEBUG:
     TIMEOUT = 3
 
@@ -57,20 +57,26 @@ def get_messages(self, request):
         """
         try:
             room_id = int(request.GET['room_id'])
-            latest_id = int(request.GET['latest_id'])
+            latest_msg_id = int(request.GET['latest_message_id'])
         except:
-            return HttpResponseNotFound('not found', mimetype="text/plain")
-        room = Room.objects.get(id=room_id)
+            return HttpResponseBadRequest(
+            "Parameters missing or bad parameters. "
+            "Expected a GET request with 'room_id' and 'latest_message_id' "
+            "parameters")
+        room = get_object_or_404(Room, id=room_id)
         # wait for new messages
         self.new_message_events[room.id].wait(TIMEOUT)
-        messages = self.messages[room.id]
+
+        handler = MessageHandlerFactory()
+        messages = handler.retrieve_messages(self, room_id)
+
         to_jsonify = [
             {"message_id": msg_id,
              "username": message.user.username,
              "date": message.date.strftime(TIME_FORMAT),
-             "content": message.message}
+             "content": message.content}
             for msg_id, message in messages
-            if msg_id > latest_id
+            if msg_id > latest_msg_id
         ]
         return HttpResponse(json.dumps(to_jsonify),
                             mimetype="application/json")
@@ -87,19 +93,19 @@ def send_message(self, request):
             message = request.POST['message']
             date = datetime.now()
         except:
-            return HttpResponseBadRequest()
+            return HttpResponseBadRequest(
+            "Parameters missing or bad parameters"
+            "Expected a POST request with 'room_id' and 'message' parameters")
+        room = get_object_or_404(Room, id=room_id)
         user = request.user
-
         foo, response = chat_message_received.send(
                             sender=self,
-                            room_id=room_id,
+                            room_id=room.id,
                             user=user,
                             message=message,
                             date=date)[0]
-        msg_number = self.counters[room_id].next()
-        self.messages[room_id].append((msg_number, response))
-        return HttpResponse(json.dumps(
-                {'id': msg_number,
+
+        return HttpResponse(json.dumps({
                  'timestamp': date.strftime(TIME_FORMAT), }
         ))
 
@@ -109,14 +115,14 @@ def notify_users_list(self, request):
         """Updates user time into connected users dictionary
         """
         try:
-            room_id = request.POST['room_id']
-        except KeyError:
-            return HttpResponseNotFound('not found', mimetype="text/plain")
+            room_id = int(request.POST['room_id'])
+        except:
+            return HttpResponseBadRequest(
+            "Parameters missing or bad parameters"
+            "Expected a POST request with 'room_id'")
 
-        # if request.user.is_authenticated():
-        room_id = long(room_id)
         user = request.user
-        room = Room.objects.get(id=room_id)
+        room = get_object_or_404(Room, id=room_id)
         date = datetime.today()
         self.connected_users[room.id].update({user.username: date})
         self.new_connected_user_event[room_id].set()
@@ -130,12 +136,14 @@ def get_users_list(self, request):
         """
         REFRESH_TIME = 8
         try:
-            room_id = request.GET['room_id']
-        except KeyError:
-            return HttpResponseBadRequest()
-        room_id = int(room_id)
-        room = Room.objects.get(id=room_id)
-        user = User.objects.get(username=request.user.username)
+            room_id = int(request.GET['room_id'])
+        except:
+            return HttpResponseBadRequest(
+            "Parameters missing or bad parameters"
+            "Expected a POST request with 'room_id'")
+
+        room = get_object_or_404(Room, id=room_id)
+        user = request.user
         self.connected_users[room.id].update({
                                 user.username: datetime.today()
                             })
@@ -158,7 +166,7 @@ def get_users_list(self, request):
 
     @method_decorator(ajax_login_required)
     @method_decorator(ajax_user_passes_test_or_403(check_user_passes_test))
-    def get_last_message_id(self, request):
+    def get_latest_message_id(self, request):
         """
         Dumps the id of the latest message sent
         """
@@ -188,16 +196,7 @@ def _clean_connected_users(self, room_id, seconds=60):
 get_messages = chat.get_messages
 get_users_list = chat.get_users_list
 notify_users_list = chat.notify_users_list
-get_last_message_id = chat.get_last_message_id
-
-
-def get_date(request):
-    """dumps the current date """
-    response = {
-        "date": "%s" % datetime.today().strftime(TIME_FORMAT)
-    }
-    return HttpResponse(json.dumps(response),
-                        mimetype="application/json")
+get_latest_message_id = chat.get_latest_message_id
 
 
 @receiver(post_save, sender=Room)

chatrooms/models.py

@@ -7,19 +7,22 @@
 
 
 class Room(PolymorphicModel):
-    name = models.CharField(max_length=64)
+    name = models.CharField(max_length=64, unique=True)
     slug = models.SlugField()
-    subscribers = models.ManyToManyField(User)
-    private = models.BooleanField()
-    password = models.CharField(max_length=32)
+    subscribers = models.ManyToManyField(User, blank=True)
+    private = models.NullBooleanField()
+    password = models.CharField(max_length=32, blank=True)
+
+    def __unicode__(self):
+        return u"%s" % self.name
 
     @models.permalink
     def get_absolute_url(self):
-        return ('room_view', [str(self.id)])
+        return ('room_view', [self.slug])
 
 
 class Message(PolymorphicModel):
     user = models.ForeignKey(User)
     date = models.DateTimeField(['%Y-%m-%d %H:%M:%S:%f'])
     room = models.ForeignKey(Room)
-    message = models.CharField(max_length=5000)
+    content = models.CharField(max_length=5000)

chatrooms/signals.py

@@ -1,11 +1,6 @@
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
+from utils.handlers import MessageHandlerFactory  # get_message_received_handler
 from django.dispatch import Signal
 
-from django_load.core import load_object
-
-from .models import Room, Message
-
 
 chat_message_received = Signal(
     providing_args=[
@@ -15,53 +10,6 @@
         "date",
 ])
 
+handler = MessageHandlerFactory()
 
-def set_new_message_chatroom_event(chatobj, room_id):
-    """
-    Set event indexed by the given room_id on the ChatView object
-    """
-    event = chatobj.new_message_event[room_id]
-    event.set()
-    event.clear()
-
-
-def db_message_received_handler(signal, sender, room_id, user, message, date):
-    """
-    Default handler for the message_received signal.
-    1 - Saves an instance of message to db
-    2 - Returns the created message
-
-    A handler is a function accepting the following arguments:
-        signal, sender, room_id, user, message, date
-    It must return an object containing the following attributes:
-        user, room, date, message
-    Whatever the things you do with the message (store to db, queueing
-        it to RabbitMQ or anything you like), you have to return
-        an object with the former attributes.
-    """
-    room = Room.objects.get(id=room_id)
-    new_message = Message(user=user,
-                          room=room,
-                          date=date,
-                          message=message)
-    new_message.save()
-    return new_message
-
-
-def get_message_received_handler():
-    """
-    Returns the function defined as settings.CHATROOMS_MESSAGE_RECEIVED_HANDLER
-        if any, else returns the db_message_received_handler
-    """
-    if hasattr(settings, 'CHATROOMS_MESSAGE_RECEIVED_HANDLER'):
-        try:
-            return load_object(settings.CHATROOMS_MESSAGE_RECEIVED_HANDLER)
-        except (ImportError, TypeError):
-            raise ImproperlyConfigured(
-            "The variable set as settings.CHATROOMS_MESSAGE_RECEIVED_HANDLER "
-            "is not a module or the path is not correct"
-            )
-    return db_message_received_handler
-
-
-chat_message_received.connect(get_message_received_handler())
+chat_message_received.connect(handler.handle_received_message)