Added anonymous mode in which the board does not save poster IP addresses

boards/config/default_settings.ini

@@ -1,33 +1,34
 [Version]
 Version = 2.10.0 BT
 SiteName = Neboard DEV
 
 [Cache]
 # Timeout for caching, if cache is used
 CacheTimeout = 600
 
 [Forms]
 # Max post length in characters
 MaxTextLength = 30000
 MaxFileSize = 8000000
 LimitPostingSpeed = false
 
 [Messages]
 # Thread bumplimit
 MaxPostsPerThread = 10
 # Old posts will be archived or deleted if this value is reached
 MaxThreadCount = 5
+AnonymousMode = false
 
 [View]
 DefaultTheme = md
 DefaultImageViewer = simple
 LastRepliesCount = 3
 ThreadsPerPage = 3
 
 [Storage]
 # Enable archiving threads instead of deletion when the thread limit is reached
 ArchiveThreads = true
 
 [External]
 # Thread update
 WebsocketsEnabled = false

boards/models/post/manager.py

@@ -1,125 +1,126
 import logging
 
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 
 from django.db import models, transaction
 from django.utils import timezone
 
 import boards
 
 from boards.models.user import Ban
 from boards.mdx_neboard import Parser
 from boards.models import PostImage, Attachment
 from boards import utils
 
 __author__ = 'neko259'
 
 IMAGE_TYPES = (
     'jpeg',
     'jpg',
     'png',
     'bmp',
     'gif',
 )
 
 POSTS_PER_DAY_RANGE = 7
 NO_IP = '0.0.0.0'
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, file=None, thread=None,
                     ip=NO_IP, tags: list=None, opening_posts: list=None, tripcode=None):
         """
         Creates new post
         """
 
+        if not utils.is_anonymous_mode():
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         # TODO Raise specific exception and catch it in the views
         if is_banned:
             raise Exception("This user is banned")
 
         if not tags:
             tags = []
         if not opening_posts:
             opening_posts = []
 
         posting_time = timezone.now()
         new_thread = False
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time)
             list(map(thread.tags.add, tags))
             boards.models.thread.Thread.objects.process_oldest_threads()
             new_thread = True
 
         pre_text = Parser().preparse(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            poster_ip=ip,
                            thread=thread,
                            last_edit_time=posting_time,
                            tripcode=tripcode,
                            opening=new_thread)
         post.threads.add(thread)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post {} by {}'.format(post, post.poster_ip))
 
         # TODO Move this to other place
         if file:
             file_type = file.name.split('.')[-1].lower()
             if file_type in IMAGE_TYPES:
                 post.images.add(PostImage.objects.create_with_hash(file))
             else:
                 post.attachments.add(Attachment.objects.create_with_hash(file))
 
         post.build_url()
         post.connect_replies()
         post.connect_threads(opening_posts)
         post.connect_notifications()
 
         # Thread needs to be bumped only when the post is already created
         if not new_thread:
             thread.last_edit_time = posting_time
             thread.bump()
             thread.save()
 
         return post
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             post.delete()
 
     @utils.cached_result()
     def get_posts_per_day(self) -> float:
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         return ppd
 

boards/utils.py

@@ -1,103 +1,121
 """
 This module contains helper functions and helper classes.
 """
 import hashlib
 import time
 import hmac
 
 from django.core.cache import cache
 from django.db.models import Model
 from django import forms
 
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
+
 import boards
+from boards.settings import get_bool
 
 from neboard import settings
 
 
 CACHE_KEY_DELIMITER = '_'
 PERMISSION_MODERATE = 'moderation'
 
+HTTP_FORWARDED = 'HTTP_X_FORWARDED_FOR'
+META_REMOTE_ADDR = 'REMOTE_ADDR'
+
+SETTING_MESSAGES = 'Messages'
+SETTING_ANON_MODE = 'AnonymousMode'
+
+ANON_IP = '127.0.0.1'
+
+
+def is_anonymous_mode():
+    return get_bool(SETTING_MESSAGES, SETTING_ANON_MODE)
+
+
 def get_client_ip(request):
-    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+    if is_anonymous_mode():
+        ip = ANON_IP
+    else:
+        x_forwarded_for = request.META.get(HTTP_FORWARDED)
     if x_forwarded_for:
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
-        ip = request.META.get('REMOTE_ADDR')
+            ip = request.META.get(META_REMOTE_ADDR)
     return ip
 
 
 # TODO The output format is not epoch because it includes microseconds
 def datetime_to_epoch(datetime):
     return int(time.mktime(timezone.localtime(
         datetime,timezone.get_current_timezone()).timetuple())
                * 1000000 + datetime.microsecond)
 
 
 def get_websocket_token(user_id='', timestamp=''):
     """
     Create token to validate information provided by new connection.
     """
 
     sign = hmac.new(settings.CENTRIFUGE_PROJECT_SECRET.encode())
     sign.update(settings.CENTRIFUGE_PROJECT_ID.encode())
     sign.update(user_id.encode())
     sign.update(timestamp.encode())
     token = sign.hexdigest()
 
     return token
 
 
 def cached_result(key_method=None):
     """
     Caches method result in the Django's cache system, persisted by object name,
     object name and model id if object is a Django model.
     """
     def _cached_result(function):
         def inner_func(obj, *args, **kwargs):
             # TODO Include method arguments to the cache key
             cache_key_params = [obj.__class__.__name__, function.__name__]
             if isinstance(obj, Model):
                 cache_key_params.append(str(obj.id))
 
             if key_method is not None:
                 cache_key_params += [str(arg) for arg in key_method(obj)]
 
             cache_key = CACHE_KEY_DELIMITER.join(cache_key_params)
 
             persisted_result = cache.get(cache_key)
             if persisted_result is not None:
                 result = persisted_result
             else:
                 result = function(obj, *args, **kwargs)
                 cache.set(cache_key, result)
 
             return result
 
         return inner_func
     return _cached_result
 
 
 def is_moderator(request):
     try:
         moderate = request.user.has_perm(PERMISSION_MODERATE)
     except AttributeError:
         moderate = False
 
     return moderate
 
 
 def get_file_hash(file) -> str:
     md5 = hashlib.md5()
     for chunk in file.chunks():
         md5.update(chunk)
     return md5.hexdigest()
 
 
 def validate_file_size(size: int):
     max_size = boards.settings.get_int('Forms', 'MaxFileSize')
     if size > max_size:
         raise forms.ValidationError(
             _('File must be less than %s bytes')
             % str(max_size))