Merge branch 'refs/heads/umessage_namespacing'

userena/contrib/umessages/fixtures/messages.json

@@ -1,50 +1,50 @@
 [
   {
-    "pk": 1, 
-    "model": "umessages.message", 
+    "pk": 1,
+    "model": "umessages.message",
     "fields": {
-      "body": "Hello from your friend", 
-      "sender_deleted_at": null, 
-      "sent_at": "2010-01-01T12:00:00.019Z", 
+      "body": "Hello from your friend",
+      "sender_deleted_at": null,
+      "sent_at": "2010-01-01T12:00:00.019Z",
       "sender": 1
     }
-  }, 
+  },
   {
-    "pk": 2, 
-    "model": "umessages.message", 
+    "pk": 2,
+    "model": "umessages.message",
     "fields": {
-      "body": "Hello from your mother", 
-      "sender_deleted_at": "2010-01-01T12:00:00.019Z", 
-      "sent_at": "2010-01-01T12:00:00.019Z", 
+      "body": "Hello from your mother",
+      "sender_deleted_at": "2010-01-01T12:00:00.019Z",
+      "sent_at": "2010-01-01T12:00:00.019Z",
       "sender": 2
     }
-  }, 
+  },
   {
-    "pk": 1, 
-    "model": "umessages.messagerecipient", 
+    "pk": 1,
+    "model": "umessages.messagerecipient",
     "fields": {
-      "message": 1, 
-      "read_at": null, 
-      "deleted_at": null, 
+      "message": 1,
+      "read_at": null,
+      "deleted_at": null,
       "user": 2
     }
   },
   {
-    "pk": 2, 
-    "model": "umessages.messagerecipient", 
+    "pk": 2,
+    "model": "umessages.messagerecipient",
     "fields": {
-      "message": 2, 
-      "read_at": "2010-01-01T12:00:00.019Z", 
-      "deleted_at": null, 
+      "message": 2,
+      "read_at": "2010-01-01T12:00:00.019Z",
+      "deleted_at": null,
       "user": 1
     }
   },
   {
     "pk": 1,
     "model": "umessages.messagecontact",
     "fields": {
-      "from_user": 1,
-      "to_user": 2,
+      "um_from_user": 1,
+      "um_to_user": 2,
       "latest_message": 2
     }
   }

userena/contrib/umessages/forms.py

@@ -25,11 +25,11 @@ def save(self, sender):
         :return: The saved :class:`Message`.
 
         """
-        to_user_list = self.cleaned_data['to']
+        um_to_user_list = self.cleaned_data['to']
         body = self.cleaned_data['body']
 
         msg = Message.objects.send_message(sender,
-                                           to_user_list,
+                                           um_to_user_list,
                                            body)
 
         return msg

userena/contrib/umessages/managers.py

@@ -8,7 +8,7 @@
 class MessageContactManager(models.Manager):
     """ Manager for the :class:`MessageContact` model """
 
-    def get_or_create(self, from_user, to_user, message):
+    def get_or_create(self, um_from_user, um_to_user, message):
         """
         Get or create a Contact
 
@@ -18,21 +18,21 @@ def get_or_create(self, from_user, to_user, message):
         """
         created = False
         try:
-            contact = self.get(Q(from_user=from_user, to_user=to_user) |
-                               Q(from_user=to_user, to_user=from_user))
+            contact = self.get(Q(um_from_user=um_from_user, um_to_user=um_to_user) |
+                               Q(um_from_user=um_to_user, um_to_user=um_from_user))
 
         except self.model.DoesNotExist:
             created = True
-            contact = self.create(from_user=from_user,
-                                  to_user=to_user,
+            contact = self.create(um_from_user=um_from_user,
+                                  um_to_user=um_to_user,
                                   latest_message=message)
 
         return (contact, created)
 
-    def update_contact(self, from_user, to_user, message):
+    def update_contact(self, um_from_user, um_to_user, message):
         """ Get or update a contacts information """
-        contact, created = self.get_or_create(from_user,
-                                              to_user,
+        contact, created = self.get_or_create(um_from_user,
+                                              um_to_user,
                                               message)
 
         # If the contact already existed, update the message
@@ -52,20 +52,20 @@ def get_contacts_for(self, user):
             The :class:`User` which to get the contacts for.
 
         """
-        contacts = self.filter(Q(from_user=user) | Q(to_user=user))
+        contacts = self.filter(Q(um_from_user=user) | Q(um_to_user=user))
         return contacts
 
 class MessageManager(models.Manager):
     """ Manager for the :class:`Message` model. """
 
-    def send_message(self, sender, to_user_list, body):
+    def send_message(self, sender, um_to_user_list, body):
         """
         Send a message from a user, to a user.
 
         :param sender:
             The :class:`User` which sends the message.
 
-        :param to_user_list:
+        :param um_to_user_list:
             A list which elements are :class:`User` to whom the message is for.
 
         :param message:
@@ -77,17 +77,17 @@ def send_message(self, sender, to_user_list, body):
         msg.save()
 
         # Save the recipients
-        msg.save_recipients(to_user_list)
-        msg.update_contacts(to_user_list)
+        msg.save_recipients(um_to_user_list)
+        msg.update_contacts(um_to_user_list)
         signals.email_sent.send(sender=None,msg=msg)
 
         return msg
 
-    def get_conversation_between(self, from_user, to_user):
+    def get_conversation_between(self, um_from_user, um_to_user):
         """ Returns a conversation between two users """
-        messages = self.filter(Q(sender=from_user, recipients=to_user,
+        messages = self.filter(Q(sender=um_from_user, recipients=um_to_user,
                                  sender_deleted_at__isnull=True) |
-                               Q(sender=to_user, recipients=from_user,
+                               Q(sender=um_to_user, recipients=um_from_user,
                                  messagerecipient__deleted_at__isnull=True))
         return messages
 
@@ -111,22 +111,22 @@ def count_unread_messages_for(self, user):
 
         return unread_total
 
-    def count_unread_messages_between(self, to_user, from_user):
+    def count_unread_messages_between(self, um_to_user, um_from_user):
         """
         Returns the amount of unread messages between two users
 
-        :param to_user:
+        :param um_to_user:
             A Django :class:`User` for who the messages are for.
 
-        :param from_user:
+        :param um_from_user:
             A Django :class:`User` from whom the messages originate from.
 
         :return:
             An integer with the amount of unread messages.
 
         """
-        unread_total = self.filter(message__sender=from_user,
-                                   user=to_user,
+        unread_total = self.filter(message__sender=um_from_user,
+                                   user=um_to_user,
                                    read_at__isnull=True,
                                    deleted_at__isnull=True).count()
 

userena/contrib/umessages/migrations/0001_initial.py

@@ -7,18 +7,18 @@
 class Migration(SchemaMigration):
 
     def forwards(self, orm):
-        
+
         # Adding model 'MessageContact'
         db.create_table('umessages_messagecontact', (
             ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
-            ('from_user', self.gf('django.db.models.fields.related.ForeignKey')(related_name='from_users', to=orm['auth.User'])),
-            ('to_user', self.gf('django.db.models.fields.related.ForeignKey')(related_name='to_users', to=orm['auth.User'])),
+            ('um_from_user', self.gf('django.db.models.fields.related.ForeignKey')(related_name='um_from_users', to=orm['auth.User'])),
+            ('um_to_user', self.gf('django.db.models.fields.related.ForeignKey')(related_name='um_to_users', to=orm['auth.User'])),
             ('latest_message', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['umessages.Message'])),
         ))
         db.send_create_signal('umessages', ['MessageContact'])
 
-        # Adding unique constraint on 'MessageContact', fields ['from_user', 'to_user']
-        db.create_unique('umessages_messagecontact', ['from_user_id', 'to_user_id'])
+        # Adding unique constraint on 'MessageContact', fields ['um_from_user', 'um_to_user']
+        db.create_unique('umessages_messagecontact', ['um_from_user_id', 'um_to_user_id'])
 
         # Adding model 'MessageRecipient'
         db.create_table('umessages_messagerecipient', (
@@ -42,9 +42,9 @@ def forwards(self, orm):
 
 
     def backwards(self, orm):
-        
-        # Removing unique constraint on 'MessageContact', fields ['from_user', 'to_user']
-        db.delete_unique('umessages_messagecontact', ['from_user_id', 'to_user_id'])
+
+        # Removing unique constraint on 'MessageContact', fields ['um_from_user', 'um_to_user']
+        db.delete_unique('umessages_messagecontact', ['um_from_user_id', 'um_to_user_id'])
 
         # Deleting model 'MessageContact'
         db.delete_table('umessages_messagecontact')
@@ -103,11 +103,11 @@ def backwards(self, orm):
             'sent_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'})
         },
         'umessages.messagecontact': {
-            'Meta': {'ordering': "['latest_message']", 'unique_together': "(('from_user', 'to_user'),)", 'object_name': 'MessageContact'},
-            'from_user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'from_users'", 'to': "orm['auth.User']"}),
+            'Meta': {'ordering': "['latest_message']", 'unique_together': "(('um_from_user', 'um_to_user'),)", 'object_name': 'MessageContact'},
+            'um_from_user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'um_from_users'", 'to': "orm['auth.User']"}),
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'latest_message': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['umessages.Message']"}),
-            'to_user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'to_users'", 'to': "orm['auth.User']"})
+            'um_to_user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'um_to_users'", 'to': "orm['auth.User']"})
         },
         'umessages.messagerecipient': {
             'Meta': {'object_name': 'MessageRecipient'},

userena/contrib/umessages/models.py

@@ -14,27 +14,27 @@ class MessageContact(models.Model):
     received a message from.
 
     """
-    from_user = models.ForeignKey(user_model_label, verbose_name=_("from user"),
-                                  related_name=('from_users'))
+    um_from_user = models.ForeignKey(user_model_label, verbose_name=_("from user"),
+                                  related_name=('um_from_users'))
 
-    to_user = models.ForeignKey(user_model_label, verbose_name=_("to user"),
-                                related_name=('to_users'))
+    um_to_user = models.ForeignKey(user_model_label, verbose_name=_("to user"),
+                                related_name=('um_to_users'))
 
     latest_message = models.ForeignKey('Message',
                                        verbose_name=_("latest message"))
 
     objects = MessageContactManager()
 
     class Meta:
-        unique_together = ('from_user', 'to_user')
+        unique_together = ('um_from_user', 'um_to_user')
         ordering = ['latest_message']
         verbose_name = _("contact")
         verbose_name_plural = _("contacts")
 
     def __unicode__(self):
-        return (_("%(from_user)s and %(to_user)s")
-                % {'from_user': self.from_user.username,
-                   'to_user': self.to_user.username})
+        return (_("%(um_from_user)s and %(um_to_user)s")
+                % {'um_from_user': self.um_from_user.username,
+                   'um_to_user': self.um_to_user.username})
 
     def opposite_user(self, user):
         """
@@ -47,9 +47,9 @@ def opposite_user(self, user):
             A Django :class:`User`.
 
         """
-        if self.from_user == user:
-            return self.to_user
-        else: return self.from_user
+        if self.um_from_user == user:
+            return self.um_to_user
+        else: return self.um_from_user
 
 class MessageRecipient(models.Model):
     """
@@ -117,37 +117,37 @@ def __unicode__(self):
         truncated_body = truncate_words(self.body, 10)
         return "%(truncated_body)s" % {'truncated_body': truncated_body}
 
-    def save_recipients(self, to_user_list):
+    def save_recipients(self, um_to_user_list):
         """
         Save the recipients for this message
 
-        :param to_user_list:
+        :param um_to_user_list:
             A list which elements are :class:`User` to whom the message is for.
 
         :return:
             Boolean indicating if any users are saved.
 
         """
         created = False
-        for user in to_user_list:
+        for user in um_to_user_list:
             MessageRecipient.objects.create(user=user,
                                             message=self)
             created = True
         return created
 
-    def update_contacts(self, to_user_list):
+    def update_contacts(self, um_to_user_list):
         """
         Updates the contacts that are used for this message.
 
-        :param to_user_list:
+        :param um_to_user_list:
             List of Django :class:`User`.
 
         :return:
             A boolean if a user is contact is updated.
 
         """
         updated = False
-        for user in to_user_list:
+        for user in um_to_user_list:
             MessageContact.objects.update_contact(self.sender,
                                                   user,
                                                   self)

userena/contrib/umessages/templates/umessages/message_list.html

@@ -11,12 +11,12 @@
 <ul>
   {% for message in message_list %}
   <li>
-  {% if message.from_user == user %}
-  <a href="{% url 'userena_umessages_detail' message.to_user.username %}">{{ message.to_user }}</a>
-  {% get_unread_message_count_between user and message.to_user as unread_between_count %}
+  {% if message.um_from_user == user %}
+  <a href="{% url 'userena_umessages_detail' message.um_to_user.username %}">{{ message.um_to_user }}</a>
+  {% get_unread_message_count_between user and message.um_to_user as unread_between_count %}
   {% else %}
-  <a href="{% url 'userena_umessages_detail' message.from_user.username %}">{{ message.from_user }}</a>
-  {% get_unread_message_count_between user and message.from_user as unread_between_count %}
+  <a href="{% url 'userena_umessages_detail' message.um_from_user.username %}">{{ message.um_from_user }}</a>
+  {% get_unread_message_count_between user and message.um_from_user as unread_between_count %}
   {% endif %}
   {% blocktrans with message.latest_message as latest_message %}{{ latest_message }} ({{ unread_between_count }} new){% endblocktrans %}
   </li>