make user decorated name decoratable through OSQA modules, allow superusers to edit...

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

diff --git a/forum/models/user.py b/forum/models/user.py
index 8dd5ff9b829a954836aa69f4c2093c481ef0a081..cf47c6653e78b2eaae6f68b5e8ae5039b5c5b8a4 100644 (file)
--- a/forum/models/user.py
+++ b/forum/models/user.py
@@ -1,13 +1,14 @@
 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.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,13 +16,9 @@ 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):
 class AnonymousUser(DjangoAnonymousUser):

+    reputation = 0
+    

     def get_visible_answers(self, question):
         return question.answers.filter_state(deleted=False)
 
     def get_visible_answers(self, question):
         return question.answers.filter_state(deleted=False)
 


@@ -33,6 +30,9 @@ class AnonymousUser(DjangoAnonymousUser):
 
     def can_vote_down(self):
         return False
 
     def can_vote_down(self):
         return False

+    
+    def can_vote_count_today(self):
+        return 0

 
     def can_flag_offensive(self, post=None):
         return False
 
     def can_flag_offensive(self, post=None):
         return False


@@ -54,6 +54,12 @@ class AnonymousUser(DjangoAnonymousUser):
 
     def can_convert_to_comment(self, answer):
         return False
 
     def can_convert_to_comment(self, answer):
         return False

+    
+    def can_convert_to_question(self, answer):
+        return False
+    
+    def can_convert_comment_to_answer(self, comment):
+        return False

 
     def can_accept_answer(self, answer):
         return False
 
     def can_accept_answer(self, answer):
         return False


@@ -85,6 +91,9 @@ class AnonymousUser(DjangoAnonymousUser):
     def can_upload_files(self):
         return False
 
     def can_upload_files(self):
         return False
 

+    def is_a_super_user_or_staff(self):
+        return False
+

 def true_if_is_super_or_staff(fn):
     def decorated(self, *args, **kwargs):
         return self.is_superuser or self.is_staff or fn(self, *args, **kwargs)
 def true_if_is_super_or_staff(fn):
     def decorated(self, *args, **kwargs):
         return self.is_superuser or self.is_staff or fn(self, *args, **kwargs)


@@ -101,11 +110,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)


@@ -122,8 +145,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):


@@ -140,23 +165,40 @@ 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
 
     @property

-    def gravatar(self):
-        return md5(self.email).hexdigest()
+    def decorated_name(self):
+        return self._decorated_name()

 
 

+    @property
+    def last_activity(self):
+        try:
+            return self.actions.order_by('-action_date')[0].action_date
+        except:
+            return self.last_seen
+
+    @property
+    def gravatar(self):
+        return md5(self.email.lower()).hexdigest()
+    

     def save(self, *args, **kwargs):
     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)


@@ -167,9 +209,6 @@ 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():
     def get_messages(self):
         messages = []
         for m in self.message_set.all():


@@ -181,22 +220,46 @@ class User(BaseModel, DjangoUser):
 
     @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):
         return self.get_profile_url()
 
     @models.permalink
     def get_asked_url(self):
 
     def get_absolute_url(self):
         return self.get_profile_url()
 
     @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)


@@ -222,6 +285,22 @@ class User(BaseModel, DjangoUser):
         today = datetime.date.today()
         return self.actions.filter(canceled=False, action_type="flag",
                                    action_date__gte=(today - datetime.timedelta(days=1))).count()
         today = datetime.date.today()
         return self.actions.filter(canceled=False, action_type="flag",
                                    action_date__gte=(today - datetime.timedelta(days=1))).count()

+    
+    def can_vote_count_today(self):
+        votes_today = settings.MAX_VOTES_PER_DAY
+        
+        if settings.USER_REPUTATION_TO_MAX_VOTES:
+            votes_today = votes_today + int(self.reputation)
+        
+        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):
 
     @true_if_is_super_or_staff
     def can_view_deleted_post(self, post):


@@ -266,13 +345,28 @@ 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)
 

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

     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, 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
     def can_accept_answer(self, answer):
 
     @true_if_is_super_or_staff
     def can_accept_answer(self, answer):

-        return self == answer.question.author
+        return self == answer.question.author and (settings.USERS_CAN_ACCEPT_OWN or answer.author != answer.question.author)

 
     @true_if_is_super_or_staff
     def can_create_tags(self):
 
     @true_if_is_super_or_staff
     def can_create_tags(self):


@@ -303,7 +397,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 >= 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):


@@ -311,12 +415,16 @@ class User(BaseModel, DjangoUser):
             return self.can_delete_comment(post)
 
         return (self == post.author and (post.__class__.__name__ == "Answer" or
             return self.can_delete_comment(post)
 
         return (self == post.author and (post.__class__.__name__ == "Answer" or

-        not post.answers.exclude(author=self).count()))
+        not post.answers.exclude(author__id=self.id).count()))

 
     @true_if_is_super_or_staff
     def can_upload_files(self):
         return self.reputation >= int(settings.REP_TO_UPLOAD)
 
 
     @true_if_is_super_or_staff
     def can_upload_files(self):
         return self.reputation >= int(settings.REP_TO_UPLOAD)
 

+    @true_if_is_super_or_staff
+    def is_a_super_user_or_staff(self):
+        return False
+

     def email_valid_and_can_ask(self):
         return 'ask' not in settings.REQUIRE_EMAIL_VALIDATION_TO or self.email_isvalid
 
     def email_valid_and_can_ask(self):
         return 'ask' not in settings.REQUIRE_EMAIL_VALIDATION_TO or self.email_isvalid
 


@@ -331,13 +439,13 @@ class User(BaseModel, DjangoUser):
     def suspension(self):
         if self.__dict__.get('_suspension_dencache_', False) != None:
             try:
     def suspension(self):
         if self.__dict__.get('_suspension_dencache_', False) != None:
             try:

-                self.__dict__['_suspension_dencache_'] = self.actions.get(action_type="suspend", canceled=False)
+                self.__dict__['_suspension_dencache_'] = self.reputes.get(action__action_type="suspend", action__canceled=False).action

             except ObjectDoesNotExist:
                 self.__dict__['_suspension_dencache_'] = None
             except MultipleObjectsReturned:
                 logging.error("Multiple suspension actions found for user %s (%s)" % (self.username, self.id))
             except ObjectDoesNotExist:
                 self.__dict__['_suspension_dencache_'] = None
             except MultipleObjectsReturned:
                 logging.error("Multiple suspension actions found for user %s (%s)" % (self.username, self.id))

-                self.__dict__['_suspension_dencache_'] = self.actions.filter(action_type="suspend", canceled=False
-                                                                             ).order_by('-action_date')[0]
+                self.__dict__['_suspension_dencache_'] = self.reputes.filter(action__action_type="suspend", action__canceled=False
+                                                                             ).order_by('-action__action_date')[0].action

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


@@ -360,7 +468,7 @@ class User(BaseModel, DjangoUser):
     class Meta:
         app_label = 'forum'
 
     class Meta:
         app_label = 'forum'
 

-class UserProperty(models.Model):
+class UserProperty(BaseModel):

     user = models.ForeignKey(User, related_name='properties')
     key = models.CharField(max_length=16)
     value = PickledObjectField()
     user = models.ForeignKey(User, related_name='properties')
     key = models.CharField(max_length=16)
     value = PickledObjectField()


@@ -369,6 +477,19 @@ class UserProperty(models.Model):
         app_label = 'forum'
         unique_together = ('user', 'key')
 
         app_label = 'forum'
         unique_together = ('user', 'key')
 

+    def cache_key(self):
+        return self._generate_cache_key("%s:%s" % (self.user.id, self.key))
+
+    @classmethod
+    def infer_cache_key(cls, querydict):
+        if 'user' in querydict and 'key' in querydict:
+            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
+

 class UserPropertyDict(object):
     def __init__(self, user):
         self.__dict__['_user'] = user
 class UserPropertyDict(object):
     def __init__(self, user):
         self.__dict__['_user'] = user


@@ -404,7 +525,7 @@ class UserPropertyDict(object):
             if current:
                 current.value = value
                 self.__dict__[name] = value
             if current:
                 current.value = value
                 self.__dict__[name] = value

-                current.save()
+                current.save(full_save=True)

             else:
                 user = self.__dict__['_user']
                 prop = UserProperty(user=user, value=value, key=name)
             else:
                 user = self.__dict__['_user']
                 prop = UserProperty(user=user, value=value, key=name)


@@ -419,22 +540,19 @@ class UserPropertyDict(object):
 
 
 class SubscriptionSettings(models.Model):
 
 
 class SubscriptionSettings(models.Model):

-    user = models.OneToOneField(User, related_name='subscription_settings')
+    user = models.OneToOneField(User, related_name='subscription_settings', editable=False)

 
     enable_notifications = models.BooleanField(default=True)
 
     #notify if
     member_joins = models.CharField(max_length=1, default='n')
 
     enable_notifications = models.BooleanField(default=True)
 
     #notify if
     member_joins = models.CharField(max_length=1, default='n')

-    new_question = models.CharField(max_length=1, default='d')
+    new_question = models.CharField(max_length=1, default='n')

     new_question_watched_tags = models.CharField(max_length=1, default='i')
     subscribed_questions = models.CharField(max_length=1, default='i')
 
     #auto_subscribe_to
     all_questions = models.BooleanField(default=False)
     all_questions_watched_tags = models.BooleanField(default=False)
     new_question_watched_tags = models.CharField(max_length=1, default='i')
     subscribed_questions = models.CharField(max_length=1, default='i')
 
     #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