Implemented bumplimit.

boards/models.py

@@ -1,208 +1,214 b''
 import os
 import re
 from django.db import models
 from django.utils import timezone
 import time
 
 from neboard import settings
 
 import thumbs
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 
 
 def update_image_filename(instance, filename):
     """Get unique image filename"""
 
     path = 'images/'
     new_name = str(int(time.mktime(time.gmtime()))) + '_' + filename
     return os.path.join(path, new_name)
 
 
 class PostManager(models.Manager):
     def create_post(self, title, text, image=None, parent_id=NO_PARENT,
                     ip=NO_IP, tags=None):
         post = self.create(title=title,
                            text=text,
                            pub_time=timezone.now(),
                            parent=parent_id,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,
                            last_edit_time=timezone.now())
 
         if tags:
             for tag in tags:
                 post.tags.add(tag)
 
         if parent_id != NO_PARENT:
-            parent = self.get(id=parent_id)
-            parent.last_edit_time=timezone.now()
-            parent.save()
+            self._bump_thread(parent_id)
         else:
             self._delete_old_threads()
 
         return post
 
     def delete_post(self, post):
         children = self.filter(parent=post.id)
         for child in children:
             self.delete_post(child)
         post.delete()
 
     def delete_posts_by_ip(self, ip):
         posts = self.filter(poster_ip=ip)
         for post in posts:
             self.delete_post(post)
 
     def get_threads(self, tag=None):
         if tag:
             threads = self.filter(parent=NO_PARENT, tags=tag)
         else:
             threads = self.filter(parent=NO_PARENT)
         threads = list(threads.order_by('-last_edit_time'))
 
         return threads
 
     def get_thread(self, opening_post_id):
         opening_post = self.get(id=opening_post_id)
 
         if opening_post.parent == NO_PARENT:
             replies = self.filter(parent=opening_post_id)
 
             thread = [opening_post]
             thread.extend(replies)
 
             return thread
 
     def exists(self, post_id):
         posts = self.filter(id=post_id)
 
         return len(posts) > 0
 
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         delete the old ones.
         """
 
         # TODO Try to find a better way to get the active thread count.
 
         # TODO Move old threads to the archive instead of deleting them.
         # Maybe make some 'old' field in the model to indicate the thread
         # must not be shown and be able for replying.
 
         threads = self.get_threads()
         thread_count = len(threads)
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[-num_threads_to_delete:]
 
             for thread in old_threads:
                 self.delete_post(thread)
 
+    def _bump_thread(self, thread_id):
+        thread = self.get(id=thread_id)
+
+        replies_count = len(self.get_thread(thread_id))
+        if replies_count <= settings.MAX_POSTS_PER_THREAD:
+            thread.last_edit_time = timezone.now()
+            thread.save()
+
 
 class TagManager(models.Manager):
     def get_not_empty_tags(self):
         all_tags = self.all().order_by('name')
         tags = []
         for tag in all_tags:
             if not tag.is_empty():
                 tags.append(tag)
 
         return tags
 
 
 class Tag(models.Model):
     """
     A tag is a text node assigned to the post. The tag serves as a board
     section. There can be multiple tags for each message
     """
 
     objects = TagManager()
 
     name = models.CharField(max_length=100)
     # TODO Connect the tag to its posts to check the number of threads for
     # the tag.
 
     def __unicode__(self):
         return self.name
 
     def is_empty(self):
         return self.get_post_count() == 0
 
     def get_post_count(self):
         posts_with_tag = Post.objects.get_threads(tag=self)
         return len(posts_with_tag)
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     title = models.CharField(max_length=50)
     pub_time = models.DateTimeField()
     text = models.TextField()
     image = thumbs.ImageWithThumbsField(upload_to=update_image_filename,
                                         blank=True, sizes=((200, 150),))
     poster_ip = models.IPAddressField()
     poster_user_agent = models.TextField()
     parent = models.BigIntegerField()
     tags = models.ManyToManyField(Tag)
     last_edit_time = models.DateTimeField()
 
     def __unicode__(self):
         return self.title + ' (' + self.text + ')'
 
     def _get_replies(self):
         return Post.objects.filter(parent=self.id)
 
     def get_reply_count(self):
         return len(self._get_replies())
 
     def get_images_count(self):
         images_count = 1 if self.image else 0
         for reply in self._get_replies():
             if reply.image:
                 images_count += 1
 
         return images_count
 
     def get_gets_count(self):
         gets_count = 1 if self.is_get() else 0
         for reply in self._get_replies():
             if reply.is_get():
                 gets_count += 1
 
         return gets_count
 
     def is_get(self):
         """If the post has pretty id (1, 1000, 77777), than it is called GET"""
 
         # TODO Make a better algorithm for describing gets
         return self.id == 1 or self.id % 10 == 0
 
     def get_parsed_text(self):
         text = self.text
 
         # TODO Implement parsing
         # Make //text colored
         # Make >>12 links to posts
 
         return text
 
 
 class Admin(models.Model):
     """
     Model for admin users
     """
     name = models.CharField(max_length=100)
     password = models.CharField(max_length=100)
 
     def __unicode__(self):
         return self.name + '/' + '*' * len(self.password)
 

neboard/settings.py

@@ -1,177 +1,177 b''
 # Django settings for neboard project.
 import os
 
 DEBUG = True
 TEMPLATE_DEBUG = DEBUG
 
 ADMINS = (
     # ('Your Name', '[e-mail]'),
     ('admin', '[e-mail]')
 )
 
 MANAGERS = ADMINS
 
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
         'NAME': 'database.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
         'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
     }
 }
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 # although not all choices may be available on all operating systems.
 # In a Windows environment this must be set to your system time zone.
 TIME_ZONE = 'Europe/Kiev'
 
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'ru'
 
 SITE_ID = 1
 
 # If you set this to False, Django will make some optimizations so as not
 # to load the internationalization machinery.
 USE_I18N = True
 
 # If you set this to False, Django will not format dates, numbers and
 # calendars according to the current locale.
 USE_L10N = True
 
 # If you set this to False, Django will not use timezone-aware datetimes.
 USE_TZ = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = ''
 
 # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 # trailing slash.
 # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 MEDIA_URL = ''
 
 # Absolute path to the directory static files should be collected to.
 # Don't put anything in this directory yourself; store your static files
 # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 # Example: "/home/media/media.lawrence.com/static/"
 STATIC_ROOT = ''
 
 # URL prefix for static files.
 # Example: "http://media.lawrence.com/static/"
 STATIC_URL = '/static/'
 
 # Additional locations of static files
 # It is really a hack, put real paths, not related
 STATICFILES_DIRS = (
     os.path.dirname(__file__) + '/boards/static',
 
 #    '/d/work/python/django/neboard/neboard/boards/static',
     # Put strings here, like "/home/html/static" or "C:/www/django/static".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
 )
 
 # List of finder classes that know how to find static files in
 # various locations.
 STATICFILES_FINDERS = (
     'django.contrib.staticfiles.finders.FileSystemFinder',
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
 #    'django.contrib.staticfiles.finders.DefaultStorageFinder',
 )
 
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&55@o11*8o'
 
 # List of callables that know how to import templates from various sources.
 TEMPLATE_LOADERS = (
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
 #     'django.template.loaders.eggs.Loader',
 )
 
 TEMPLATE_CONTEXT_PROCESSORS = (
     'django.core.context_processors.media',
     'django.core.context_processors.static',
     'django.core.context_processors.request',
     'django.contrib.auth.context_processors.auth',
 )
 
 MIDDLEWARE_CLASSES = (
     'django.middleware.common.CommonMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
 #    'django.middleware.csrf.CsrfViewMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     # Uncomment the next line for simple clickjacking protection:
     # 'django.middleware.clickjacking.XFrameOptionsMiddleware',
 )
 
 ROOT_URLCONF = 'neboard.urls'
 
 # Python dotted path to the WSGI application used by Django's runserver.
 WSGI_APPLICATION = 'neboard.wsgi.application'
 
 TEMPLATE_DIRS = (
     # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
     'templates',
 )
 
 INSTALLED_APPS = (
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     'django.contrib.sites',
     'django.contrib.messages',
     'django.contrib.staticfiles',
     # Uncomment the next line to enable the admin:
      'django.contrib.admin',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
     'django.contrib.markup',
     'boards',
 )
 
 # A sample logging configuration. The only tangible logging
 # performed by this configuration is to send an email to
 # the site admins on every HTTP 500 error when DEBUG=False.
 # See http://docs.djangoproject.com/en/dev/topics/logging for
 # more details on how to customize your logging configuration.
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'mail_admins': {
             'level': 'ERROR',
             'filters': ['require_debug_false'],
             'class': 'django.utils.log.AdminEmailHandler'
         }
     },
     'loggers': {
         'django.request': {
             'handlers': ['mail_admins'],
             'level': 'ERROR',
             'propagate': True,
         },
     }
 }
 
 # Custom imageboard settings
-MAX_POSTS_PER_THREAD = 100
-MAX_THREAD_COUNT = 20
+MAX_POSTS_PER_THREAD = 500 # Thread bumplimit
+MAX_THREAD_COUNT = 20 # Old threads will be deleted to preserve this count
 SITE_NAME = 'Neboard'
 
 THEMES = [
     ('md', 'Mystic Dark'),
     ('sw', 'Snow White') ]
 DEFAULT_THEME = 'md'
  No newline at end of file

templates/thread.html

@@ -1,74 +1,74 b''
 {% extends "base.html" %}
 
 {% load i18n %}
 {% load markup %}
 
 {% block head %}
     <title>Neboard</title>
 {% endblock %}
 
 {% block content %}
 
 	{% if posts %}
 		{% for post in posts %}
             <a name="{{ post.id }}"></a>
             <div class="post">
             {% if post.image %}
                 <div class="block">
                     <a href="{{ post.image.url }}"><img
                         src="{{ post.image.url_200x150 }}" />
                     </a>
                 </div>
             {% endif %}
             <div class="block">
                 <span class="title">{{ post.title }}</span>
                 <a class="post_id" href="#{{ post.id }}">
                     (#{{ post.id }})</a>
                 [{{ post.pub_time }}]
                 {{ post.get_parsed_text|markdown:"safe" }}
             </div>
             {% if post.tags.all %}
                 <div class="metadata">
                     <span class="tags">{% trans 'Tags' %}:
                         {% for tag in post.tags.all %}
                             <a class="tag" href="{% url 'tag' tag.name %}">
                                 {{ tag.name }}</a>
                         {% endfor %}
                     </span>
                 </div>
             {% endif %}
             </div>
 		{% endfor %}
 	{% else %}
 		No threads found.
         <hr />
 	{% endif %}
 
     <form enctype="multipart/form-data" method="post">{% csrf_token %}
         <div class="post-form-w">
-            <div class="form-title">{% trans "Create new thread" %}</div>
+            <div class="form-title">{% trans "Reply to thread" %}</div>
             <div class="post-form">
                 <div class="form-row">
                     <div class="form-label">{% trans 'Title' %}</div>
                     <div class="form-input">{{ form.title }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-label">{% trans 'Text' %}</div>
                     <div class="form-input">{{ form.text }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-label">{% trans 'Image' %}</div>
                     <div class="form-input">{{ form.image }}</div>
                 </div>
             </div>
             <div class="form-submit"><input type="submit"
                                             value="{% trans "Post" %}"/></div>
             <div>Use <a
                     href="http://daringfireball.net/projects/markdown/basics">
                 markdown</a> syntax for posting.</div>
             <div>Example: *<i>italic</i>*, **<b>bold</b>**</div>
             <div>Insert quotes with "&gt;"</div>
         </div>
     </form>
 
-{% endblock %}
  No newline at end of file
+{% endblock %}