Merge pull request #5 from lra/french

[osqa.git] / forum / models / user.py

diff --git a/forum/models/user.py b/forum/models/user.py
index 9d6324875f9273c6d9ab5da77290f7bb5c4645e9..131ae5491d06c013f5b317c794ace47a611cb07e 100644 (file)
--- a/forum/models/user.py
+++ b/forum/models/user.py
@@ -1,13 +1,15 @@
 from base import *
 from utils import PickledObjectField
 from base import *
 from utils import PickledObjectField

+from django.conf import settings as django_settings

 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.auth.models import User as DjangoUser, AnonymousUser as DjangoAnonymousUser
 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.auth.models import User as DjangoUser, AnonymousUser as DjangoAnonymousUser

-from django.db.models import Q
-try:
-    from hashlib import md5
-except:
-    from md5 import new as md5
+from django.db.models import Q, Manager
+from django.core.urlresolvers import get_script_prefix
+
+from django.utils.encoding import smart_unicode
+
+from forum.settings import TRUNCATE_LONG_USERNAMES, TRUNCATE_USERNAMES_LONGER_THAN

 
 import string
 from random import Random
 
 import string
 from random import Random


@@ -15,12 +17,6 @@ from random import Random
 from django.utils.translation import ugettext as _
 import logging
 
 from django.utils.translation import ugettext as _
 import logging
 

-QUESTIONS_PER_PAGE_CHOICES = (
-(10, u'10'),
-(30, u'30'),
-(50, u'50'),
-)
-

 class AnonymousUser(DjangoAnonymousUser):
     reputation = 0
     
 class AnonymousUser(DjangoAnonymousUser):
     reputation = 0
     


@@ -115,11 +111,25 @@ def false_if_validation_required_to(item):
         return decorated
     return decorator
 
         return decorated
     return decorator
 

+class UserManager(CachedManager):
+    def get(self, *args, **kwargs):
+        if not len(args) and len(kwargs) == 1 and 'username' in kwargs:
+            matching_users = self.filter(username=kwargs['username'])
+            
+            if len(matching_users) == 1:
+                return matching_users[0]
+            elif len(matching_users) > 1:
+                for user in matching_users:
+                    if user.username == kwargs['username']:
+                        return user
+                return matching_users[0]
+        return super(UserManager, self).get(*args, **kwargs)
+

 class User(BaseModel, DjangoUser):
     is_approved = models.BooleanField(default=False)
     email_isvalid = models.BooleanField(default=False)
 
 class User(BaseModel, DjangoUser):
     is_approved = models.BooleanField(default=False)
     email_isvalid = models.BooleanField(default=False)
 

-    reputation = models.PositiveIntegerField(default=0)
+    reputation = models.IntegerField(default=0)

     gold = models.PositiveIntegerField(default=0)
     silver = models.PositiveIntegerField(default=0)
     bronze = models.PositiveIntegerField(default=0)
     gold = models.PositiveIntegerField(default=0)
     silver = models.PositiveIntegerField(default=0)
     bronze = models.PositiveIntegerField(default=0)


@@ -136,8 +146,10 @@ class User(BaseModel, DjangoUser):
     vote_up_count = DenormalizedField("actions", canceled=False, action_type="voteup")
     vote_down_count = DenormalizedField("actions", canceled=False, action_type="votedown")
 
     vote_up_count = DenormalizedField("actions", canceled=False, action_type="voteup")
     vote_down_count = DenormalizedField("actions", canceled=False, action_type="votedown")
 

+    objects = UserManager()
+

     def __unicode__(self):
     def __unicode__(self):

-        return self.username
+        return smart_unicode(self.username)

 
     @property
     def prop(self):
 
     @property
     def prop(self):


@@ -154,16 +166,25 @@ class User(BaseModel, DjangoUser):
         #todo: temporary thing, for now lets just assume that the site owner will always be the first user of the application
         return self.id == 1
 
         #todo: temporary thing, for now lets just assume that the site owner will always be the first user of the application
         return self.id == 1
 

-    @property
-    def decorated_name(self):
+
+    def _decorated_name(self):
+        username = smart_unicode(self.username)
+
+        if len(username) > TRUNCATE_USERNAMES_LONGER_THAN and TRUNCATE_LONG_USERNAMES:
+            username = '%s...' % username[:TRUNCATE_USERNAMES_LONGER_THAN-3]
+

         if settings.SHOW_STATUS_DIAMONDS:
             if self.is_superuser:
         if settings.SHOW_STATUS_DIAMONDS:
             if self.is_superuser:

-                return u"%s \u2666\u2666" % self.username
+                return u"%s \u2666\u2666" % username

 
             if self.is_staff:
 
             if self.is_staff:

-                return u"%s \u2666" % self.username
+                return u"%s \u2666" % username

 
 

-        return self.username
+        return username
+
+    @property
+    def decorated_name(self):
+        return self._decorated_name()

 
     @property
     def last_activity(self):
 
     @property
     def last_activity(self):


@@ -177,7 +198,8 @@ class User(BaseModel, DjangoUser):
         return md5(self.email.lower()).hexdigest()
     
     def save(self, *args, **kwargs):
         return md5(self.email.lower()).hexdigest()
     
     def save(self, *args, **kwargs):

-        if self.reputation < 0:
+        # If the community doesn't allow negative reputation, set it to 0
+        if not settings.ALLOW_NEGATIVE_REPUTATION and self.reputation < 0:

             self.reputation = 0
 
         new = not bool(self.id)
             self.reputation = 0
 
         new = not bool(self.id)


@@ -188,36 +210,50 @@ class User(BaseModel, DjangoUser):
             sub_settings = SubscriptionSettings(user=self)
             sub_settings.save()
 
             sub_settings = SubscriptionSettings(user=self)
             sub_settings.save()
 

-    def get_absolute_url(self):
-        return self.get_profile_url()
-
-    def get_messages(self):
-        messages = []
-        for m in self.message_set.all():
-            messages.append(m.message)
-        return messages
-
-    def delete_messages(self):
-        self.message_set.all().delete()
-

     @models.permalink
     def get_profile_url(self):
     @models.permalink
     def get_profile_url(self):

-        return ('user_profile', (), {'id': self.id, 'slug': slugify(self.username)})
+        keyword_arguments = {
+            'slug': slugify(smart_unicode(self.username))
+        }
+        if settings.INCLUDE_ID_IN_USER_URLS:
+            keyword_arguments.update({
+                'id': self.id,
+            })
+        return ('user_profile', (), keyword_arguments)

 
     def get_absolute_url(self):
 
     def get_absolute_url(self):

-        return self.get_profile_url()
+        root_relative_url = self.get_profile_url()
+        relative_url = root_relative_url[len(get_script_prefix()):]
+        return '%s/%s' % (django_settings.APP_URL, relative_url)

 
     @models.permalink
     def get_asked_url(self):
 
     @models.permalink
     def get_asked_url(self):

-        return ('user_questions', (), {'mode': _('asked-by'), 'user': self.id, 'slug': slugify(self.username)})
+        return ('user_questions', (), {'mode': _('asked-by'), 'user': self.id, 'slug': slugify(smart_unicode(self.username))})
+
+    @models.permalink
+    def get_user_subscriptions_url(self):
+        keyword_arguments = {
+            'slug': slugify(smart_unicode(self.username))
+        }
+        if settings.INCLUDE_ID_IN_USER_URLS:
+            keyword_arguments.update({
+                'id': self.id,
+            })
+        return ('user_subscriptions', (), keyword_arguments)

 
     @models.permalink
     def get_answered_url(self):
         return ('user_questions', (), {'mode': _('answered-by'), 'user': self.id, 'slug': slugify(self.username)})
 
 
     @models.permalink
     def get_answered_url(self):
         return ('user_questions', (), {'mode': _('answered-by'), 'user': self.id, 'slug': slugify(self.username)})
 

-    @models.permalink

     def get_subscribed_url(self):
     def get_subscribed_url(self):

-        return ('user_questions', (), {'mode': _('subscribed-by'), 'user': self.id, 'slug': slugify(self.username)})
+        try:
+            # Try to retrieve the Subscribed User URL.
+            url = reverse('user_questions',
+                           kwargs={'mode': _('subscribed-by'), 'user': self.id, 'slug': slugify(smart_unicode(self.username))})
+            return url
+        except Exception, e:
+            # If some Exception has been raised, don't forget to log it.
+            logging.error("Error retrieving a subscribed user URL: %s" % e)

 
     def get_profile_link(self):
         profile_link = u'<a href="%s">%s</a>' % (self.get_profile_url(), self.username)
 
     def get_profile_link(self):
         profile_link = u'<a href="%s">%s</a>' % (self.get_profile_url(), self.username)


@@ -252,6 +288,14 @@ class User(BaseModel, DjangoUser):
         
         return votes_today
     
         
         return votes_today
     

+    def can_use_canned_comments(self):
+        # The canned comments feature is available only for admins and moderators,
+        # and only if the "Use canned comments" setting is activated in the administration.
+        if (self.is_superuser or self.is_staff) and settings.USE_CANNED_COMMENTS:
+            return True
+        else:
+            return False
+

     @true_if_is_super_or_staff
     def can_view_deleted_post(self, post):
         return post.author == self
     @true_if_is_super_or_staff
     def can_view_deleted_post(self, post):
         return post.author == self


@@ -295,16 +339,23 @@ class User(BaseModel, DjangoUser):
     def can_delete_comment(self, comment):
         return self == comment.author or self.reputation >= int(settings.REP_TO_DELETE_COMMENTS)
 
     def can_delete_comment(self, comment):
         return self == comment.author or self.reputation >= int(settings.REP_TO_DELETE_COMMENTS)
 

-    @true_if_is_super_or_staff

     def can_convert_comment_to_answer(self, comment):
     def can_convert_comment_to_answer(self, comment):

-        return self == comment.author or self.reputation >= int(settings.REP_TO_CONVERT_COMMENTS_TO_ANSWERS)
+        # We need to know what is the comment parent node type.
+        comment_parent_type = comment.parent.node_type
+
+        # If the parent is not a question or an answer this comment cannot be converted to an answer.
+        if comment_parent_type != "question" and comment_parent_type != "answer":
+            return False
+
+        return (comment.parent.node_type in ('question', 'answer')) and (self.is_superuser or self.is_staff or (
+            self == comment.author) or (self.reputation >= int(settings.REP_TO_CONVERT_COMMENTS_TO_ANSWERS)))

 
     def can_convert_to_comment(self, answer):
         return (not answer.marked) and (self.is_superuser or self.is_staff or answer.author == self or self.reputation >= int
                 (settings.REP_TO_CONVERT_TO_COMMENT))
     
 
     def can_convert_to_comment(self, answer):
         return (not answer.marked) and (self.is_superuser or self.is_staff or answer.author == self or self.reputation >= int
                 (settings.REP_TO_CONVERT_TO_COMMENT))
     

-    def can_convert_to_question(self, answer):
-        return (not answer.marked) and (self.is_superuser or self.is_staff or answer.author == self or self.reputation >= int
+    def can_convert_to_question(self, node):
+        return (not node.marked) and (self.is_superuser or self.is_staff or node.author == self or self.reputation >= int

                 (settings.REP_TO_CONVERT_TO_QUESTION))
 
     @true_if_is_super_or_staff
                 (settings.REP_TO_CONVERT_TO_QUESTION))
 
     @true_if_is_super_or_staff


@@ -340,7 +391,17 @@ class User(BaseModel, DjangoUser):
 
     @true_if_is_super_or_staff
     def can_reopen_question(self, question):
 
     @true_if_is_super_or_staff
     def can_reopen_question(self, question):

-        return self == question.author and self.reputation >= int(settings.REP_TO_REOPEN_OWN)
+        # Check whether the setting to Unify close and reopen permissions has been activated
+        if bool(settings.UNIFY_PERMISSIONS_TO_CLOSE_AND_REOPEN):
+            # If we unify close to reopen check whether the user has permissions to close.
+            # If he has -- he can reopen his question too.
+            can_reopen = (
+                self == question.author and self.reputation >= int(settings.REP_TO_CLOSE_OWN)
+            ) or self.reputation >= int(settings.REP_TO_CLOSE_OTHERS)
+        else:
+            # Check whether the user is the author and has the required permissions to reopen
+            can_reopen = self == question.author and self.reputation >= int(settings.REP_TO_REOPEN_OWN)
+        return can_reopen

 
     @true_if_is_super_or_staff
     def can_delete_post(self, post):
 
     @true_if_is_super_or_staff
     def can_delete_post(self, post):


@@ -378,7 +439,7 @@ class User(BaseModel, DjangoUser):
             except MultipleObjectsReturned:
                 logging.error("Multiple suspension actions found for user %s (%s)" % (self.username, self.id))
                 self.__dict__['_suspension_dencache_'] = self.reputes.filter(action__action_type="suspend", action__canceled=False
             except MultipleObjectsReturned:
                 logging.error("Multiple suspension actions found for user %s (%s)" % (self.username, self.id))
                 self.__dict__['_suspension_dencache_'] = self.reputes.filter(action__action_type="suspend", action__canceled=False

-                                                                             ).order_by('-action__action_date')[0]
+                                                                             ).order_by('-action__action_date')[0].action

 
         return self.__dict__['_suspension_dencache_']
 
 
         return self.__dict__['_suspension_dencache_']
 


@@ -416,7 +477,10 @@ class UserProperty(BaseModel):
     @classmethod
     def infer_cache_key(cls, querydict):
         if 'user' in querydict and 'key' in querydict:
     @classmethod
     def infer_cache_key(cls, querydict):
         if 'user' in querydict and 'key' in querydict:

-            return cls._generate_cache_key("%s:%s" % (querydict['user'].id, querydict['key']))
+            cache_key = cls._generate_cache_key("%s:%s" % (querydict['user'].id, querydict['key']))
+            if len(cache_key) > django_settings.CACHE_MAX_KEY_LENGTH:
+                cache_key = cache_key[:django_settings.CACHE_MAX_KEY_LENGTH]
+            return cache_key

 
         return None
 
 
         return None
 


@@ -483,9 +547,6 @@ class SubscriptionSettings(models.Model):
     #auto_subscribe_to
     all_questions = models.BooleanField(default=False)
     all_questions_watched_tags = models.BooleanField(default=False)
     #auto_subscribe_to
     all_questions = models.BooleanField(default=False)
     all_questions_watched_tags = models.BooleanField(default=False)

-    questions_asked = models.BooleanField(default=True)
-    questions_answered = models.BooleanField(default=True)
-    questions_commented = models.BooleanField(default=False)

     questions_viewed = models.BooleanField(default=False)
 
     #notify activity on subscribed
     questions_viewed = models.BooleanField(default=False)
 
     #notify activity on subscribed