Moved notrefactored code outside of misago dir.

misago/acl/builder.py

@@ -0,0 +1,91 @@
+from django.conf import settings
+from django.core.cache import cache, InvalidCacheBackendError
+from django.utils.importlib import import_module
+from misago.forms import Form
+from misago.models import Forum, ForumRole
+
+def build_form(request, role):
+    form_type = type('ACLForm', (Form,), dict(layout=[]))
+    for provider in settings.PERMISSION_PROVIDERS:
+        app_module = import_module(provider)
+        try:
+            app_module.make_form(request, role, form_type)
+        except AttributeError:
+            pass
+    return form_type
+
+
+def build_forum_form(request, role):
+    form_type = type('ACLForm', (Form,), dict(layout=[]))
+    for provider in settings.PERMISSION_PROVIDERS:
+        app_module = import_module(provider)
+        try:
+            app_module.make_forum_form(request, role, form_type)
+        except AttributeError:
+            pass
+    return form_type
+
+
+class BaseACL(object):
+    def __init__(self):
+        self.acl = {}
+
+    def __repr__(self):
+        return '%s (%s)' % (self.__class__.__name__[0:-3],
+                            self.__class__.__module__)
+
+
+class ACL(object):
+    def __init__(self, version):
+        self.version = version
+        self.team = False
+
+    def __iter__(self):
+        for attr in dir(self):
+            if not attr.startswith("__") and attr not in ['team', 'version']:
+                yield self.__dict__[attr]
+
+
+def acl(request, user):
+    acl_key = user.make_acl_key()
+    try:
+        user_acl = cache.get(acl_key)
+        if user_acl.version != request.monitor['acl_version']:
+            raise InvalidCacheBackendError()
+    except (AttributeError, InvalidCacheBackendError):
+        user_acl = build_acl(request, request.user.get_roles())
+        cache.set(acl_key, user_acl, 2592000)
+    return user_acl
+
+
+def build_acl(request, roles):
+    acl = ACL(request.monitor['acl_version'])
+    forums = Forum.objects.get(token='root').get_descendants().order_by('lft')
+    perms = []
+    forum_roles = {}
+
+    for role in roles:
+        perms.append(role.get_permissions())
+
+    for role in ForumRole.objects.all():
+        forum_roles[role.pk] = role.get_permissions()
+
+    for provider in settings.PERMISSION_PROVIDERS:
+        app_module = import_module(provider)
+        try:
+            app_module.build(acl, perms)
+        except AttributeError:
+            pass
+        try:
+            app_module.build_forums(acl, perms, forums, forum_roles)
+        except AttributeError:
+            pass
+
+    for provider in settings.PERMISSION_PROVIDERS:
+        app_module = import_module(provider)
+        try:
+            app_module.cleanup(acl, perms, forums)
+        except AttributeError:
+            pass
+
+    return acl

misago/acl/decorators.py

@@ -0,0 +1,12 @@
+from misago.acl.exceptions import ACLError403, ACLError404
+from misago.shared.views import error403, error404
+
+def acl_errors(f):
+    def decorator(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except ACLError403 as e:
+            return error403(args[0], e.message)
+        except ACLError404 as e:
+            return error404(args[0], e.message)
+    return decorator

misago/acl/exceptions.py

@@ -0,0 +1,9 @@
+"""
+ACL Exceptions thrown by Misago actions
+"""
+
+class ACLError403(Exception):
+    pass
+
+class ACLError404(Exception):
+    pass

misago/middleware/acl.py

@@ -0,0 +1,13 @@
+from misago.acl.builder import acl
+
+class ACLMiddleware(object):
+    def process_request(self, request):
+        request.acl = acl(request, request.user)
+        
+        if (request.user.is_authenticated() and
+            (request.acl.team or request.user.is_god()) != request.user.is_team):
+            request.user.is_team = (request.acl.team or request.user.is_god())
+            request.user.save(force_update=True)
+        if request.session.team != request.user.is_team:
+            request.session.team = request.user.is_team
+            request.session.save()

misago/middleware/banning.py

@@ -0,0 +1,18 @@
+from misago.models import BanCache, Guest
+
+class BanningMiddleware(object):
+    def process_request(self, request):
+        if request.heartbeat or request.user.is_crawler():
+            return None
+            
+        try:
+            request.ban = request.session['ban']
+        except KeyError:
+            request.ban = BanCache()
+            request.session['ban'] = request.ban
+
+        if not request.firewall.admin:
+            request.ban.check_for_updates(request)
+            # Make sure banned session is downgraded to guest level
+            if request.ban.is_banned():
+                request.session.sign_out(request)

misago/models/__init__.py

@@ -1,5 +1,5 @@
 from misago.models.alertmodel import Alert
-from misago.models.banmodel import Ban
+from misago.models.banmodel import Ban, BanCache
 from misago.models.changemodel import Change
 from misago.models.checkpointmodel import Checkpoint
 from misago.models.fixturemodel import Fixture

misago/models/banmodel.py

@@ -5,6 +5,32 @@ BAN_NAME = 1
 BAN_EMAIL = 2
 BAN_IP = 3
 
+class BansManager(models.Manager):
+    def check_ban(ip=False, username=False, email=False):
+        bans_model = Ban.objects.filter(Q(expires=None) | Q(expires__gt=timezone.now()))
+        if not (ip and username and email):
+            if ip:
+                bans_model.filter(test=BAN_IP)
+            if username:
+                bans_model.filter(test=BAN_NAME_EMAIL)
+                bans_model.filter(test=BAN_NAME)
+            if email:
+                bans_model.filter(test=BAN_NAME_EMAIL)
+                bans_model.filter(test=BAN_EMAIL)
+        for ban in bans_model.order_by('-expires').iterator():
+            if (
+                # Check user name
+                ((username and (ban.test == BAN_NAME_EMAIL or ban.test == BAN_NAME))
+                and re.search('^' + re.escape(ban.ban).replace('\*', '(.*?)') + '$', username, flags=re.IGNORECASE))
+                or # Check user email
+                ((email and (ban.test == BAN_NAME_EMAIL or ban.test == BAN_EMAIL))
+                and re.search('^' + re.escape(ban.ban).replace('\*', '(.*?)') + '$', email, flags=re.IGNORECASE))
+                or # Check IP address
+                (ip and ban.test == BAN_IP
+                and re.search('^' + re.escape(ban.ban).replace('\*', '(.*?)') + '$', ip, flags=re.IGNORECASE))):
+                    return ban
+        return False
+
 
 class Ban(models.Model):
     test = models.PositiveIntegerField(default=BAN_NAME_EMAIL)
@@ -14,4 +40,45 @@ class Ban(models.Model):
     expires = models.DateTimeField(null=True, blank=True)
 
     class Meta:
-        app_label = 'misago'
+        app_label = 'misago'
+
+
+class BanCache(object):
+    def __init__(self):
+        self.banned = False
+        self.test = None
+        self.expires = None
+        self.reason_user = None
+        self.version = 0
+
+    def check_for_updates(self, request):
+        if (self.version < request.monitor['bans_version']
+            or (self.expires != None and self.expires < timezone.now())):
+            self.version = request.monitor['bans_version']
+
+            # Check Ban
+            if request.user.is_authenticated():
+                ban = check_ban(
+                                ip=request.session.get_ip(request),
+                                username=request.user.username,
+                                email=request.user.email
+                                )
+            else:
+                ban = check_ban(ip=request.session.get_ip(request))
+
+            # Update ban cache
+            if ban:
+                self.banned = True
+                self.reason_user = ban.reason_user
+                self.expires = ban.expires
+                self.test = ban.test
+            else:
+                self.banned = False
+                self.reason_user = None
+                self.expires = None
+                self.test = None
+            return True
+        return False
+
+    def is_banned(self):
+        return self.banned

misago/models/postmodel.py

@@ -72,7 +72,7 @@ class Post(models.Model):
                                        )
             
     def notify_mentioned(self, request, users):
-        from misago.acl.builder import get_acl
+        from misago.acl.builder import acl
         from misago.acl.utils import ACLError403, ACLError404
         
         mentioned = self.mentions.all()
@@ -80,7 +80,7 @@ class Post(models.Model):
             if user.pk != request.user.pk and user not in mentioned:
                 self.mentions.add(user)
                 try:                    
-                    acl = get_acl(request, user)
+                    acl = acl(request, user)
                     acl.forums.allow_forum_view(self.forum)
                     acl.threads.allow_thread_view(user, self.thread)
                     acl.threads.allow_post_view(user, self.thread, self)

misago/models/threadmodel.py

@@ -128,7 +128,7 @@ class Thread(models.Model):
         self.merges = last_post.merge
         
     def email_watchers(self, request, post):
-        from misago.acl.builder import get_acl
+        from misago.acl.builder import acl
         from misago.acl.utils import ACLError403, ACLError404
         from misago.models import ThreadRead
 
@@ -136,7 +136,7 @@ class Thread(models.Model):
             user = watch.user
             if user.pk != request.user.pk:
                 try:
-                    acl = get_acl(request, user)
+                    acl = acl(request, user)
                     acl.forums.allow_forum_view(self.forum)
                     acl.threads.allow_thread_view(user, self)
                     acl.threads.allow_post_view(user, self, post)

misago/models/usermodel.py

@@ -13,12 +13,12 @@ from django.template import RequestContext
 from django.utils import timezone as tz_util
 from django.utils.translation import ugettext_lazy as _
 from misago.acl.builder import build_acl
-from misago.monitor.monitor import Monitor
+from misago.monitor import Monitor
 from misago.dbsettings import DBSettings
 from misago.signals import delete_user_content, rename_user
-from misago.users.validators import validate_username, validate_password, validate_email
 from misago.utils.strings import random_string, slugify
 from misago.utils.avatars import avatar_size
+from misago.validators import validate_username, validate_password, validate_email
 
 class UserManager(models.Manager):
     """
@@ -412,7 +412,7 @@ class User(models.Model):
         self.acl_key = 'acl_%s' % hashlib.md5('_'.join(roles_ids)).hexdigest()[0:8]
         return self.acl_key
 
-    def get_acl(self, request):
+    def acl(self, request):
         try:
             acl = cache.get(self.acl_key)
             if acl.version != request.monitor.acl_version:

misago/settings_base.py

@@ -96,7 +96,7 @@ JINJA2_EXTENSIONS = (
 MIDDLEWARE_CLASSES = (
     'misago.stopwatch.middleware.StopwatchMiddleware',
     'debug_toolbar.middleware.DebugToolbarMiddleware',
-    #'misago.heartbeat.middleware.HeartbeatMiddleware',
+    'misago.heartbeat.middleware.HeartbeatMiddleware',
     'misago.middleware.cookiejar.CookieJarMiddleware',
     'misago.middleware.settings.SettingsMiddleware',
     'misago.middleware.monitor.MonitorMiddleware',
@@ -106,7 +106,7 @@ MIDDLEWARE_CLASSES = (
     'misago.middleware.session.SessionMiddleware',
     #'misago.bruteforce.middleware.JamMiddleware',
     #'misago.csrf.middleware.CSRFMiddleware',
-    #'misago.banning.middleware.BanningMiddleware',
+    'misago.middleware.banning.BanningMiddleware',
     #'misago.messages.middleware.MessagesMiddleware',
     #'misago.users.middleware.UserMiddleware',
     #'misago.acl.middleware.ACLMiddleware',

misago/shared/views.py

@@ -0,0 +1,33 @@
+from django.core.urlresolvers import reverse
+from django.shortcuts import redirect
+from django.template import RequestContext
+
+def redirect_message(request, message, type='info', owner=None):
+    """
+    Set flash message and redirect to board index.
+    """
+    request.messages.set_flash(message, type, owner)
+    return redirect(reverse('index'))
+
+
+"""
+Error views
+"""
+def error_view(request, error, message):
+    response = request.theme.render_to_response(('error%s.html' % error),
+                                                {
+                                                 'message': message,
+                                                 'hide_signin': True,
+                                                 'exception_response': True,
+                                                 },
+                                                context_instance=RequestContext(request));
+    response.status_code = error
+    return response
+
+
+def error403(request, message=None):
+    return error_view(request, 403, message)
+
+
+def error404(request, message=None):
+    return error_view(request, 404, message)

misago/validators.py

@@ -0,0 +1,80 @@
+import re
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.utils.translation import ungettext, ugettext_lazy as _
+from misago.models import Ban
+from misago.settings import DBSettings
+from django.core.exceptions import ValidationError
+from django.utils.translation import ugettext_lazy as _
+from misago.utils.strings import slugify
+
+class validate_sluggable(object):
+    def __init__(self, error_short=None, error_long=None):
+        self.error_short = error_short if error_short else _("Value has to contain alpha-numerical characters.")
+        self.error_long = error_long if error_long else _("Value is too long.")
+
+    def __call__(self, value):
+        slug = slugify(value)
+        if not slug:
+            raise ValidationError(self.error_short)
+        if len(slug) > 255:
+            raise ValidationError(self.error_long)
+
+
+def validate_username(value, db_settings):
+    value = unicode(value).strip()
+    if len(value) < db_settings['username_length_min']:
+        raise ValidationError(ungettext(
+            'Username must be at least one character long.',
+            'Username must be at least %(count)d characters long.',
+            db_settings['username_length_min']
+        ) % {
+            'count': db_settings['username_length_min'],
+        })
+    if len(value) > db_settings['username_length_max']:
+        raise ValidationError(ungettext(
+            'Username cannot be longer than one characters.',
+            'Username cannot be longer than %(count)d characters.',
+            db_settings['username_length_max']
+        ) % {
+            'count': db_settings['username_length_max'],
+        })
+    if settings.UNICODE_USERNAMES:
+        if not re.search('^[^\W_]+$', value, re.UNICODE):
+            raise ValidationError(_("Username can only contain letters and digits."))
+    else:
+        if not re.search('^[^\W_]+$', value):
+            raise ValidationError(_("Username can only contain latin alphabet letters and digits."))
+    if Ban.objects.check_ban(username=value):
+        raise ValidationError(_("This username is forbidden."))
+
+
+def validate_password(value, db_settings):
+    value = unicode(value).strip()
+    if len(value) < db_settings['password_length']:
+        raise ValidationError(ungettext(
+            'Correct password has to be at least one character long.',
+            'Correct password has to be at least %(count)d characters long.',
+            db_settings['password_length']
+        ) % {
+            'count': db_settings['password_length'],
+        })
+    for test in db_settings['password_complexity']:
+        if test in ('case', 'digits', 'special'):
+            if not re.search('[a-zA-Z]', value):
+                raise ValidationError(_("Password must contain alphabetical characters."))
+            if test == 'case':
+                if not (re.search('[a-z]', value) and re.search('[A-Z]', value)):
+                    raise ValidationError(_("Password must contain characters that have different case."))
+            if test == 'digits':
+                if not re.search('[0-9]', value):
+                    raise ValidationError(_("Password must contain digits in addition to characters."))
+            if test == 'special':
+                if not re.search('[^0-9a-zA-Z]', value):
+                    raise ValidationError(_("Password must contain special (non alphanumerical) characters."))
+
+
+def validate_email(value):
+    value = unicode(value).strip()
+    if Ban.objects.check_ban(email=value):
+        raise ValidationError(_("This board forbids registrations using this e-mail address."))

notrefactored/acl/panels.py

@@ -0,0 +1,30 @@
+from debug_toolbar.panels import DebugPanel
+from django.template.loader import render_to_string
+from django.utils.translation import ugettext_lazy as _
+
+class MisagoACLDebugPanel(DebugPanel):
+    name = 'MisagoACL'
+    has_content = True
+
+    def nav_title(self):
+        return _('Misago ACL')
+
+    def title(self):
+        return _('Misago User ACL')
+
+    def url(self):
+        return ''
+
+    def process_request(self, request):
+        self.request = request
+
+    def content(self):
+        if self.request.heartbeat:
+            self.has_content = False
+        else:
+            context = self.context.copy()
+            try:
+                context['acl'] = self.request.acl
+            except AttributeError:
+                context['acl'] = {}
+            return render_to_string('debug_toolbar/panels/acl.html', context)

notrefactored/heartbeat/middleware.py

@@ -0,0 +1,8 @@
+from django.conf import settings
+from django.http import HttpResponse
+
+class HeartbeatMiddleware(object):
+    def process_request(self, request):
+        request.heartbeat = settings.HEARTBEAT_PATH and settings.HEARTBEAT_PATH == request.path
+        if request.heartbeat:
+            return HttpResponse('BATTLECRUISER OPERATIONAL')

refactoring.md

@@ -8,20 +8,15 @@ Directory Tree
 misago/                        App root structure
 +-admin/                       Admin apps
 +-shared/                      Shared (Admin/Front) apps
-+-core/                        Core features
-  +-forms/                     Misago forms
-    +-fields.py                Custom fields
-    +-forms.py                 Custom form base class
-    +-layouts.py               Forums layouts (wrapper around Django forms that enables templating)
-    +-widgets.py               Custom widgets
-  +-cookiejar.py               CookieJar allows for easy setting and removing cookies without direct access to response object
-  +-monitor.py                 Monitor controller that tracks forum stats
-  +-settings.py                DB based settings controller
-  +-stopwatch.py               Stopwatch controller for measuring request processing time
 +-fixtures/                    Starting data
   +-basicsettings.py           "Basic Settings" group fixture
   +-captchasettings.py         "Captcha Settings" group fixture
   +-usersmonitor.py            Users Monitor fixture
++-forms/                     Misago forms
+  +-fields.py                Custom fields
+  +-forms.py                 Custom form base class
+  +-layouts.py               Forums layouts (wrapper around Django forms that enables templating)
+  +-widgets.py               Custom widgets
 +-front/                       Frontend apps
 +-management/                  manage.py commands
 +-migrations/                  South DB migrations
@@ -41,10 +36,14 @@ misago/                        App root structure
   +-translation.py             Functions for working with translation strings
 +-__init__.py                  Misago init, contains Misago version
 +-context_processors.py        Misago context processors
++-cookiejar.py                 CookieJar allows for easy setting and removing cookies without direct access to response object
++-dbsettings.py                DB based settings controller
++-monitor.py                   Monitor controller that tracks forum stats
 +-settingsbase.py              Base configuration
 +-signals.py                   Misago's signals
 +-urls.py                      Default urls
 +-validators.py                Misago's validators
++-stopwatch.py                 Stopwatch controller for measuring request processing time
 ```