Merge pull request #46 from udacity/subfolder_fixes

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

diff --git a/forum/models/user.py b/forum/models/user.py
index 523397ef3cd264d2bdf30a49c743bf960b3ab501..131ae5491d06c013f5b317c794ace47a611cb07e 100644 (file)
--- a/forum/models/user.py
+++ b/forum/models/user.py
@@ -1,9 +1,11 @@
 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
+from django.db.models import Q, Manager
+from django.core.urlresolvers import get_script_prefix

 
 from django.utils.encoding import smart_unicode
 
 
 from django.utils.encoding import smart_unicode
 


@@ -109,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)


@@ -130,6 +146,8 @@ 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):
         return smart_unicode(self.username)
 
     def __unicode__(self):
         return smart_unicode(self.username)
 


@@ -148,8 +166,8 @@ 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 = smart_unicode(self.username)
 
         if len(username) > TRUNCATE_USERNAMES_LONGER_THAN and TRUNCATE_LONG_USERNAMES:


@@ -164,6 +182,10 @@ class User(BaseModel, DjangoUser):
 
         return username
 
 
         return username
 

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

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


@@ -176,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)


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

-    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(smart_unicode(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)


@@ -248,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


@@ -292,6 +340,13 @@ class User(BaseModel, DjangoUser):
         return self == comment.author or self.reputation >= int(settings.REP_TO_DELETE_COMMENTS)
 
     def can_convert_comment_to_answer(self, comment):
         return self == comment.author or self.reputation >= int(settings.REP_TO_DELETE_COMMENTS)
 
     def can_convert_comment_to_answer(self, comment):

+        # 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)))
 
         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)))
 


@@ -299,8 +354,8 @@ class User(BaseModel, DjangoUser):
         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))
     
         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


@@ -336,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):


@@ -374,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_']
 


@@ -412,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