Merged with default branch

boards/migrations/0036_thread_status.py

@@ -0,0 +1,32
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    def bumpable_and_opening_to_status(apps, schema_editor):
+        Thread = apps.get_model('boards', 'Thread')
+        for thread in Thread.objects.all():
+            if thread.archived:
+                thread.status = 'archived'
+            elif not thread.bumpable:
+                thread.status = 'bumplimit'
+            else:
+                thread.status = 'active'
+            thread.save(update_fields=['status'])
+
+
+    dependencies = [
+        ('boards', '0035_auto_20151021_1346'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='thread',
+            name='status',
+            field=models.CharField(default='active', max_length=50),
+        ),
+        migrations.RunPython(bumpable_and_opening_to_status),
+    ]

boards/migrations/0037_auto_20151122_2155.py

@@ -0,0 +1,22
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0036_thread_status'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='thread',
+            name='archived',
+        ),
+        migrations.RemoveField(
+            model_name='thread',
+            name='bumpable',
+        ),
+    ]

boards/migrations/0038_auto_20151123_1203.py

@@ -0,0 +1,19
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0037_auto_20151122_2155'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='banner',
+            name='text',
+            field=models.TextField(null=True, blank=True),
+        ),
+    ]

boards/migrations/0039_auto_20151203_1841.py

@@ -0,0 +1,19
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0038_auto_20151123_1203'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='thread',
+            name='status',
+            field=models.CharField(max_length=50, choices=[('active', 'active'), ('bumplimit', 'bumplimit'), ('archived', 'archived')], default='active'),
+        ),
+    ]

boards/migrations/0040_thread_monochrome.py

@@ -0,0 +1,19
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0039_auto_20151203_1841'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='thread',
+            name='monochrome',
+            field=models.BooleanField(default=False),
+        ),
+    ]

boards/static/js/3party/sha256.js

@@ -0,0 +1,16
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+var CryptoJS=CryptoJS||function(h,s){var f={},t=f.lib={},g=function(){},j=t.Base={extend:function(a){g.prototype=this;var c=new g;a&&c.mixIn(a);c.hasOwnProperty("init")||(c.init=function(){c.$super.init.apply(this,arguments)});c.init.prototype=c;c.$super=this;return c},create:function(){var a=this.extend();a.init.apply(a,arguments);return a},init:function(){},mixIn:function(a){for(var c in a)a.hasOwnProperty(c)&&(this[c]=a[c]);a.hasOwnProperty("toString")&&(this.toString=a.toString)},clone:function(){return this.init.prototype.extend(this)}},
+q=t.WordArray=j.extend({init:function(a,c){a=this.words=a||[];this.sigBytes=c!=s?c:4*a.length},toString:function(a){return(a||u).stringify(this)},concat:function(a){var c=this.words,d=a.words,b=this.sigBytes;a=a.sigBytes;this.clamp();if(b%4)for(var e=0;e<a;e++)c[b+e>>>2]|=(d[e>>>2]>>>24-8*(e%4)&255)<<24-8*((b+e)%4);else if(65535<d.length)for(e=0;e<a;e+=4)c[b+e>>>2]=d[e>>>2];else c.push.apply(c,d);this.sigBytes+=a;return this},clamp:function(){var a=this.words,c=this.sigBytes;a[c>>>2]&=4294967295<<
+32-8*(c%4);a.length=h.ceil(c/4)},clone:function(){var a=j.clone.call(this);a.words=this.words.slice(0);return a},random:function(a){for(var c=[],d=0;d<a;d+=4)c.push(4294967296*h.random()|0);return new q.init(c,a)}}),v=f.enc={},u=v.Hex={stringify:function(a){var c=a.words;a=a.sigBytes;for(var d=[],b=0;b<a;b++){var e=c[b>>>2]>>>24-8*(b%4)&255;d.push((e>>>4).toString(16));d.push((e&15).toString(16))}return d.join("")},parse:function(a){for(var c=a.length,d=[],b=0;b<c;b+=2)d[b>>>3]|=parseInt(a.substr(b,
+2),16)<<24-4*(b%8);return new q.init(d,c/2)}},k=v.Latin1={stringify:function(a){var c=a.words;a=a.sigBytes;for(var d=[],b=0;b<a;b++)d.push(String.fromCharCode(c[b>>>2]>>>24-8*(b%4)&255));return d.join("")},parse:function(a){for(var c=a.length,d=[],b=0;b<c;b++)d[b>>>2]|=(a.charCodeAt(b)&255)<<24-8*(b%4);return new q.init(d,c)}},l=v.Utf8={stringify:function(a){try{return decodeURIComponent(escape(k.stringify(a)))}catch(c){throw Error("Malformed UTF-8 data");}},parse:function(a){return k.parse(unescape(encodeURIComponent(a)))}},
+x=t.BufferedBlockAlgorithm=j.extend({reset:function(){this._data=new q.init;this._nDataBytes=0},_append:function(a){"string"==typeof a&&(a=l.parse(a));this._data.concat(a);this._nDataBytes+=a.sigBytes},_process:function(a){var c=this._data,d=c.words,b=c.sigBytes,e=this.blockSize,f=b/(4*e),f=a?h.ceil(f):h.max((f|0)-this._minBufferSize,0);a=f*e;b=h.min(4*a,b);if(a){for(var m=0;m<a;m+=e)this._doProcessBlock(d,m);m=d.splice(0,a);c.sigBytes-=b}return new q.init(m,b)},clone:function(){var a=j.clone.call(this);
+a._data=this._data.clone();return a},_minBufferSize:0});t.Hasher=x.extend({cfg:j.extend(),init:function(a){this.cfg=this.cfg.extend(a);this.reset()},reset:function(){x.reset.call(this);this._doReset()},update:function(a){this._append(a);this._process();return this},finalize:function(a){a&&this._append(a);return this._doFinalize()},blockSize:16,_createHelper:function(a){return function(c,d){return(new a.init(d)).finalize(c)}},_createHmacHelper:function(a){return function(c,d){return(new w.HMAC.init(a,
+d)).finalize(c)}}});var w=f.algo={};return f}(Math);
+(function(h){for(var s=CryptoJS,f=s.lib,t=f.WordArray,g=f.Hasher,f=s.algo,j=[],q=[],v=function(a){return 4294967296*(a-(a|0))|0},u=2,k=0;64>k;){var l;a:{l=u;for(var x=h.sqrt(l),w=2;w<=x;w++)if(!(l%w)){l=!1;break a}l=!0}l&&(8>k&&(j[k]=v(h.pow(u,0.5))),q[k]=v(h.pow(u,1/3)),k++);u++}var a=[],f=f.SHA256=g.extend({_doReset:function(){this._hash=new t.init(j.slice(0))},_doProcessBlock:function(c,d){for(var b=this._hash.words,e=b[0],f=b[1],m=b[2],h=b[3],p=b[4],j=b[5],k=b[6],l=b[7],n=0;64>n;n++){if(16>n)a[n]=
+c[d+n]|0;else{var r=a[n-15],g=a[n-2];a[n]=((r<<25|r>>>7)^(r<<14|r>>>18)^r>>>3)+a[n-7]+((g<<15|g>>>17)^(g<<13|g>>>19)^g>>>10)+a[n-16]}r=l+((p<<26|p>>>6)^(p<<21|p>>>11)^(p<<7|p>>>25))+(p&j^~p&k)+q[n]+a[n];g=((e<<30|e>>>2)^(e<<19|e>>>13)^(e<<10|e>>>22))+(e&f^e&m^f&m);l=k;k=j;j=p;p=h+r|0;h=m;m=f;f=e;e=r+g|0}b[0]=b[0]+e|0;b[1]=b[1]+f|0;b[2]=b[2]+m|0;b[3]=b[3]+h|0;b[4]=b[4]+p|0;b[5]=b[5]+j|0;b[6]=b[6]+k|0;b[7]=b[7]+l|0},_doFinalize:function(){var a=this._data,d=a.words,b=8*this._nDataBytes,e=8*a.sigBytes;
+d[e>>>5]|=128<<24-e%32;d[(e+64>>>9<<4)+14]=h.floor(b/4294967296);d[(e+64>>>9<<4)+15]=b;a.sigBytes=4*d.length;this._process();return this._hash},clone:function(){var a=g.clone.call(this);a._hash=this._hash.clone();return a}});s.SHA256=g._createHelper(f);s.HmacSHA256=g._createHmacHelper(f)})(Math);

boards/static/js/proof_of_work.js

@@ -0,0 +1,54
+var POW_COMPUTING_TIMEOUT = 2;
+var POW_HASH_LENGTH = 16;
+
+
+function computeHash(iteration, guess, target, payload, timestamp, hasher) {
+    iteration += 1;
+    var hash = hasher(payload + iteration).toString();
+    guess = hash.substring(0, POW_HASH_LENGTH);
+
+    if (guess <= target) {
+        //console.log("Iteration: ", iteration);
+        //console.log("Guess: ", guess);
+        //console.log("Target: ", target);
+
+        var data = {
+            iteration: iteration,
+            timestamp: timestamp,
+            guess: guess
+        };
+        self.postMessage(data);
+    } else {
+        //console.log("Iteration: ", iteration);
+        //console.log("Guess: ", guess);
+        //console.log("Target: ", target);
+
+        setTimeout(function() {
+            computeHash(iteration, guess, target, payload, timestamp, hasher);
+        }, POW_COMPUTING_TIMEOUT);
+    }
+}
+
+function doWork(message, hasher, difficulty) {
+    var timestamp = Date.now();
+    var iteration = 0;
+    var payload = timestamp + message;
+
+    var target = parseInt(Math.pow(2, POW_HASH_LENGTH * 3) / difficulty).toString();
+    while (target.length < POW_HASH_LENGTH) {
+        target = '0' + target;
+    }
+
+    var guess = target + '0';
+
+    setTimeout(function() {
+        computeHash(iteration, guess, target, payload, timestamp, hasher);
+    }, POW_COMPUTING_TIMEOUT);
+}
+
+self.onmessage = function(e) {
+    var difficulty = e.data.difficulty;
+    importScripts(e.data.hasher);
+    var hasher = CryptoJS.SHA256;
+    self.doWork(e.data.msg, hasher, difficulty);
+};

boards/views/tag_gallery.py

@@ -0,0 +1,31
+from django.core.urlresolvers import reverse
+from django.shortcuts import get_object_or_404, render
+
+from boards import settings
+from boards.abstracts.paginator import get_paginator
+from boards.models import Tag
+from boards.views.base import BaseBoardView
+from boards.views.mixins import PaginatedMixin
+
+IMAGES_PER_PAGE = settings.get_int('View', 'ImagesPerPageGallery')
+
+TEMPLATE = 'boards/tag_gallery.html'
+
+
+class TagGalleryView(BaseBoardView, PaginatedMixin):
+
+    def get(self, request, tag_name):
+        page = int(request.GET.get('page', 1))
+
+        params = dict()
+        tag = get_object_or_404(Tag, name=tag_name)
+        params['tag'] = tag
+        paginator = get_paginator(tag.get_images(), IMAGES_PER_PAGE,
+                                  current_page=page)
+        params['paginator'] = paginator
+        params['images'] = paginator.page(page).object_list
+        paginator.set_url(reverse('tag_gallery', kwargs={'tag_name': tag_name}),
+                          request.GET.dict())
+        self.set_page_urls(paginator, params)
+
+        return render(request, TEMPLATE, params)
  No newline at end of file

boards/views/translation.py

@@ -0,0 +1,7
+from django.views.decorators.cache import cache_page
+from django.views.i18n import javascript_catalog
+
+@cache_page(600)
+def cached_javascript_catalog(request, domain='djangojs', packages=None):
+    return javascript_catalog(request, domain, packages)
+

.hgtags

@@ -1,37 +1,39
 bc8fce57a613175450b8b6d933cdd85f22c04658 1.1
 784258eb652c563c288ca7652c33f52cd4733d83 1.1-stable
 1b53a22467a8fccc798935d7a26efe78e4bc7b25 1.2-stable
 1713fb7543386089e364c39703b79e57d3d851f0 1.3
 80f183ebbe132ea8433eacae9431360f31fe7083 1.4
 4330ff5a2bf6c543d8aaae8a43de1dc062f3bd13 1.4.1
 8531d7b001392289a6b761f38c73a257606552ad 1.5
 78e843c8b04b5a81cee5aa24601e305fae75da24 1.5.1
 4f92838730ed9aa1d17651bbcdca19a097fd0c37 1.6
 4bac2f37ea463337ddd27f98e7985407a74de504 1.7
 1c4febea92c6503ae557fba73b2768659ae90d24 1.7.1
 56a4a4578fc454ee455e33dd74a2cc82234bcb59 1.7.2
 34d6f3d5deb22be56b6c1512ec654bd7f6e03bcc 1.7.3
 f5cca33d29c673b67d43f310bebc4e3a21c6d04c 1.7.4
 7f7c33ba6e3f3797ca866c5ed5d358a2393f1371 1.8
 a6b9dd9547bdc17b681502efcceb17aa5c09adf4 1.8.1
 8318fa1615d1946e4519f5735ae880909521990d 2.0
 e23590ee7e2067a3f0fc3cbcfd66404b47127feb 2.1
 4d998aba79e4abf0a2e78e93baaa2c2800b1c49c 2.2
 07fdef4ac33a859250d03f17c594089792bca615 2.2.1
 bcc74d45f060ecd3ff06ff448165aea0d026cb3e 2.2.2
 b0e629ff24eb47a449ecfb455dc6cc600d18c9e2 2.2.3
 1b52ba60f17fd7c90912c14d9d17e880b7952d01 2.2.4
 957e2fec91468f739b0fc2b9936d564505048c68 2.3.0
 bb91141c6ea5c822ccbe2d46c3c48bdab683b77d 2.4.0
 97eb184637e5691b288eaf6b03e8971f3364c239 2.5.0
 119fafc5381b933bf30d97be0b278349f6135075 2.5.1
 d528d76d3242cced614fa11bb63f3d342e4e1d09 2.5.2
 1b631781ced34fbdeec032e7674bc4e131724699 2.6.0
 0f2ef17dc0de678ada279bf7eedf6c5585f1fd7a 2.6.1
 d53fc814a424d7fd90f23025c87b87baa164450e 2.7.0
 836d8bb9fcd930b952b9a02029442c71c2441983 2.8.0
 dfb6c481b1a2c33705de9a9b5304bc924c46b202 2.8.1
 4a5bec08ccfb47a27f9e98698f12dd5b7246623b 2.8.2
 604935b98f5b5e4a5e903594f048046e1fbb3519 2.8.3
 c48ffdc671566069ed0f33644da1229277f3cd18 2.9.0
 d66dc192d4e089ba85325afeef5229b73cb0fde4 2.10.0
+1c22a38cca9ae3bee13d6f263792c0629d0061f6 2.10.1
+3076e0d03339f3b41dcc71fb6af2b4169920846c 2.11.0

boards/abstracts/paginator.py

@@ -1,74 +1,91
 __author__ = 'neko259'
 
 from django.core.paginator import Paginator
 
 PAGINATOR_LOOKAROUND_SIZE = 2
 
 
 def get_paginator(*args, **kwargs):
     return DividedPaginator(*args, **kwargs)
 
 
 class DividedPaginator(Paginator):
 
     lookaround_size = PAGINATOR_LOOKAROUND_SIZE
-    current_page = 0
+
+    def __init__(self, object_list, per_page, orphans=0,
+                 allow_empty_first_page=True, current_page=1):
+        super().__init__(object_list, per_page, orphans, allow_empty_first_page)
+
+        self.link = None
+        self.params = None
+        self.current_page = current_page
 
     def _left_range(self):
         return self.page_range[:self.lookaround_size]
 
     def _right_range(self):
         pages = self.num_pages-self.lookaround_size
         if pages <= 0:
             return []
         else:
             return self.page_range[pages:]
 
     def _center_range(self):
         index = self.page_range.index(self.current_page)
 
         start = max(self.lookaround_size, index - self.lookaround_size)
         end = min(self.num_pages - self.lookaround_size, index + self.lookaround_size + 1)
         return self.page_range[start:end]
 
     def get_divided_range(self):
         dr = list()
 
         dr += self._left_range()
         dr += self._center_range()
         dr += self._right_range()
 
         # Remove duplicates
         dr = list(set(dr))
         dr.sort()
 
         return dr
 
     def get_dividers(self):
         dividers = []
 
         prev_page = 1
         for page in self.get_divided_range():
             if page - prev_page > 1:
                 dividers.append(page)
 
                 # There can be no more than 2 dividers, so don't bother going
                 # further
                 if len(dividers) > 2:
                     break
             prev_page = page
 
         return dividers
 
     def set_url(self, link, params):
         self.link = link
         self.params = params
 
     def get_page_url(self, page):
         self.params['page'] = page
         url_params = '?' + '&'.join(['{}={}'.format(key, self.params[key])
-            for key in self.params.keys()])
+                                     for key in self.params.keys()])
         return self.link + url_params
 
     def supports_urls(self):
         return self.link is not None and self.params is not None
+
+    def get_next_page_url(self):
+        current = self.page(self.current_page)
+        if current.has_next():
+            return self.get_page_url(current.next_page_number())
+
+    def get_prev_page_url(self):
+        current = self.page(self.current_page)
+        if current.has_previous():
+            return self.get_page_url(current.previous_page_number())
  No newline at end of file

boards/abstracts/settingsmanager.py

@@ -1,172 +1,180
 from boards.models import Tag
 from boards.models.thread import FAV_THREAD_NO_UPDATES
 
 MAX_TRIPCODE_COLLISIONS = 50
 
 __author__ = 'neko259'
 
 SESSION_SETTING = 'setting'
 
 # Remove this, it is not used any more cause there is a user's permission
 PERMISSION_MODERATE = 'moderator'
 
 SETTING_THEME = 'theme'
 SETTING_FAVORITE_TAGS = 'favorite_tags'
 SETTING_FAVORITE_THREADS = 'favorite_threads'
 SETTING_HIDDEN_TAGS = 'hidden_tags'
 SETTING_PERMISSIONS = 'permissions'
 SETTING_USERNAME = 'username'
 SETTING_LAST_NOTIFICATION_ID = 'last_notification'
 SETTING_IMAGE_VIEWER = 'image_viewer'
 SETTING_TRIPCODE = 'tripcode'
 
 DEFAULT_THEME = 'md'
 
 
 class SettingsManager:
     """
     Base settings manager class. get_setting and set_setting methods should
     be overriden.
     """
     def __init__(self):
         pass
 
     def get_theme(self) -> str:
         theme = self.get_setting(SETTING_THEME)
         if not theme:
             theme = DEFAULT_THEME
             self.set_setting(SETTING_THEME, theme)
 
         return theme
 
     def set_theme(self, theme):
         self.set_setting(SETTING_THEME, theme)
 
     def has_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if permissions:
             return permission in permissions
         else:
             return False
 
     def get_setting(self, setting, default=None):
         pass
 
     def set_setting(self, setting, value):
         pass
 
     def add_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = [permission]
         else:
             permissions.append(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def del_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = []
         else:
             permissions.remove(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def get_fav_tags(self) -> list:
         tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(name__in=tag_names))
         return tags
 
     def add_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
 
         tags.sort()
         self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def del_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def get_hidden_tags(self) -> list:
         tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(name__in=tag_names))
 
         return tags
 
     def add_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
 
         tags.sort()
         self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def del_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def get_fav_threads(self) -> dict:
         return self.get_setting(SETTING_FAVORITE_THREADS, default=dict())
 
     def add_or_read_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         thread = opening_post.get_thread()
         # Don't check for new posts if the thread is archived already
         if thread.is_archived():
             last_id = FAV_THREAD_NO_UPDATES
         else:
             last_id = thread.get_replies().last().id
         threads[str(opening_post.id)] = last_id
         self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def del_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         if self.thread_is_fav(opening_post):
             del threads[str(opening_post.id)]
             self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def thread_is_fav(self, opening_post):
         return str(opening_post.id) in self.get_fav_threads()
 
+    def get_notification_usernames(self):
+        name_list = self.get_setting(SETTING_USERNAME)
+        if name_list is not None and len(name_list) > 0:
+            return name_list.lower().split(',')
+        else:
+            return list()
+
+
 class SessionSettingsManager(SettingsManager):
     """
     Session-based settings manager. All settings are saved to the user's
     session.
     """
     def __init__(self, session):
         SettingsManager.__init__(self)
         self.session = session
 
     def get_setting(self, setting, default=None):
         if setting in self.session:
             return self.session[setting]
         else:
             self.set_setting(setting, default)
             return default
 
     def set_setting(self, setting, value):
         self.session[setting] = value
 
 
 def get_settings_manager(request) -> SettingsManager:
     """
     Get settings manager based on the request object. Currently only
     session-based manager is supported. In the future, cookie-based or
     database-based managers could be implemented.
     """
     return SessionSettingsManager(request.session)

boards/admin.py

@@ -1,81 +1,82
 from django.contrib import admin
 from boards.models import Post, Tag, Ban, Thread, KeyPair, Banner
 from django.utils.translation import ugettext_lazy as _
 
 
 @admin.register(Post)
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text', 'poster_ip')
     list_filter = ('pub_time',)
     search_fields = ('id', 'title', 'text', 'poster_ip')
     exclude = ('referenced_posts', 'refmap')
-    readonly_fields = ('poster_ip', 'threads', 'thread', 'images', 'uid')
+    readonly_fields = ('poster_ip', 'threads', 'thread', 'images',
+            'attachments', 'uid', 'url', 'pub_time', 'opening')
 
     def ban_poster(self, request, queryset):
         bans = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
         self.message_user(request, _('{} posters were banned').format(bans))
 
     actions = ['ban_poster']
 
 
 @admin.register(Tag)
 class TagAdmin(admin.ModelAdmin):
 
     def thread_count(self, obj: Tag) -> int:
         return obj.get_thread_count()
 
     def display_children(self, obj: Tag):
         return ', '.join([str(child) for child in obj.get_children().all()])
 
     list_display = ('name', 'thread_count', 'display_children')
     search_fields = ('name',)
 
 
 @admin.register(Thread)
 class ThreadAdmin(admin.ModelAdmin):
 
     def title(self, obj: Thread) -> str:
         return obj.get_opening_post().get_title()
 
     def reply_count(self, obj: Thread) -> int:
         return obj.get_reply_count()
 
     def ip(self, obj: Thread):
         return obj.get_opening_post().poster_ip
 
     def display_tags(self, obj: Thread):
         return ', '.join([str(tag) for tag in obj.get_tags().all()])
 
     def op(self, obj: Thread):
         return obj.get_opening_post_id()
 
-    list_display = ('id', 'op', 'title', 'reply_count', 'archived', 'ip',
+    list_display = ('id', 'op', 'title', 'reply_count', 'status', 'ip',
             'display_tags')
-    list_filter = ('bump_time', 'archived', 'bumpable')
+    list_filter = ('bump_time', 'status')
     search_fields = ('id', 'title')
     filter_horizontal = ('tags',)
 
 
 @admin.register(KeyPair)
 class KeyPairAdmin(admin.ModelAdmin):
     list_display = ('public_key', 'primary')
     list_filter = ('primary',)
     search_fields = ('public_key',)
 
 
 @admin.register(Ban)
 class BanAdmin(admin.ModelAdmin):
     list_display = ('ip', 'can_read')
     list_filter = ('can_read',)
     search_fields = ('ip',)
 
 
 @admin.register(Banner)
 class BannerAdmin(admin.ModelAdmin):
     list_display = ('title', 'text')

boards/config/default_settings.ini

@@ -1,34 +1,39
 [Version]
-Version = 2.10.0 BT
+Version = 2.11.0 Yuko
 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
+LimitPostingSpeed = true
+PowDifficulty = 20
 
 [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
+ImagesPerPageGallery = 20
 
 [Storage]
 # Enable archiving threads instead of deletion when the thread limit is reached
 ArchiveThreads = true
 
 [External]
 # Thread update
 WebsocketsEnabled = false
+
+[RSS]
+MaxItems = 20

boards/context_processors.py

@@ -1,68 +1,68
 from boards.abstracts.settingsmanager import get_settings_manager, \
-    SETTING_USERNAME, SETTING_LAST_NOTIFICATION_ID, SETTING_IMAGE_VIEWER
+    SETTING_LAST_NOTIFICATION_ID, SETTING_IMAGE_VIEWER
 from boards.models.user import Notification
 
 __author__ = 'neko259'
 
-from boards import settings, utils
+from boards import settings
 from boards.models import Post, Tag
 
 CONTEXT_SITE_NAME = 'site_name'
 CONTEXT_VERSION = 'version'
-CONTEXT_MODERATOR = 'moderator'
 CONTEXT_THEME_CSS = 'theme_css'
 CONTEXT_THEME = 'theme'
 CONTEXT_PPD = 'posts_per_day'
 CONTEXT_TAGS = 'tags'
 CONTEXT_USER = 'user'
 CONTEXT_NEW_NOTIFICATIONS_COUNT = 'new_notifications_count'
-CONTEXT_USERNAME = 'username'
+CONTEXT_USERNAMES = 'usernames'
 CONTEXT_TAGS_STR = 'tags_str'
 CONTEXT_IMAGE_VIEWER = 'image_viewer'
 CONTEXT_HAS_FAV_THREADS = 'has_fav_threads'
+CONTEXT_POW_DIFFICULTY = 'pow_difficulty'
 
 
 def get_notifications(context, request):
     settings_manager = get_settings_manager(request)
-    username = settings_manager.get_setting(SETTING_USERNAME)
+    usernames = settings_manager.get_notification_usernames()
     new_notifications_count = 0
-    if username is not None and len(username) > 0:
+    if usernames is not None:
         last_notification_id = settings_manager.get_setting(
             SETTING_LAST_NOTIFICATION_ID)
 
         new_notifications_count = Notification.objects.get_notification_posts(
-                username=username, last=last_notification_id).count()
+                usernames=usernames, last=last_notification_id).count()
     context[CONTEXT_NEW_NOTIFICATIONS_COUNT] = new_notifications_count
-    context[CONTEXT_USERNAME] = username
+    context[CONTEXT_USERNAMES] = usernames
 
 
 def user_and_ui_processor(request):
     context = dict()
 
     context[CONTEXT_PPD] = float(Post.objects.get_posts_per_day())
 
     settings_manager = get_settings_manager(request)
     fav_tags = settings_manager.get_fav_tags()
     context[CONTEXT_TAGS] = fav_tags
 
     context[CONTEXT_TAGS_STR] = Tag.objects.get_tag_url_list(fav_tags)
     theme = settings_manager.get_theme()
     context[CONTEXT_THEME] = theme
     context[CONTEXT_THEME_CSS] = 'css/' + theme + '/base_page.css'
 
-    # This shows the moderator panel
-    context[CONTEXT_MODERATOR] = utils.is_moderator(request)
-
     context[CONTEXT_VERSION] = settings.get('Version', 'Version')
     context[CONTEXT_SITE_NAME] = settings.get('Version', 'SiteName')
 
+    if settings.get_bool('Forms', 'LimitPostingSpeed'):
+        context[CONTEXT_POW_DIFFICULTY] = settings.get_int('Forms', 'PowDifficulty')
+
     context[CONTEXT_IMAGE_VIEWER] = settings_manager.get_setting(
         SETTING_IMAGE_VIEWER,
         default=settings.get('View', 'DefaultImageViewer'))
 
     context[CONTEXT_HAS_FAV_THREADS] =\
         len(settings_manager.get_fav_threads()) > 0
 
     get_notifications(context, request)
 
     return context

boards/forms.py

@@ -1,406 +1,443
 import hashlib
 import re
 import time
 import logging
+
 import pytz
 
 from django import forms
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.exceptions import ObjectDoesNotExist
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _, ungettext_lazy
+from django.utils import timezone
 
 from boards.mdx_neboard import formatters
 from boards.models.attachment.downloaders import Downloader
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import Tag, Post
 from boards.utils import validate_file_size, get_file_mimetype, \
     FILE_EXTENSION_DELIMITER
 from neboard import settings
 import boards.settings as board_settings
 import neboard
 
+POW_HASH_LENGTH = 16
+POW_LIFE_MINUTES = 1
+
 REGEX_TAGS = re.compile(r'^[\w\s\d]+$', re.UNICODE)
+REGEX_USERNAMES = re.compile(r'^[\w\s\d,]+$', re.UNICODE)
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 ATTRIBUTE_ROWS = 'rows'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('Type message here. Use formatting panel for more advanced usage.')
 TAGS_PLACEHOLDER = _('music images i_dont_like_tags')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 ERROR_SPEED = 'Please wait %(delay)d second before sending message'
 ERROR_SPEED_PLURAL = 'Please wait %(delay)d seconds before sending message'
 
 TAG_MAX_LENGTH = 20
 
 TEXTAREA_ROWS = 4
 
 TRIPCODE_DELIM = '#'
 
 # TODO Maybe this may be converted into the database table?
 MIMETYPE_EXTENSIONS = {
     'image/jpeg': 'jpeg',
     'image/png': 'png',
     'image/gif': 'gif',
     'video/webm': 'webm',
     'application/pdf': 'pdf',
     'x-diff': 'diff',
     'image/svg+xml': 'svg',
     'application/x-shockwave-flash': 'swf',
 }
 
 
 def get_timezones():
     timezones = []
     for tz in pytz.common_timezones:
         timezones.append((tz, tz),)
     return timezones
 
 
 class FormatPanel(forms.Textarea):
     """
     Panel for text formatting. Consists of buttons to add different tags to the
     form text area.
     """
 
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += '<span class="mark_btn"' + \
                       ' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + '</span>'
 
         output += '</div>'
-        output += super(FormatPanel, self).render(name, value, attrs=None)
+        output += super(FormatPanel, self).render(name, value, attrs=attrs)
 
         return output
 
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join(['(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
     """
     Form with neboard-specific formatting.
     """
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row">'
                        '<div class="form-label">'
                        '%(label)s'
                        '</div>'
                        '<div class="form-input">'
                        '%(field)s'
                        '</div>'
                        '</div>'
                        '<div class="form-row">'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-row">'
                       '<div class="form-label"></div>'
                       '<div class="form-errors">%s</div>'
                       '</div>',
             row_ender='</div>',
             help_text_html='%s',
             errors_on_separate_row=True)
 
     def as_json_errors(self):
         errors = []
 
         for name, field in list(self.fields.items()):
             if self[name].errors:
                 errors.append({
                     'field': name,
                     'errors': self[name].errors.as_text(),
                 })
 
         return errors
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
                             label=LABEL_TITLE,
                             widget=forms.TextInput(
                                 attrs={ATTRIBUTE_PLACEHOLDER:
                                            'test#tripcode'}))
     text = forms.CharField(
         widget=FormatPanel(attrs={
             ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER,
             ATTRIBUTE_ROWS: TEXTAREA_ROWS,
         }),
         required=False, label=LABEL_TEXT)
     file = forms.FileField(required=False, label=_('File'),
                              widget=forms.ClearableFileInput(
                                  attrs={'accept': 'file/*'}))
     file_url = forms.CharField(required=False, label=_('File URL'),
                                 widget=forms.TextInput(
                                     attrs={ATTRIBUTE_PLACEHOLDER:
                                                'http://example.com/image.png'}))
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
     threads = forms.CharField(required=False, label=_('Additional threads'),
             widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER:
                 '123 456 789'}))
 
+    guess = forms.CharField(widget=forms.HiddenInput(), required=False)
+    timestamp = forms.CharField(widget=forms.HiddenInput(), required=False)
+    iteration = forms.CharField(widget=forms.HiddenInput(), required=False)
+
     session = None
     need_to_ban = False
 
     def _update_file_extension(self, file):
         if file:
             mimetype = get_file_mimetype(file)
             extension = MIMETYPE_EXTENSIONS.get(mimetype)
             if extension:
                 filename = file.name.split(FILE_EXTENSION_DELIMITER, 1)[0]
                 new_filename = filename + FILE_EXTENSION_DELIMITER + extension
 
                 file.name = new_filename
             else:
                 logger = logging.getLogger('boards.forms.extension')
 
                 logger.info('Unrecognized file mimetype: {}'.format(mimetype))
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text'].strip()
         if text:
             max_length = board_settings.get_int('Forms', 'MaxTextLength')
             if len(text) > max_length:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') % str(max_length))
         return text
 
     def clean_file(self):
         file = self.cleaned_data['file']
 
         if file:
             validate_file_size(file.size)
         self._update_file_extension(file)
 
         return file
 
     def clean_file_url(self):
         url = self.cleaned_data['file_url']
 
         file = None
         if url:
             file = self._get_file_from_url(url)
 
             if not file:
                 raise forms.ValidationError(_('Invalid URL'))
             else:
                 validate_file_size(file.size)
         self._update_file_extension(file)
 
         return file
 
     def clean_threads(self):
         threads_str = self.cleaned_data['threads']
 
         if len(threads_str) > 0:
             threads_id_list = threads_str.split(' ')
 
             threads = list()
 
             for thread_id in threads_id_list:
                 try:
                     thread = Post.objects.get(id=int(thread_id))
-                    if not thread.is_opening() or thread.get_thread().archived:
+                    if not thread.is_opening() or thread.get_thread().is_archived():
                         raise ObjectDoesNotExist()
                     threads.append(thread)
                 except (ObjectDoesNotExist, ValueError):
                     raise forms.ValidationError(_('Invalid additional thread list'))
 
             return threads
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if cleaned_data['email']:
             self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_file()
 
-        if not self.errors and self.session:
-            self._validate_posting_speed()
+        limit_speed = board_settings.get_bool('Forms', 'LimitPostingSpeed')
+        if not self.errors and limit_speed:
+            pow_difficulty = board_settings.get_int('Forms', 'PowDifficulty')
+            if pow_difficulty > 0 and cleaned_data['timestamp'] and cleaned_data['iteration'] and cleaned_data['guess']:
+                self._validate_hash(cleaned_data['timestamp'], cleaned_data['iteration'], cleaned_data['guess'], cleaned_data['text'])
+            else:
+                self._validate_posting_speed()
 
         return cleaned_data
 
     def get_file(self):
         """
         Gets file from form or URL.
         """
 
         file = self.cleaned_data['file']
         return file or self.cleaned_data['file_url']
 
     def get_tripcode(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             code = title.split(TRIPCODE_DELIM, maxsplit=1)[1] + neboard.settings.SECRET_KEY
             tripcode = hashlib.md5(code.encode()).hexdigest()
         else:
             tripcode = ''
         return tripcode
 
     def get_title(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             return title.split(TRIPCODE_DELIM, maxsplit=1)[0]
         else:
             return title
 
     def _clean_text_file(self):
         text = self.cleaned_data.get('text')
         file = self.get_file()
 
         if (not text) and (not file):
             error_message = _('Either text or file must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         posting_delay = settings.POSTING_DELAY
 
         if board_settings.get_bool('Forms', 'LimitPostingSpeed'):
             now = time.time()
 
             current_delay = 0
 
             if LAST_POST_TIME not in self.session:
                 self.session[LAST_POST_TIME] = now
 
                 need_delay = True
             else:
                 last_post_time = self.session.get(LAST_POST_TIME)
                 current_delay = int(now - last_post_time)
 
                 need_delay = current_delay < posting_delay
 
             if need_delay:
                 delay = posting_delay - current_delay
                 error_message = ungettext_lazy(ERROR_SPEED, ERROR_SPEED_PLURAL,
                                                delay) % {'delay': delay}
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
             if can_post:
                 self.session[LAST_POST_TIME] = now
 
     def _get_file_from_url(self, url: str) -> SimpleUploadedFile:
         """
         Gets an file file from URL.
         """
 
         img_temp = None
 
         try:
             for downloader in Downloader.__subclasses__():
                 if downloader.handles(url):
                     return downloader.download(url)
             # If nobody of the specific downloaders handles this, use generic
             # one
             return Downloader.download(url)
         except forms.ValidationError as e:
             raise e
         except Exception as e:
-            # Just return no file
-            pass
+            raise forms.ValidationError(e)
+
+    def _validate_hash(self, timestamp: str, iteration: str, guess: str, message: str):
+        post_time = timezone.datetime.fromtimestamp(
+            int(timestamp[:-3]), tz=timezone.get_current_timezone())
+        timedelta = (timezone.now() - post_time).seconds / 60
+        if timedelta > POW_LIFE_MINUTES:
+            self._errors['text'] = self.error_class([_('Stale PoW.')])
+
+        payload = timestamp + message.replace('\r\n', '\n')
+        difficulty = board_settings.get_int('Forms', 'PowDifficulty')
+        target = str(int(2 ** (POW_HASH_LENGTH * 3) / difficulty))
+        if len(target) < POW_HASH_LENGTH:
+            target = '0' * (POW_HASH_LENGTH - len(target)) + target
+
+        computed_guess = hashlib.sha256((payload + iteration).encode())\
+                             .hexdigest()[0:POW_HASH_LENGTH]
+        if guess != computed_guess or guess > target:
+            self._errors['text'] = self.error_class(
+                [_('Invalid PoW.')])
 
 
 class ThreadForm(PostForm):
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
+    monochrome = forms.BooleanField(label=_('Monochrome'), required=False)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not REGEX_TAGS.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
         required_tag_exists = False
         tag_set = set()
         for tag_string in tags.split():
             tag, created = Tag.objects.get_or_create(name=tag_string.strip().lower())
             tag_set.add(tag)
 
             # If this is a new tag, don't check for its parents because nobody
             # added them yet
             if not created:
                 tag_set |= set(tag.get_all_parents())
 
         for tag in tag_set:
             if tag.required:
                 required_tag_exists = True
                 break
 
         if not required_tag_exists:
             raise forms.ValidationError(
                 _('Need at least one section.'))
 
         return tag_set
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
+    def is_monochrome(self):
+        return self.cleaned_data['monochrome']
+
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES, label=_('Theme'))
     image_viewer = forms.ChoiceField(choices=settings.IMAGE_VIEWERS, label=_('Image view mode'))
     username = forms.CharField(label=_('User name'), required=False)
     timezone = forms.ChoiceField(choices=get_timezones(), label=_('Time zone'))
 
     def clean_username(self):
         username = self.cleaned_data['username']
 
-        if username and not REGEX_TAGS.match(username):
+        if username and not REGEX_USERNAMES.match(username):
             raise forms.ValidationError(_('Inappropriate characters.'))
 
         return username
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)

boards/locale/ru/LC_MESSAGES/django.po

@@ -1,501 +1,532
 # SOME DESCRIPTIVE TITLE.
 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2015-10-09 23:21+0300\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
 "Language: ru\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 
 #: admin.py:22
 msgid "{} posters were banned"
 msgstr ""
 
 #: authors.py:9
 msgid "author"
 msgstr "автор"
 
 #: authors.py:10
 msgid "developer"
 msgstr "разработчик"
 
 #: authors.py:11
 msgid "javascript developer"
 msgstr "разработчик javascript"
 
 #: authors.py:12
 msgid "designer"
 msgstr "дизайнер"
 
 #: forms.py:30
 msgid "Type message here. Use formatting panel for more advanced usage."
 msgstr ""
 "Вводите сообщение сюда. Используйте панель для более сложного форматирования."
 
 #: forms.py:31
 msgid "music images i_dont_like_tags"
 msgstr "музыка картинки теги_не_нужны"
 
 #: forms.py:33
 msgid "Title"
 msgstr "Заголовок"
 
 #: forms.py:34
 msgid "Text"
 msgstr "Текст"
 
 #: forms.py:35
 msgid "Tag"
 msgstr "Метка"
 
 #: forms.py:36 templates/boards/base.html:40 templates/search/search.html:7
 msgid "Search"
 msgstr "Поиск"
 
 #: forms.py:139
 msgid "File"
 msgstr "Файл"
 
 #: forms.py:142
 msgid "File URL"
 msgstr "URL файла"
 
 #: forms.py:148
 msgid "e-mail"
 msgstr ""
 
 #: forms.py:151
 msgid "Additional threads"
 msgstr "Дополнительные темы"
 
 #: forms.py:162
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
 #: forms.py:172
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
 #: forms.py:192
 msgid "Invalid URL"
 msgstr "Неверный URL"
 
 #: forms.py:213
 msgid "Invalid additional thread list"
 msgstr "Неверный список дополнительных тем"
 
 #: forms.py:258
 msgid "Either text or file must be entered."
 msgstr "Текст или файл должны быть введены."
 
 #: forms.py:317 templates/boards/all_threads.html:153
 #: templates/boards/rss/post.html:10 templates/boards/tags.html:6
 msgid "Tags"
 msgstr "Метки"
 
 #: forms.py:324
 msgid "Inappropriate characters in tags."
 msgstr "Недопустимые символы в метках."
 
 #: forms.py:344
 msgid "Need at least one section."
 msgstr "Нужен хотя бы один раздел."
 
 #: forms.py:356
 msgid "Theme"
 msgstr "Тема"
 
 #: forms.py:357
 msgid "Image view mode"
 msgstr "Режим просмотра изображений"
 
 #: forms.py:358
 msgid "User name"
 msgstr "Имя пользователя"
 
 #: forms.py:359
 msgid "Time zone"
 msgstr "Часовой пояс"
 
 #: forms.py:365
 msgid "Inappropriate characters."
 msgstr "Недопустимые символы."
 
 #: templates/boards/404.html:6
 msgid "Not found"
 msgstr "Не найдено"
 
 #: templates/boards/404.html:12
 msgid "This page does not exist"
 msgstr "Этой страницы не существует"
 
 #: templates/boards/all_threads.html:35
-msgid "Related message"
-msgstr "Связанное сообщение"
+msgid "Details"
+msgstr "Подробности"
 
 #: templates/boards/all_threads.html:69
 msgid "Edit tag"
 msgstr "Изменить метку"
 
 #: templates/boards/all_threads.html:76
 #, python-format
 msgid "%(count)s active thread"
 msgid_plural "%(count)s active threads"
 msgstr[0] "%(count)s активная тема"
 msgstr[1] "%(count)s активные темы"
 msgstr[2] "%(count)s активных тем"
 
 #: templates/boards/all_threads.html:76
 #, python-format
 msgid "%(count)s thread in bumplimit"
 msgid_plural "%(count)s threads in bumplimit"
 msgstr[0] "%(count)s тема в бамплимите"
 msgstr[1] "%(count)s темы в бамплимите"
 msgstr[2] "%(count)s тем в бамплимите"
 
 #: templates/boards/all_threads.html:77
 #, python-format
 msgid "%(count)s archived thread"
 msgid_plural "%(count)s archived thread"
 msgstr[0] "%(count)s архивная тема"
 msgstr[1] "%(count)s архивные темы"
 msgstr[2] "%(count)s архивных тем"
 
 #: templates/boards/all_threads.html:78 templates/boards/post.html:102
 #, python-format
 #| msgid "%(count)s message"
 #| msgid_plural "%(count)s messages"
 msgid "%(count)s message"
 msgid_plural "%(count)s messages"
 msgstr[0] "%(count)s сообщение"
 msgstr[1] "%(count)s сообщения"
 msgstr[2] "%(count)s сообщений"
 
 #: templates/boards/all_threads.html:95 templates/boards/feed.html:30
 #: templates/boards/notifications.html:17 templates/search/search.html:26
 msgid "Previous page"
 msgstr "Предыдущая страница"
 
 #: templates/boards/all_threads.html:109
 #, python-format
 msgid "Skipped %(count)s reply. Open thread to see all replies."
 msgid_plural "Skipped %(count)s replies. Open thread to see all replies."
 msgstr[0] "Пропущен %(count)s ответ. Откройте тред, чтобы увидеть все ответы."
 msgstr[1] ""
 "Пропущено %(count)s ответа. Откройте тред, чтобы увидеть все ответы."
 msgstr[2] ""
 "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
 #: templates/boards/all_threads.html:127 templates/boards/feed.html:40
 #: templates/boards/notifications.html:27 templates/search/search.html:37
 msgid "Next page"
 msgstr "Следующая страница"
 
 #: templates/boards/all_threads.html:132
 msgid "No threads exist. Create the first one!"
 msgstr "Нет тем. Создайте первую!"
 
 #: templates/boards/all_threads.html:138
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
 #: templates/boards/all_threads.html:143 templates/boards/preview.html:16
 #: templates/boards/thread_normal.html:51
 msgid "Post"
 msgstr "Отправить"
 
 #: templates/boards/all_threads.html:144 templates/boards/preview.html:6
 #: templates/boards/staticpages/help.html:21
 #: templates/boards/thread_normal.html:52
 msgid "Preview"
 msgstr "Предпросмотр"
 
 #: templates/boards/all_threads.html:149
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
 "Метки должны быть разделены пробелами. Текст или изображение обязательны."
 
 #: templates/boards/all_threads.html:152 templates/boards/thread_normal.html:58
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
 #: templates/boards/all_threads.html:166 templates/boards/feed.html:53
 msgid "Pages:"
 msgstr "Страницы: "
 
 #: templates/boards/authors.html:6 templates/boards/authors.html.py:12
 msgid "Authors"
 msgstr "Авторы"
 
 #: templates/boards/authors.html:26
 msgid "Distributed under the"
 msgstr "Распространяется под"
 
 #: templates/boards/authors.html:28
 msgid "license"
 msgstr "лицензией"
 
 #: templates/boards/authors.html:30
 msgid "Repository"
 msgstr "Репозиторий"
 
 #: templates/boards/base.html:14 templates/boards/base.html.py:41
 msgid "Feed"
 msgstr "Лента"
 
 #: templates/boards/base.html:31
 msgid "All threads"
 msgstr "Все темы"
 
 #: templates/boards/base.html:37
 msgid "Add tags"
 msgstr "Добавить метки"
 
 #: templates/boards/base.html:39
 msgid "Tag management"
 msgstr "Управление метками"
 
 #: templates/boards/base.html:39
 msgid "tags"
 msgstr "метки"
 
 #: templates/boards/base.html:40
 msgid "search"
 msgstr "поиск"
 
 #: templates/boards/base.html:41 templates/boards/feed.html:11
 msgid "feed"
 msgstr "лента"
 
 #: templates/boards/base.html:42 templates/boards/random.html:6
 msgid "Random images"
 msgstr "Случайные изображения"
 
 #: templates/boards/base.html:42
 msgid "random"
 msgstr "случайные"
 
 #: templates/boards/base.html:44
 msgid "favorites"
 msgstr "избранное"
 
 #: templates/boards/base.html:48 templates/boards/base.html.py:49
 #: templates/boards/notifications.html:8
 msgid "Notifications"
 msgstr "Уведомления"
 
 #: templates/boards/base.html:56 templates/boards/settings.html:8
 msgid "Settings"
 msgstr "Настройки"
 
 #: templates/boards/base.html:59
 msgid "Loading..."
 msgstr "Загрузка..."
 
 #: templates/boards/base.html:71
 msgid "Admin"
 msgstr "Администрирование"
 
 #: templates/boards/base.html:73
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
 #: templates/boards/base.html:75
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/feed.html:45
 msgid "No posts exist. Create the first one!"
 msgstr "Нет сообщений. Создайте первое!"
 
 #: templates/boards/post.html:33
 msgid "Open"
 msgstr "Открыть"
 
 #: templates/boards/post.html:35 templates/boards/post.html.py:46
 msgid "Reply"
 msgstr "Ответить"
 
 #: templates/boards/post.html:41
 msgid " in "
 msgstr " в "
 
 #: templates/boards/post.html:51
 msgid "Edit"
 msgstr "Изменить"
 
 #: templates/boards/post.html:53
 msgid "Edit thread"
 msgstr "Изменить тему"
 
 #: templates/boards/post.html:91
 msgid "Replies"
 msgstr "Ответы"
 
 #: templates/boards/post.html:103
 #, python-format
 msgid "%(count)s image"
 msgid_plural "%(count)s images"
 msgstr[0] "%(count)s изображение"
 msgstr[1] "%(count)s изображения"
 msgstr[2] "%(count)s изображений"
 
 #: templates/boards/rss/post.html:5
 msgid "Post image"
 msgstr "Изображение сообщения"
 
 #: templates/boards/settings.html:15
 msgid "You are moderator."
 msgstr "Вы модератор."
 
 #: templates/boards/settings.html:19
 msgid "Hidden tags:"
 msgstr "Скрытые метки:"
 
 #: templates/boards/settings.html:25
 msgid "No hidden tags."
 msgstr "Нет скрытых меток."
 
 #: templates/boards/settings.html:34
 msgid "Save"
 msgstr "Сохранить"
 
 #: templates/boards/staticpages/banned.html:6
 msgid "Banned"
 msgstr "Заблокирован"
 
 #: templates/boards/staticpages/banned.html:11
 msgid "Your IP address has been banned. Contact the administrator"
 msgstr "Ваш IP адрес был заблокирован. Свяжитесь с администратором"
 
 #: templates/boards/staticpages/help.html:6
 #: templates/boards/staticpages/help.html:10
 msgid "Syntax"
 msgstr "Синтаксис"
 
 #: templates/boards/staticpages/help.html:11
 msgid "Italic text"
 msgstr "Курсивный текст"
 
 #: templates/boards/staticpages/help.html:12
 msgid "Bold text"
 msgstr "Полужирный текст"
 
 #: templates/boards/staticpages/help.html:13
 msgid "Spoiler"
 msgstr "Спойлер"
 
 #: templates/boards/staticpages/help.html:14
 msgid "Link to a post"
 msgstr "Ссылка на сообщение"
 
 #: templates/boards/staticpages/help.html:15
 msgid "Strikethrough text"
 msgstr "Зачеркнутый текст"
 
 #: templates/boards/staticpages/help.html:16
 msgid "Comment"
 msgstr "Комментарий"
 
 #: templates/boards/staticpages/help.html:17
 #: templates/boards/staticpages/help.html:18
 msgid "Quote"
 msgstr "Цитата"
 
 #: templates/boards/staticpages/help.html:21
 msgid "You can try pasting the text and previewing the result here:"
 msgstr "Вы можете попробовать вставить текст и проверить результат здесь:"
 
 #: templates/boards/tags.html:17
 msgid "Sections:"
 msgstr "Разделы:"
 
 #: templates/boards/tags.html:30
 msgid "Other tags:"
 msgstr "Другие метки:"
 
 #: templates/boards/tags.html:43
 msgid "All tags..."
 msgstr "Все метки..."
 
 #: templates/boards/thread.html:14
 msgid "Normal"
 msgstr "Нормальный"
 
 #: templates/boards/thread.html:15
 msgid "Gallery"
 msgstr "Галерея"
 
 #: templates/boards/thread.html:16
 msgid "Tree"
 msgstr "Дерево"
 
 #: templates/boards/thread.html:35
 msgid "message"
 msgid_plural "messages"
 msgstr[0] "сообщение"
 msgstr[1] "сообщения"
 msgstr[2] "сообщений"
 
 #: templates/boards/thread.html:38
 msgid "image"
 msgid_plural "images"
 msgstr[0] "изображение"
 msgstr[1] "изображения"
 msgstr[2] "изображений"
 
 #: templates/boards/thread.html:40
 msgid "Last update: "
 msgstr "Последнее обновление: "
 
 #: templates/boards/thread_gallery.html:36
 msgid "No images."
 msgstr "Нет изображений."
 
 #: templates/boards/thread_normal.html:30
 msgid "posts to bumplimit"
 msgstr "сообщений до бамплимита"
 
 #: templates/boards/thread_normal.html:44
 msgid "Reply to thread"
 msgstr "Ответить в тему"
 
 #: templates/boards/thread_normal.html:44
 msgid "to message "
 msgstr "на сообщение"
 
 #: templates/boards/thread_normal.html:59
 msgid "Close form"
 msgstr "Закрыть форму"
 
 #: templates/search/search.html:17
 msgid "Ok"
 msgstr "Ок"
 
 #: utils.py:120
 #, python-format
-msgid "File must be less than %s bytes"
-msgstr "Файл должен быть менее %s байт"
+msgid "File must be less than %s but is %s."
+msgstr "Файл должен быть менее %s, но его размер %s."
 
 msgid "Please wait %(delay)d second before sending message"
 msgid_plural "Please wait %(delay)d seconds before sending message"
 msgstr[0] "Пожалуйста подождите %(delay)d секунду перед отправкой сообщения"
 msgstr[1] "Пожалуйста подождите %(delay)d секунды перед отправкой сообщения"
 msgstr[2] "Пожалуйста подождите %(delay)d секунд перед отправкой сообщения"
 
 msgid "New threads"
 msgstr "Новые темы"
+
+#, python-format
+msgid "Max file size is %(size)s."
+msgstr "Максимальный размер файла %(size)s."
+
+msgid "Size of media:"
+msgstr "Размер медиа:"
+
+msgid "Statistics"
+msgstr "Статистика"
+
+msgid "Invalid PoW."
+msgstr "Неверный PoW."
+
+msgid "Stale PoW."
+msgstr "PoW устарел."
+
+msgid "Show"
+msgstr "Показывать"
+
+msgid "Hide"
+msgstr "Скрывать"
+
+msgid "Add to favorites"
+msgstr "Добавить в избранное"
+
+msgid "Remove from favorites"
+msgstr "Убрать из избранного"
+
+msgid "Monochrome"
+msgstr "Монохромный"
  No newline at end of file

boards/locale/ru/LC_MESSAGES/djangojs.po

@@ -1,55 +1,57
 # SOME DESCRIPTIVE TITLE.
 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2015-09-04 18:47+0300\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
 "Language: \n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 
 #: static/js/3party/jquery-ui.min.js:8
 msgid "'"
 msgstr ""
 
 #: static/js/refpopup.js:72
 msgid "Loading..."
 msgstr "Загрузка..."
 
 #: static/js/refpopup.js:91
 msgid "Post not found"
 msgstr "Сообщение не найдено"
 
 #: static/js/thread_update.js:261
 msgid "message"
 msgid_plural "messages"
 msgstr[0] "сообщение"
 msgstr[1] "сообщения"
 msgstr[2] "сообщений"
 
 #: static/js/thread_update.js:262
 msgid "image"
 msgid_plural "images"
 msgstr[0] "изображение"
 msgstr[1] "изображения"
 msgstr[2] "изображений"
 
 #: static/js/thread_update.js:445
 msgid "Sending message..."
 msgstr "Отправка сообщения..."
 
 #: static/js/thread_update.js:449
 msgid "Server error!"
 msgstr "Ошибка сервера!"
 
+msgid "Computing PoW..."
+msgstr "Расчёт PoW..."
  No newline at end of file

boards/management/commands/cleantags.py

@@ -1,19 +1,19
 from django.core.management import BaseCommand
 from django.db import transaction
 from django.db.models import Count
 
 from boards.models import Tag
 
 
 __author__ = 'neko259'
 
 
 class Command(BaseCommand):
     help = 'Removed tags that have no threads'
 
     @transaction.atomic
     def handle(self, *args, **options):
-        empty = Tag.objects.annotate(num_threads=Count('thread'))\
+        empty = Tag.objects.annotate(num_threads=Count('thread_tags'))\
                 .filter(num_threads=0).order_by('-required', 'name')
         print('Removing {} empty tags'.format(empty.count()))
         empty.delete()

boards/mdx_neboard.py

@@ -1,230 +1,232
 # coding=utf-8
 
 import re
 import bbcode
 
 from urllib.parse import unquote
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 
 import boards
 
 
 __author__ = 'neko259'
 
 
 REFLINK_PATTERN = re.compile(r'^\d+$')
 MULTI_NEWLINES_PATTERN = re.compile(r'(\r?\n){2,}')
 ONE_NEWLINE = '\n'
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 LINE_BREAK_HTML = '<div class="br"></div>'
 
 
 class TextFormatter():
     """
     An interface for formatter that can be used in the text format panel
     """
 
     def __init__(self):
         pass
 
     name = ''
 
     # Left and right tags for the button preview
     preview_left = ''
     preview_right = ''
 
     # Left and right characters for the textarea input
     format_left = ''
     format_right = ''
 
 
 class AutolinkPattern():
     def handleMatch(self, m):
         link_element = etree.Element('a')
         href = m.group(2)
         link_element.set('href', href)
         link_element.text = href
 
         return link_element
 
 
 class QuotePattern(TextFormatter):
     name = '>q'
     preview_left = '<span class="quote">'
     preview_right = '</span>'
 
     format_left = '[quote]'
     format_right = '[/quote]'
 
 
 class SpoilerPattern(TextFormatter):
     name = 'spoiler'
     preview_left = '<span class="spoiler">'
     preview_right = '</span>'
 
     format_left = '[spoiler]'
     format_right = '[/spoiler]'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'spoiler')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class CommentPattern(TextFormatter):
     name = ''
     preview_left = '<span class="comment">// '
     preview_right = '</span>'
 
     format_left = '[comment]'
     format_right = '[/comment]'
 
 
 # TODO Use <s> tag here
 class StrikeThroughPattern(TextFormatter):
     name = 's'
     preview_left = '<span class="strikethrough">'
     preview_right = '</span>'
 
     format_left = '[s]'
     format_right = '[/s]'
 
 
 class ItalicPattern(TextFormatter):
     name = 'i'
     preview_left = '<i>'
     preview_right = '</i>'
 
     format_left = '[i]'
     format_right = '[/i]'
 
 
 class BoldPattern(TextFormatter):
     name = 'b'
     preview_left = '<b>'
     preview_right = '</b>'
 
     format_left = '[b]'
     format_right = '[/b]'
 
 
 class CodePattern(TextFormatter):
     name = 'code'
     preview_left = '<code>'
     preview_right = '</code>'
 
     format_left = '[code]'
     format_right = '[/code]'
 
 
 def render_reflink(tag_name, value, options, parent, context):
     result = '>>%s' % value
 
     if REFLINK_PATTERN.match(value):
         post_id = int(value)
 
         try:
             post = boards.models.Post.objects.get(id=post_id)
 
             result = post.get_link_view()
         except ObjectDoesNotExist:
             pass
 
     return result
 
 
 def render_quote(tag_name, value, options, parent, context):
     source = ''
     if 'source' in options:
         source = options['source']
+    elif 'quote' in options:
+        source = options['quote']
 
     if source:
         result = '<div class="multiquote"><div class="quote-header">%s</div><div class="quote-text">%s</div></div>' % (source, value)
     else:
         # Insert a ">" at the start of every line
         result = '<span class="quote">&gt;{}</span>'.format(
                 value.replace(LINE_BREAK_HTML,
                     '{}&gt;'.format(LINE_BREAK_HTML)))
 
     return result
 
 
 def render_notification(tag_name, value, options, parent, content):
     username = value.lower()
 
     return '<a href="{}" class="user-cast">@{}</a>'.format(
         reverse('notifications', kwargs={'username': username}), username)
 
 
 def render_tag(tag_name, value, options, parent, context):
     tag_name = value.lower()
 
     try:
         url = boards.models.Tag.objects.get(name=tag_name).get_view()
     except ObjectDoesNotExist:
         url = tag_name
 
     return url
 
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
 ]
 
 
 PREPARSE_PATTERNS = {
     r'(?<!>)>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
     r'^>([^>].+)': r'[quote]\1[/quote]',  # Quote ">text"
     r'^//(.+)': r'[comment]\1[/comment]',  # Comment "//text"
     r'\B@(\w+)': r'[user]\1[/user]',  # User notification "@user"
 }
 
 
 class Parser:
     def __init__(self):
         # The newline hack is added because br's margin does not work in all
         # browsers except firefox, when the div's does.
         self.parser = bbcode.Parser(newline=LINE_BREAK_HTML)
 
         self.parser.add_formatter('post', render_reflink, strip=True)
         self.parser.add_formatter('quote', render_quote, strip=True)
         self.parser.add_formatter('user', render_notification, strip=True)
         self.parser.add_formatter('tag', render_tag, strip=True)
         self.parser.add_simple_formatter(
             'comment', '<span class="comment">//%(value)s</span>')
         self.parser.add_simple_formatter(
             'spoiler', '<span class="spoiler">%(value)s</span>')
         self.parser.add_simple_formatter(
             's', '<span class="strikethrough">%(value)s</span>')
         # TODO Why not use built-in tag?
         self.parser.add_simple_formatter('code',
                                          '<pre><code>%(value)s</pre></code>',
                                          render_embedded=False)
 
     def preparse(self, text):
         """
         Performs manual parsing before the bbcode parser is used.
         Preparsed text is saved as raw and the text before preparsing is lost.
         """
         new_text = MULTI_NEWLINES_PATTERN.sub(ONE_NEWLINE, text)
 
         for key, value in PREPARSE_PATTERNS.items():
             new_text = re.sub(key, value, new_text, flags=re.MULTILINE)
 
         for link in REGEX_URL.findall(text):
             new_text = new_text.replace(link, unquote(link))
 
         return new_text
 
     def parse(self, text):
         return self.parser.format(text)

boards/models/__init__.py

@@ -1,11 +1,14
-__author__ = 'neko259'
+STATUS_ACTIVE = 'active'
+STATUS_BUMPLIMIT = 'bumplimit'
+STATUS_ARCHIVE = 'archived'
+
 
 from boards.models.signature import GlobalId, Signature
 from boards.models.sync_key import KeyPair
 from boards.models.image import PostImage
 from boards.models.attachment import Attachment
 from boards.models.thread import Thread
 from boards.models.post import Post
 from boards.models.tag import Tag
 from boards.models.user import Ban
 from boards.models.banner import Banner

boards/models/attachment/__init__.py

@@ -1,41 +1,42
 from django.db import models
 
 from boards import utils
 from boards.models.attachment.viewers import get_viewers, AbstractViewer
 from boards.utils import get_upload_filename, get_file_mimetype, get_extension
 
 
 class AttachmentManager(models.Manager):
     def create_with_hash(self, file):
         file_hash = utils.get_file_hash(file)
         existing = self.filter(hash=file_hash)
         if len(existing) > 0:
             attachment = existing[0]
         else:
             # FIXME Use full mimetype here, need to modify viewers too
             file_type = get_extension(file.name)
             attachment = self.create(file=file, mimetype=file_type,
                                      hash=file_hash)
 
         return attachment
 
 
 class Attachment(models.Model):
     objects = AttachmentManager()
 
     file = models.FileField(upload_to=get_upload_filename)
     mimetype = models.CharField(max_length=50)
     hash = models.CharField(max_length=36)
 
     def get_view(self):
         file_viewer = None
         for viewer in get_viewers():
             if viewer.supports(self.mimetype):
                 file_viewer = viewer
                 break
         if file_viewer is None:
             file_viewer = AbstractViewer
 
         return file_viewer(self.file, self.mimetype).get_view()
 
-
+    def __str__(self):
+        return self.file.url

boards/models/attachment/downloaders.py

@@ -1,66 +1,69
 import os
 import re
 
-from django.core.files.uploadedfile import SimpleUploadedFile
+from django.core.files.uploadedfile import SimpleUploadedFile, \
+    TemporaryUploadedFile
 from pytube import YouTube
 import requests
 
 from boards.utils import validate_file_size
 
 YOUTUBE_VIDEO_FORMAT = 'webm'
 
 HTTP_RESULT_OK = 200
 
 HEADER_CONTENT_LENGTH = 'content-length'
 HEADER_CONTENT_TYPE = 'content-type'
 
-FILE_DOWNLOAD_CHUNK_BYTES = 100000
+FILE_DOWNLOAD_CHUNK_BYTES = 200000
 
-YOUTUBE_URL = re.compile(r'https?://www\.youtube\.com/watch\?v=\w+')
+YOUTUBE_URL = re.compile(r'https?://(www\.youtube\.com/watch\?v=|youtu.be/)\w+')
 
 
 class Downloader:
     @staticmethod
     def handles(url: str) -> bool:
         return False
 
     @staticmethod
     def download(url: str):
         # Verify content headers
         response_head = requests.head(url, verify=False)
         content_type = response_head.headers[HEADER_CONTENT_TYPE].split(';')[0]
         length_header = response_head.headers.get(HEADER_CONTENT_LENGTH)
         if length_header:
             length = int(length_header)
             validate_file_size(length)
         # Get the actual content into memory
         response = requests.get(url, verify=False, stream=True)
 
         # Download file, stop if the size exceeds limit
         size = 0
-        content = b''
+
+        # Set a dummy file name that will be replaced
+        # anyway, just keep the valid extension
+        filename = 'file.' + content_type.split('/')[1]
+
+        file = TemporaryUploadedFile(filename, content_type, 0, None, None)
         for chunk in response.iter_content(FILE_DOWNLOAD_CHUNK_BYTES):
             size += len(chunk)
             validate_file_size(size)
-            content += chunk
+            file.write(chunk)
 
-        if response.status_code == HTTP_RESULT_OK and content:
-            # Set a dummy file name that will be replaced
-            # anyway, just keep the valid extension
-            filename = 'file.' + content_type.split('/')[1]
-            return SimpleUploadedFile(filename, content, content_type)
+        if response.status_code == HTTP_RESULT_OK:
+            return file
 
 
 class YouTubeDownloader(Downloader):
     @staticmethod
     def download(url: str):
         yt = YouTube()
         yt.from_url(url)
         videos = yt.filter(YOUTUBE_VIDEO_FORMAT)
         if len(videos) > 0:
             video = videos[0]
             return Downloader.download(video.url)
 
     @staticmethod
     def handles(url: str) -> bool:
         return YOUTUBE_URL.match(url)

boards/models/banner.py

@@ -1,10 +1,13
 from django.db import models
 
 
 class Banner(models.Model):
     title = models.TextField()
-    text = models.TextField()
+    text = models.TextField(blank=True, null=True)
     post = models.ForeignKey('Post')
 
     def __str__(self):
         return self.title
+
+    def get_text(self) -> str:
+        return self.text or self.post.get_text()

boards/models/image.py

@@ -1,95 +1,97
 from django.db import models
 from django.template.defaultfilters import filesizeformat
 
 from boards import thumbs, utils
 import boards
 from boards.models.base import Viewable
+from boards.models import STATUS_ARCHIVE
 from boards.utils import get_upload_filename
 
+
 __author__ = 'neko259'
 
 
 IMAGE_THUMB_SIZE = (200, 150)
 HASH_LENGTH = 36
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 
 class PostImageManager(models.Manager):
     def create_with_hash(self, image):
         image_hash = utils.get_file_hash(image)
         existing = self.filter(hash=image_hash)
         if len(existing) > 0:
             post_image = existing[0]
         else:
             post_image = PostImage.objects.create(image=image)
 
         return post_image
 
-    def get_random_images(self, count, include_archived=False, tags=None):
-        images = self.filter(post_images__thread__archived=include_archived)
+    def get_random_images(self, count, tags=None):
+        images = self.exclude(post_images__thread__status=STATUS_ARCHIVE)
         if tags is not None:
             images = images.filter(post_images__threads__tags__in=tags)
         return images.order_by('?')[:count]
 
 
 class PostImage(models.Model, Viewable):
     objects = PostImageManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('id',)
 
     width = models.IntegerField(default=0)
     height = models.IntegerField(default=0)
 
     pre_width = models.IntegerField(default=0)
     pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=get_upload_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='width',
                                         height_field='height',
                                         preview_width_field='pre_width',
                                         preview_height_field='pre_height')
     hash = models.CharField(max_length=HASH_LENGTH)
 
     def save(self, *args, **kwargs):
         """
         Saves the model and computes the image hash for deduplication purposes.
         """
 
         if not self.pk and self.image:
             self.hash = utils.get_file_hash(self.image)
         super(PostImage, self).save(*args, **kwargs)
 
     def __str__(self):
         return self.image.url
 
     def get_view(self):
         metadata = '{}, {}'.format(self.image.name.split('.')[-1],
                                    filesizeformat(self.image.size))
         return '<div class="{}">' \
                '<a class="{}" href="{full}">' \
                '<img class="post-image-preview"' \
                ' src="{}"' \
                ' alt="{}"' \
                ' width="{}"' \
                ' height="{}"' \
                ' data-width="{}"' \
                ' data-height="{}" />' \
                '</a>' \
                '<div class="image-metadata">'\
                '<a href="{full}" download>{image_meta}</a>'\
                '</div>' \
                '</div>'\
             .format(CSS_CLASS_IMAGE, CSS_CLASS_THUMB,
                     self.image.url_200x150,
                     str(self.hash), str(self.pre_width),
                     str(self.pre_height), str(self.width), str(self.height),
                     full=self.image.url, image_meta=metadata)
 
     def get_random_associated_post(self):
         posts = boards.models.Post.objects.filter(images__in=[self])
         return posts.order_by('?').first()

boards/models/post/__init__.py

@@ -1,436 +1,447
 import logging
 import re
 import uuid
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.db import models
 from django.db.models import TextField, QuerySet
 from django.template.defaultfilters import truncatewords, striptags
 from django.template.loader import render_to_string
 from django.utils import timezone
 
 from boards import settings
 from boards.abstracts.tripcode import Tripcode
 from boards.mdx_neboard import Parser
 from boards.models import PostImage, Attachment, KeyPair, GlobalId
 from boards.models.base import Viewable
 from boards.models.post.export import get_exporter, DIFF_TYPE_JSON
 from boards.models.post.manager import PostManager
 from boards.models.user import Notification
 
 CSS_CLS_HIDDEN_POST = 'hidden_post'
 CSS_CLS_DEAD_POST = 'dead_post'
 CSS_CLS_ARCHIVE_POST = 'archive_post'
 CSS_CLS_POST = 'post'
+CSS_CLS_MONOCHROME = 'monochrome'
 
 TITLE_MAX_WORDS = 10
 
 APP_LABEL_BOARDS = 'boards'
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 REGEX_GLOBAL_REPLY = re.compile(r'\[post\](\w+)::([^:]+)::(\d+)\[/post\]')
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 REGEX_NOTIFICATION = re.compile(r'\[user\](\w+)\[/user\]')
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_CSS_CLASS = 'css_class'
 PARAMETER_THREAD = 'thread'
 PARAMETER_IS_OPENING = 'is_opening'
-PARAMETER_MODERATOR = 'moderator'
 PARAMETER_POST = 'post'
 PARAMETER_OP_ID = 'opening_post_id'
 PARAMETER_NEED_OPEN_LINK = 'need_open_link'
 PARAMETER_REPLY_LINK = 'reply_link'
 PARAMETER_NEED_OP_DATA = 'need_op_data'
 
 POST_VIEW_PARAMS = (
     'need_op_data',
     'reply_link',
-    'moderator',
     'need_open_link',
     'truncated',
     'mode_tree',
+    'perms',
 )
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH, null=True, blank=True)
     pub_time = models.DateTimeField()
     text = TextField(blank=True, null=True)
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
                                     related_name='post_images', db_index=True)
     attachments = models.ManyToManyField(Attachment, null=True, blank=True,
                                          related_name='attachment_posts')
 
     poster_ip = models.GenericIPAddressField()
 
     # TODO This field can be removed cause UID is used for update now
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='refposts',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
     threads = models.ManyToManyField('Thread', db_index=True,
                                      related_name='multi_replies')
     thread = models.ForeignKey('Thread', db_index=True, related_name='pt+')
 
     url = models.TextField()
     uid = models.TextField(db_index=True)
 
     # Global ID with author key. If the message was downloaded from another
     # server, this indicates the server.
     global_id = models.OneToOneField('GlobalId', null=True, blank=True)
 
     tripcode = models.CharField(max_length=50, blank=True, default='')
     opening = models.BooleanField(db_index=True)
     hidden = models.BooleanField(default=False)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.get_title())
 
     def get_referenced_posts(self):
         threads = self.get_threads().all()
         return self.referenced_posts.filter(threads__in=threads)\
             .order_by('pub_time').distinct().all()
 
     def get_title(self) -> str:
         return self.title
 
     def get_title_or_text(self):
         title = self.get_title()
         if not title:
             title = truncatewords(striptags(self.get_text()), TITLE_MAX_WORDS)
 
         return title
 
     def build_refmap(self) -> None:
         """
         Builds a replies map string from replies list. This is a cache to stop
         the server from recalculating the map on every post show.
         """
 
         post_urls = [refpost.get_link_view()
                      for refpost in self.referenced_posts.all()]
 
         self.refmap = ', '.join(post_urls)
 
     def is_referenced(self) -> bool:
         return self.refmap and len(self.refmap) > 0
 
     def is_opening(self) -> bool:
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.opening
 
     def get_absolute_url(self, thread=None):
         url = None
 
         if thread is None:
             thread = self.get_thread()
 
             # Url is cached only for the "main" thread. When getting url
             # for other threads, do it manually.
             if self.url:
                 url = self.url
 
         if url is None:
             opening_id = thread.get_opening_post_id()
             url = reverse('thread', kwargs={'post_id': opening_id})
             if self.id != opening_id:
                 url += '#' + str(self.id)
 
         return url
 
     def get_thread(self):
         return self.thread
 
     def get_threads(self) -> QuerySet:
         """
         Gets post's thread.
         """
 
         return self.threads
 
     def get_view(self, *args, **kwargs) -> str:
         """
         Renders post's HTML view. Some of the post params can be passed over
         kwargs for the means of caching (if we view the thread, some params
         are same for every post and don't need to be computed over and over.
         """
 
         thread = self.get_thread()
 
         css_classes = [CSS_CLS_POST]
-        if thread.archived:
+        if thread.is_archived():
             css_classes.append(CSS_CLS_ARCHIVE_POST)
         elif not thread.can_bump():
             css_classes.append(CSS_CLS_DEAD_POST)
         if self.is_hidden():
             css_classes.append(CSS_CLS_HIDDEN_POST)
+        if thread.is_monochrome():
+            css_classes.append(CSS_CLS_MONOCHROME)
 
         params = dict()
         for param in POST_VIEW_PARAMS:
             if param in kwargs:
                 params[param] = kwargs[param]
 
         params.update({
             PARAMETER_POST: self,
             PARAMETER_IS_OPENING: self.is_opening(),
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: ' '.join(css_classes),
         })
 
         return render_to_string('boards/post.html', params)
 
     def get_search_view(self, *args, **kwargs):
         return self.get_view(need_op_data=True, *args, **kwargs)
 
     def get_first_image(self) -> PostImage:
         return self.images.earliest('id')
 
     def delete(self, using=None):
         """
         Deletes all post images and the post itself.
         """
 
         for image in self.images.all():
             image_refs_count = image.post_images.count()
             if image_refs_count == 1:
                 image.delete()
 
         for attachment in self.attachments.all():
             attachment_refs_count = attachment.attachment_posts.count()
             if attachment_refs_count == 1:
                 attachment.delete()
 
         if self.global_id:
             self.global_id.delete()
 
         thread = self.get_thread()
         thread.last_edit_time = timezone.now()
         thread.save()
 
         super(Post, self).delete(using)
 
         logging.getLogger('boards.post.delete').info(
             'Deleted post {}'.format(self))
 
     def set_global_id(self, key_pair=None):
         """
         Sets global id based on the given key pair. If no key pair is given,
         default one is used.
         """
 
         if key_pair:
             key = key_pair
         else:
             try:
                 key = KeyPair.objects.get(primary=True)
             except KeyPair.DoesNotExist:
                 # Do not update the global id because there is no key defined
                 return
         global_id = GlobalId(key_type=key.key_type,
                              key=key.public_key,
                              local_id=self.id)
         global_id.save()
 
         self.global_id = global_id
 
         self.save(update_fields=['global_id'])
 
     def get_pub_time_str(self):
         return str(self.pub_time)
 
     def get_replied_ids(self):
         """
         Gets ID list of the posts that this post replies.
         """
 
         raw_text = self.get_raw_text()
 
         local_replied = REGEX_REPLY.findall(raw_text)
         global_replied = []
         for match in REGEX_GLOBAL_REPLY.findall(raw_text):
             key_type = match[0]
             key = match[1]
             local_id = match[2]
 
             try:
                 global_id = GlobalId.objects.get(key_type=key_type,
                                                  key=key, local_id=local_id)
                 for post in Post.objects.filter(global_id=global_id).only('id'):
                     global_replied.append(post.id)
             except GlobalId.DoesNotExist:
                 pass
         return local_replied + global_replied
 
     def get_post_data(self, format_type=DIFF_TYPE_JSON, request=None,
                       include_last_update=False) -> str:
         """
         Gets post HTML or JSON data that can be rendered on a page or used by
         API.
         """
 
         return get_exporter(format_type).export(self, request,
                                                 include_last_update)
 
     def notify_clients(self, recursive=True):
         """
         Sends post HTML data to the thread web socket.
         """
 
         if not settings.get_bool('External', 'WebsocketsEnabled'):
             return
 
         thread_ids = list()
         for thread in self.get_threads().all():
             thread_ids.append(thread.id)
 
             thread.notify_clients()
 
         if recursive:
             for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
                 post_id = reply_number.group(1)
 
                 try:
                     ref_post = Post.objects.get(id=post_id)
 
                     if ref_post.get_threads().exclude(id__in=thread_ids).exists():
                         # If post is in this thread, its thread was already notified.
                         # Otherwise, notify its thread separately.
                         ref_post.notify_clients(recursive=False)
                 except ObjectDoesNotExist:
                     pass
 
     def build_url(self):
         self.url = self.get_absolute_url()
         self.save(update_fields=['url'])
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
+        new_post = self.id is None
+
         self._text_rendered = Parser().parse(self.get_raw_text())
 
         self.uid = str(uuid.uuid4())
         if update_fields is not None and 'uid' not in update_fields:
             update_fields += ['uid']
 
-        if self.id:
+        if not new_post:
             for thread in self.get_threads().all():
                 thread.last_edit_time = self.last_edit_time
 
-                thread.save(update_fields=['last_edit_time', 'bumpable'])
+                thread.save(update_fields=['last_edit_time', 'status'])
 
         super().save(force_insert, force_update, using, update_fields)
 
+        # Post save triggers
+        if new_post:
+            self.build_url()
+
+        self._connect_replies()
+        self._connect_notifications()
+
     def get_text(self) -> str:
         return self._text_rendered
 
     def get_raw_text(self) -> str:
         return self.text
 
     def get_sync_text(self) -> str:
         """
         Returns text applicable for sync. It has absolute post reflinks.
         """
 
         replacements = dict()
         for post_id in REGEX_REPLY.findall(self.get_raw_text()):
             absolute_post_id = str(Post.objects.get(id=post_id).global_id)
             replacements[post_id] = absolute_post_id
 
         text = self.get_raw_text()
         for key in replacements:
             text = text.replace('[post]{}[/post]'.format(key),
                                 '[post]{}[/post]'.format(replacements[key]))
 
         return text
 
     def get_absolute_id(self) -> str:
         """
         If the post has many threads, shows its main thread OP id in the post
         ID.
         """
 
         if self.get_threads().count() > 1:
             return '{}/{}'.format(self.get_thread().get_opening_post_id(), self.id)
         else:
             return str(self.id)
 
-    def connect_notifications(self):
+    def _connect_notifications(self):
         for reply_number in re.finditer(REGEX_NOTIFICATION, self.get_raw_text()):
             user_name = reply_number.group(1).lower()
             Notification.objects.get_or_create(name=user_name, post=self)
 
-    def connect_replies(self):
+    def _connect_replies(self):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
             post_id = reply_number.group(1)
 
             try:
                 referenced_post = Post.objects.get(id=post_id)
 
                 referenced_post.referenced_posts.add(self)
                 referenced_post.last_edit_time = self.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
             except ObjectDoesNotExist:
                 pass
 
     def connect_threads(self, opening_posts):
         for opening_post in opening_posts:
             threads = opening_post.get_threads().all()
             for thread in threads:
                 if thread.can_bump():
                     thread.update_bump_status()
 
                 thread.last_edit_time = self.last_edit_time
-                thread.save(update_fields=['last_edit_time', 'bumpable'])
+                thread.save(update_fields=['last_edit_time', 'status'])
             self.threads.add(opening_post.get_thread())
 
     def get_tripcode(self):
         if self.tripcode:
             return Tripcode(self.tripcode)
 
     def get_link_view(self):
         """
         Gets view of a reflink to the post.
         """
         result = '<a href="{}">&gt;&gt;{}</a>'.format(self.get_absolute_url(),
                                                       self.id)
         if self.is_opening():
             result = '<b>{}</b>'.format(result)
 
         return result
 
     def is_hidden(self) -> bool:
         return self.hidden
 
     def set_hidden(self, hidden):
         self.hidden = hidden

boards/models/post/export.py

@@ -1,55 +1,57
+from django.contrib.auth.context_processors import PermWrapper
+
 from boards import utils
 
 
 PARAMETER_TRUNCATED = 'truncated'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 
 class Exporter():
     @staticmethod
     def export(post, request, include_last_update) -> str:
         pass
 
 
 class HtmlExporter(Exporter):
     @staticmethod
     def export(post, request, include_last_update):
         if request is not None and PARAMETER_TRUNCATED in request.GET:
             truncated = True
             reply_link = False
         else:
             truncated = False
             reply_link = True
 
         return post.get_view(truncated=truncated, reply_link=reply_link,
-                             moderator=utils.is_moderator(request))
+                perms=PermWrapper(request.user))
 
 
 class JsonExporter(Exporter):
     @staticmethod
     def export(post, request, include_last_update):
         post_json = {
             'id': post.id,
             'title': post.title,
             'text': post.get_raw_text(),
             }
         if post.images.exists():
             post_image = post.get_first_image()
             post_json['image'] = post_image.image.url
             post_json['image_preview'] = post_image.image.url_200x150
         if include_last_update:
             post_json['bump_time'] = utils.datetime_to_epoch(
                 post.get_thread().bump_time)
         return post_json
 
 
 EXPORTERS = {
     DIFF_TYPE_HTML: HtmlExporter,
     DIFF_TYPE_JSON: JsonExporter,
 }
 
 
 def get_exporter(export_type: str) -> Exporter:
     return EXPORTERS[export_type]()

boards/models/post/manager.py

@@ -1,152 +1,149
 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=''):
+                    tripcode='', monochrome=False):
         """
         Creates new post
         """
 
         if not utils.is_anonymous_mode():
             is_banned = Ban.objects.filter(ip=ip).exists()
+        else:
+            is_banned = False
 
         # 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)
+                bump_time=posting_time, last_edit_time=posting_time,
+                    monochrome=monochrome)
             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 [{}] with text [{}] by {}'.format(post,
-                                                                    post.get_text(),post.poster_ip))
+            post.get_text(),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()
         post.set_global_id()
 
         # 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
 
     @transaction.atomic
     def import_post(self, title: str, text: str, pub_time: str, global_id,
                     opening_post=None, tags=list()):
         is_opening = opening_post is None
         if is_opening:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=pub_time, last_edit_time=pub_time)
             list(map(thread.tags.add, tags))
         else:
             thread = opening_post.get_thread()
 
         post = self.create(title=title, text=text,
                            pub_time=pub_time,
                            poster_ip=NO_IP,
                            last_edit_time=pub_time,
                            global_id=global_id,
                            opening=is_opening,
                            thread=thread)
 
         post.threads.add(thread)
-        post.build_url()
-        post.connect_replies()
-        post.connect_notifications()

boards/models/tag.py

@@ -1,143 +1,147
 import hashlib
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count
 from django.core.urlresolvers import reverse
 
+from boards.models import PostImage
 from boards.models.base import Viewable
+from boards.models.thread import STATUS_ACTIVE, STATUS_BUMPLIMIT, STATUS_ARCHIVE
 from boards.utils import cached_result
 import boards
 
 __author__ = 'neko259'
 
 
 RELATED_TAGS_COUNT = 5
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         return self.annotate(num_threads=Count('thread_tags')).filter(num_threads__gt=0)\
             .order_by('-required', 'name')
 
     def get_tag_url_list(self, tags: list) -> str:
         """
         Gets a comma-separated list of tag links.
         """
 
         return ', '.join([tag.get_view() for tag in tags])
 
 
 class Tag(models.Model, Viewable):
     """
     A tag is a text node assigned to the thread. The tag serves as a board
     section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
     name = models.CharField(max_length=100, db_index=True, unique=True)
     required = models.BooleanField(default=False, db_index=True)
     description = models.TextField(blank=True)
 
     parent = models.ForeignKey('Tag', null=True, blank=True,
             related_name='children')
 
     def __str__(self):
         return self.name
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
-    def get_thread_count(self, archived=None, bumpable=None) -> int:
+    def get_thread_count(self, status=None) -> int:
         threads = self.get_threads()
-        if archived is not None:
-            threads = threads.filter(archived=archived)
-        if bumpable is not None:
-            threads = threads.filter(bumpable=bumpable)
+        if status is not None:
+            threads = threads.filter(status=status)
         return threads.count()
 
     def get_active_thread_count(self) -> int:
-        return self.get_thread_count(archived=False, bumpable=True)
+        return self.get_thread_count(status=STATUS_ACTIVE)
 
     def get_bumplimit_thread_count(self) -> int:
-        return self.get_thread_count(archived=False, bumpable=False)
+        return self.get_thread_count(status=STATUS_BUMPLIMIT)
 
     def get_archived_thread_count(self) -> int:
-        return self.get_thread_count(archived=True)
+        return self.get_thread_count(status=STATUS_ARCHIVE)
 
     def get_absolute_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
     def get_threads(self):
         return self.thread_tags.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def get_view(self):
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_absolute_url(), self.name)
         if self.is_required():
             link = '<b>{}</b>'.format(link)
         return link
 
     def get_search_view(self, *args, **kwargs):
         return render_to_string('boards/tag.html', {
             'tag': self,
         })
 
     @cached_result()
     def get_post_count(self):
         return self.get_threads().aggregate(num_posts=Count('multi_replies'))['num_posts']
 
     def get_description(self):
         return self.description
 
-    def get_random_image_post(self, archived=False):
+    def get_random_image_post(self, status=[STATUS_ACTIVE, STATUS_BUMPLIMIT]):
         posts = boards.models.Post.objects.annotate(images_count=Count(
             'images')).filter(images_count__gt=0, threads__tags__in=[self])
-        if archived is not None:
-            posts = posts.filter(thread__archived=archived)
+        if status is not None:
+            posts = posts.filter(thread__status__in=status)
         return posts.order_by('?').first()
 
     def get_first_letter(self):
         return self.name and self.name[0] or ''
 
     def get_related_tags(self):
         return set(Tag.objects.filter(thread_tags__in=self.get_threads()).exclude(
             id=self.id).order_by('?')[:RELATED_TAGS_COUNT])
 
     @cached_result()
     def get_color(self):
         """
         Gets color hashed from the tag name.
         """
         return hashlib.md5(self.name.encode()).hexdigest()[:6]
 
     def get_parent(self):
         return self.parent
 
     def get_all_parents(self):
         parents = list()
         parent = self.get_parent()
         if parent and parent not in parents:
             parents.insert(0, parent)
             parents = parent.get_all_parents() + parents
 
         return parents
 
     def get_children(self):
         return self.children
+
+    def get_images(self):
+        return PostImage.objects.filter(post_images__thread__tags__in=[self])\
+            .order_by('-post_images__pub_time')
  No newline at end of file

boards/models/thread.py

@@ -1,258 +1,272
 import logging
 from adjacent import Client
 
 from django.db.models import Count, Sum, QuerySet, Q
 from django.utils import timezone
 from django.db import models
 
+from boards.models import STATUS_BUMPLIMIT, STATUS_ACTIVE, STATUS_ARCHIVE
+
 from boards import settings
 import boards
 from boards.utils import cached_result, datetime_to_epoch
 from boards.models.post import Post
 from boards.models.tag import Tag
 
 FAV_THREAD_NO_UPDATES = -1
 
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
+STATUS_CHOICES = (
+        (STATUS_ACTIVE, STATUS_ACTIVE),
+        (STATUS_BUMPLIMIT, STATUS_BUMPLIMIT),
+        (STATUS_ARCHIVE, STATUS_ARCHIVE),
+)
+
 
 class ThreadManager(models.Manager):
     def process_oldest_threads(self):
         """
          Preserves maximum thread count. If there are too many threads,
          archive or delete the old ones.
          """
 
-        threads = Thread.objects.filter(archived=False).order_by('-bump_time')
+        threads = Thread.objects.exclude(status=STATUS_ARCHIVE).order_by('-bump_time')
         thread_count = threads.count()
 
         max_thread_count = settings.get_int('Messages', 'MaxThreadCount')
         if thread_count > max_thread_count:
             num_threads_to_delete = thread_count - max_thread_count
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 if settings.get_bool('Storage', 'ArchiveThreads'):
                     self._archive_thread(thread)
                 else:
                     thread.delete()
 
             logger.info('Processed %d old threads' % num_threads_to_delete)
 
     def _archive_thread(self, thread):
-        thread.archived = True
-        thread.bumpable = False
+        thread.status = STATUS_ARCHIVE
         thread.last_edit_time = timezone.now()
         thread.update_posts_time()
-        thread.save(update_fields=['archived', 'last_edit_time', 'bumpable'])
+        thread.save(update_fields=['last_edit_time', 'status'])
 
     def get_new_posts(self, datas):
         query = None
         # TODO Use classes instead of dicts
         for data in datas:
             if data['last_id'] != FAV_THREAD_NO_UPDATES:
                 q = (Q(id=data['op'].get_thread().id)
                      & Q(multi_replies__id__gt=data['last_id']))
                 if query is None:
                     query = q
                 else:
                     query = query | q
         if query is not None:
             return self.filter(query).annotate(
                 new_post_count=Count('multi_replies'))
 
     def get_new_post_count(self, datas):
         new_posts = self.get_new_posts(datas)
         return new_posts.aggregate(total_count=Count('multi_replies'))\
                 ['total_count'] if new_posts else 0
 
 
 def get_thread_max_posts():
     return settings.get_int('Messages', 'MaxPostsPerThread')
 
 
 class Thread(models.Model):
     objects = ThreadManager()
 
     class Meta:
         app_label = 'boards'
 
     tags = models.ManyToManyField('Tag', related_name='thread_tags')
     bump_time = models.DateTimeField(db_index=True)
     last_edit_time = models.DateTimeField()
-    archived = models.BooleanField(default=False)
-    bumpable = models.BooleanField(default=True)
     max_posts = models.IntegerField(default=get_thread_max_posts)
+    status = models.CharField(max_length=50, default=STATUS_ACTIVE,
+            choices=STATUS_CHOICES)
+    monochrome = models.BooleanField(default=False)
 
     def get_tags(self) -> QuerySet:
         """
         Gets a sorted tag list.
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bumps (moves to up) thread if possible.
         """
 
         if self.can_bump():
             self.bump_time = self.last_edit_time
 
             self.update_bump_status()
 
             logger.info('Bumped thread %d' % self.id)
 
     def has_post_limit(self) -> bool:
         return self.max_posts > 0
 
     def update_bump_status(self, exclude_posts=None):
         if self.has_post_limit() and self.get_reply_count() >= self.max_posts:
-            self.bumpable = False
+            self.status = STATUS_BUMPLIMIT
             self.update_posts_time(exclude_posts=exclude_posts)
 
     def _get_cache_key(self):
         return [datetime_to_epoch(self.last_edit_time)]
 
     @cached_result(key_method=_get_cache_key)
     def get_reply_count(self) -> int:
         return self.get_replies().count()
 
     @cached_result(key_method=_get_cache_key)
     def get_images_count(self) -> int:
         return self.get_replies().annotate(images_count=Count(
             'images')).aggregate(Sum('images_count'))['images_count__sum']
 
     def can_bump(self) -> bool:
         """
         Checks if the thread can be bumped by replying to it.
         """
 
-        return self.bumpable and not self.is_archived()
+        return self.get_status() == STATUS_ACTIVE
 
     def get_last_replies(self) -> QuerySet:
         """
         Gets several last replies, not including opening post
         """
 
         last_replies_count = settings.get_int('View', 'LastRepliesCount')
 
         if last_replies_count > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(last_replies_count,
                                           reply_count - 1)
                 replies = self.get_replies()
                 last_replies = replies[reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self) -> int:
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.get_int('View', 'LastRepliesCount'),
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False) -> QuerySet:
         """
         Gets sorted thread posts
         """
 
         query = self.multi_replies.order_by('pub_time').prefetch_related(
             'images', 'thread', 'threads', 'attachments')
         if view_fields_only:
             query = query.defer('poster_ip')
         return query.all()
 
     def get_top_level_replies(self) -> QuerySet:
         return self.get_replies().exclude(refposts__threads__in=[self])
 
     def get_replies_with_images(self, view_fields_only=False) -> QuerySet:
         """
         Gets replies that have at least one image attached
         """
 
         return self.get_replies(view_fields_only).annotate(images_count=Count(
             'images')).filter(images_count__gt=0)
 
     def get_opening_post(self, only_id=False) -> Post:
         """
         Gets the first post of the thread
         """
 
         query = self.get_replies().filter(opening=True)
         if only_id:
             query = query.only('id')
         opening_post = query.first()
 
         return opening_post
 
     @cached_result()
     def get_opening_post_id(self) -> int:
         """
         Gets ID of the first thread post.
         """
 
         return self.get_opening_post(only_id=True).id
 
     def get_pub_time(self):
         """
         Gets opening post's pub time because thread does not have its own one.
         """
 
         return self.get_opening_post().pub_time
 
     def __str__(self):
         return 'T#{}/{}'.format(self.id, self.get_opening_post_id())
 
     def get_tag_url_list(self) -> list:
         return boards.models.Tag.objects.get_tag_url_list(self.get_tags())
 
     def update_posts_time(self, exclude_posts=None):
         last_edit_time = self.last_edit_time
 
         for post in self.multi_replies.all():
             if exclude_posts is None or post not in exclude_posts:
                 # Manual update is required because uids are generated on save
                 post.last_edit_time = last_edit_time
                 post.save(update_fields=['last_edit_time'])
 
                 post.get_threads().update(last_edit_time=last_edit_time)
 
     def notify_clients(self):
         if not settings.get_bool('External', 'WebsocketsEnabled'):
             return
 
         client = Client()
 
         channel_name = WS_CHANNEL_THREAD + str(self.get_opening_post_id())
         client.publish(channel_name, {
             WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
             })
         client.send()
 
     def get_absolute_url(self):
         return self.get_opening_post().get_absolute_url()
 
     def get_required_tags(self):
         return self.get_tags().filter(required=True)
 
     def get_replies_newer(self, post_id):
         return self.get_replies().filter(id__gt=post_id)
 
     def is_archived(self):
-        return self.archived
+        return self.get_status() == STATUS_ARCHIVE
+
+    def get_status(self):
+        return self.status
+
+    def is_monochrome(self):
+        return self.monochrome

boards/models/user.py

@@ -1,45 +1,45
 from django.db import models
 import boards
 
 __author__ = 'neko259'
 
 BAN_REASON_AUTO = 'Auto'
 BAN_REASON_MAX_LENGTH = 200
 
 
 class Ban(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     ip = models.GenericIPAddressField()
     reason = models.CharField(default=BAN_REASON_AUTO,
                               max_length=BAN_REASON_MAX_LENGTH)
     can_read = models.BooleanField(default=True)
 
     def __str__(self):
         return self.ip
 
 
 class NotificationManager(models.Manager):
-    def get_notification_posts(self, username: str, last: int = None):
-        i_username = username.lower()
-
-        posts = boards.models.post.Post.objects.filter(notification__name=i_username)
+    def get_notification_posts(self, usernames: list, last: int = None):
+        lower_names = [username.lower() for username in usernames]
+        posts = boards.models.post.Post.objects.filter(
+                notification__name__in=lower_names).distinct()
         if last is not None:
             posts = posts.filter(id__gt=last)
         posts = posts.order_by('-id')
 
         return posts
 
 
 class Notification(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     objects = NotificationManager()
 
     post = models.ForeignKey('Post')
     name = models.TextField()
 

boards/rss.py

@@ -1,80 +1,84
 from django.contrib.syndication.views import Feed
 from django.core.urlresolvers import reverse
 from django.shortcuts import get_object_or_404
 from boards.models import Post, Tag, Thread
 from boards import settings
+from boards.models.thread import STATUS_ARCHIVE
 
-__author__ = 'neko259'
+__author__ = 'nekorin'
+
+
+MAX_ITEMS = settings.get_int('RSS', 'MaxItems')
 
 
 # TODO Make tests for all of these
 class AllThreadsFeed(Feed):
 
     title = settings.get('Version', 'SiteName') + ' - All threads'
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self):
-        return Thread.objects.filter(archived=False).order_by('-id')
+        return Thread.objects.exclude(status=STATUS_ARCHIVE).order_by('-id')[:MAX_ITEMS]
 
     def item_title(self, item):
         return item.get_opening_post().title
 
     def item_link(self, item):
         return reverse('thread', args={item.get_opening_post_id()})
 
     def item_pubdate(self, item):
         return item.get_pub_time()
 
 
 class TagThreadsFeed(Feed):
 
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self, obj):
-        return obj.threads.filter(archived=False).order_by('-id')
+        return obj.get_threads().exclude(status=STATUS_ARCHIVE).order_by('-id')[:MAX_ITEMS]
 
     def get_object(self, request, tag_name):
         return get_object_or_404(Tag, name=tag_name)
 
     def item_title(self, item):
         return item.get_opening_post().title
 
     def item_link(self, item):
         return reverse('thread', args={item.get_opening_post_id()})
 
     def item_pubdate(self, item):
         return item.get_pub_time()
 
     def title(self, obj):
         return obj.name
 
 
 class ThreadPostsFeed(Feed):
 
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self, obj):
-        return obj.get_thread().get_replies()
+        return obj.get_thread().get_replies().order_by('-pub_time')[:MAX_ITEMS]
 
     def get_object(self, request, post_id):
         return get_object_or_404(Post, id=post_id)
 
     def item_title(self, item):
         return item.title
 
     def item_link(self, item):
         if not item.is_opening():
             return reverse('thread', args={
                 item.get_thread().get_opening_post_id()
             }) + "#" + str(item.id)
         else:
             return reverse('thread', args={item.id})
 
     def item_pubdate(self, item):
         return item.pub_time
 
     def title(self, obj):
         return obj.title

boards/static/css/base.css

@@ -1,153 +1,159
 .ui-button {
    display: none;
 }
 
 .ui-dialog-content {
     padding: 0;
     min-height: 0;
 }
 
 .mark_btn {
     cursor: pointer;
 }
 
 .img-full {
     position: fixed;
     background-color: #CCC;
     border: 1px solid #000;
     cursor: pointer;
 }
 
 .strikethrough {
     text-decoration: line-through;
 }
 
 .post_preview {
     z-index: 300;
     position:absolute;
 }
 
 .gallery_image {
     display: inline-block;
 }
 
 @media print {
     .post-form-w {
         display: none;
     }
 }
 
 input[name="image"] {
      display: block;
      width: 100px;
      height: 100px;
      cursor: pointer;
      position: absolute;
      opacity: 0;
      z-index: 1;
 }
 
 .file_wrap {
      width: 100px;
      height: 100px;
      border: solid 1px white;
      display: inline-block;
 }
 
 form > .file_wrap {
     float: left;
 }
 
 .file-thumb {
     width: 100px;
     height: 100px;
     background-size: cover;
     background-position: center;
 }
 
 .compact-form-text {
     margin-left:110px;
 }
 
 textarea, input {
     -moz-box-sizing: border-box;
     -webkit-box-sizing: border-box;
     box-sizing: border-box;
 }
 
 .compact-form-text > textarea {
     height: 100px;
     width: 100%;
 }
 
 .post-button-form {
     display: inline;
 }
 
 .post-button-form > button, #autoupdate {
     border: none;
     margin: inherit;
     padding: inherit;
     background: none;
     font-size: inherit;
+    cursor: pointer;
 }
 
 #form-close-button {
     display: none;
 }
 
 .post-image-full {
     width: 100%;
     height: auto;
 }
 
 #preview-text {
     display: none;
 }
 
 .random-images-table {
     text-align: center;
     width: 100%;
 }
 
 .random-images-table > div {
     margin-left: auto;
     margin-right: auto;
 }
 
 .tag-image, .tag-text-data {
     display: inline-block;
 }
 
 .tag-text-data > h2 {
     margin: 0;
 }
 
 .tag-image {
     margin-right: 5px;
 }
 
 .reply-to-message {
     display: none;
 }
 
 .tripcode {
     padding: 2px;
 }
 
 #fav-panel {
     display: none;
     margin: 1ex;
 }
 
 #new-fav-post-count {
     display: none;
 }
 
 .hidden_post {
     opacity: 0.2;
 }
 
 .hidden_post:hover {
     opacity: 1;
 }
+
+.monochrome > .image > .thumb > img {
+    filter: grayscale(100%);
+    -webkit-filter: grayscale(100%);
+}

boards/static/css/md/base_page.css

@@ -1,579 +1,578
 * {
    text-decoration: none;
    font-weight: inherit;
 }
 
 b, strong {
    font-weight: bold;
 }
 
 html {
     background: #555;
     color: #ffffff;
 }
 
 body {
     margin: 0;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 .title {
     font-weight: bold;
     color: #ffcc00;
 }
 
 .link, a {
     color: #afdcec;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #FFD37D;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post, .dead_post, .archive_post, #posts-table {
     background: #333;
     padding: 10px;
     clear: left;
     word-wrap: break-word;
     border-top: 1px solid #777;
     border-bottom: 1px solid #777;
 }
 
 .post + .post {
     border-top: none;
 }
 
 .dead_post + .dead_post {
     border-top: none;
 }
 
 .archive_post + .archive_post {
     border-top: none;
 }
 
 .metadata {
     padding-top: 5px;
     margin-top: 10px;
     border-top: solid 1px #666;
     color: #ddd;
 }
 
 .navigation_panel, .tag_info {
     background: #222;
     margin-bottom: 5px;
     margin-top: 5px;
     padding: 10px;
     border-bottom: solid 1px #888;
     border-top: solid 1px #888;
     color: #eee;
 }
 
 .navigation_panel .link:first-child {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 
 .navigation_panel .right-link {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel .link {
     font-weight: bold;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 .tag_info {
     text-align: center;
 }
 
 .tag_info > .tag-text-data {
     text-align: left;
 }
 
 .header {
     border-bottom: solid 2px #ccc;
     margin-bottom: 5px;
     border-top: none;
     margin-top: 0;
 }
 
 .footer {
     border-top: solid 2px #ccc;
     margin-top: 5px;
     border-bottom: none;
     margin-bottom: 0;
 }
 
 p, .br {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     background: #333344;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     color: #fff;
     padding: 10px;
     margin-bottom: 5px;
     margin-top: 5px;
 }
 
 .form-row {
     width: 100%;
     display: table-row;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
     display: table-cell;
 }
 
 .form-input {
     padding: .25em 0;
     width: 100%;
     display: table-cell;
 }
 
 .form-errors {
     font-weight: bolder;
     vertical-align: middle;
     display: table-cell;
 }
 
 .post-form input:not([name="image"]):not([type="checkbox"]):not([type="submit"]), .post-form textarea, .post-form select {
     background: #333;
     color: #fff;
     border: solid 1px;
     padding: 0;
     font: medium sans-serif;
     width: 100%;
 }
 
 .post-form textarea {
     resize: vertical;
 }
 
 .form-submit {
     display: table;
     margin-bottom: 1ex;
     margin-top: 1ex;
 }
 
 .form-title {
     font-weight: bold;
     font-size: 2ex;
     margin-bottom: 0.5ex;
 }
 
 input[type="submit"], button {
     background: #222;
     border: solid 2px #fff;
     color: #fff;
     padding: 0.5ex;
     margin-right: 0.5ex;
 }
 
 input[type="submit"]:hover {
     background: #060;
 }
 
 .form-submit > button:hover {
     background: #006;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post > .post-info {
     font-style: italic;
 }
 
 .archive_post > .post-info {
     text-decoration: line-through;
 }
 
 .mark_btn {
     border: 1px solid;
     padding: 2px 2ex;
     display: inline-block;
     margin: 0 5px 4px 0;
 }
 
 .mark_btn:hover {
     background: #555;
 }
 
 .quote {
     color: #92cf38;
     font-style: italic;
 }
 
 .multiquote {
     padding: 3px;
     display: inline-block;
     background: #222;
     border-style: solid;
     border-width: 1px 1px 1px 4px;
     font-size: 0.9em;
 }
 
 .spoiler {
     background: black;
     color: black;
     padding: 0 1ex 0 1ex;
 }
 
 .spoiler:hover {
     color: #ddd;
 }
 
 .comment {
     color: #eb2;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
     margin-right: 3ex;
     border-left: solid 1px #777;
     border-right: solid 1px #777;
 }
 
 .last-replies > .post:first-child {
     border-top: none;
 }
 
 .thread {
     margin-bottom: 3ex;
     margin-top: 1ex;
 }
 
 .post:target {
     border: solid 2px white;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     background: #444;
     color: #eee;
     margin-top: 5px;
     padding: 5px;
     border-top: 1px solid #888;
     border-bottom: 1px solid #888;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin-top: 5px;
     margin-bottom: 5px;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .post-info {
     color: #ddd;
     margin-bottom: 1ex;
 }
 
 .moderator_info {
     color: #e99d41;
     opacity: 0.4;
 }
 
 .moderator_info:hover {
     opacity: 1;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #ccc;
     margin-top: 1em;
 }
 
 .fav {
     color: yellow;
 }
 
 .not_fav {
     color: #ccc;
 }
 
-.role {
-    text-decoration: underline;
-}
-
 .form-email {
     display: none;
 }
 
 .bar-value {
     background: rgba(50, 55, 164, 0.45);
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     margin-top: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .page_link {
     background: #444;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     padding: 5px;
     color: #eee;
     font-size: 2ex;
     margin-top: .5ex;
     margin-bottom: .5ex;
 }
 
 .skipped_replies {
     padding: 5px;
     margin-left: 3ex;
     margin-right: 3ex;
     border-left: solid 1px #888;
     border-right: solid 1px #888;
     border-bottom: solid 1px #888;
     background: #000;
 }
 
 .current_page {
     padding: 2px;
     background-color: #afdcec;
     color: #000;
 }
 
 .current_mode {
     font-weight: bold;
 }
 
 .gallery_image {
     border: solid 1px;
     margin: 0.5ex;
     text-align: center;
     padding: 1ex;
 }
 
 code {
     border: dashed 1px #ccc;
     background: #111;
     padding: 2px;
     font-size: 1.2em;
     display: inline-block;
 }
 
 pre {
     overflow: auto;
 }
 
 .img-full {
     background: #222;
     border: solid 1px white;
 }
 
 .tag_item {
     display: inline-block;
 }
 
 #id_models li {
     list-style: none;
 }
 
 #id_q {
     margin-left: 1ex;
 }
 
 ul {
     padding-left: 0px;
 }
 
 .quote-header {
     border-bottom: 2px solid #ddd;
     margin-bottom: 1ex;
     padding-bottom: .5ex;
     color: #ddd;
     font-size: 1.2em;
 }
 
 .global-id {
     font-weight: bolder;
     opacity: .5;
 }
 
 /* Post */
 .post > .message, .post > .image {
         padding-left: 1em;
 }
 
 /* Reflink preview */
 .post_preview {
     border-left: 1px solid #777;
     border-right: 1px solid #777;
     max-width: 600px;
 }
 
 /* Code highlighter */
 .hljs {
     color: #fff;
     background: #000;
     display: inline-block;
 }
 
 .hljs, .hljs-subst, .hljs-tag .hljs-title, .lisp .hljs-title, .clojure .hljs-built_in, .nginx .hljs-title {
     color: #fff;
 }
 
 #up {
     position: fixed;
     bottom: 5px;
     right: 5px;
     border: 1px solid #777;
     background: #000;
     padding: 4px;
     opacity: 0.3;
 }
 
 #up:hover {
     opacity: 1;
 }
 
 .user-cast {
     border: solid #ffffff 1px;
     padding: .2ex;
     background: #152154;
     color: #fff;
 }
 
 .highlight {
     background: #222;
 }
 
 .post-button-form > button:hover {
     text-decoration: underline;
 }
 
 .tree_reply > .post {
     margin-top: 1ex;
     border-left: solid 1px #777;
     padding-right: 0;
 }
 
 #preview-text {
     border: solid 1px white;
     margin: 1ex 0 1ex 0;
     padding: 1ex;
 }
 
 .image-metadata {
-    font-style: italic;
     font-size: 0.9em;
 }
 
 .tripcode {
     color: white;
 }
 
 #fav-panel {
     border: 1px solid white;
 }
+
+.post-blink {
+    background-color: #000;
+}

boards/static/css/pg/base_page.css

@@ -1,383 +1,383
 html {
     background: rgb(238, 238, 238);
     color: rgb(51, 51, 51);
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 
 .title {
     font-weight: bold;
     color: #333;
     font-size: 2ex;
 }
 
 .link, a {
     color: #ff7000;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #222;
 }
 
 .post_id:hover {
     color: #11f;
 }
 
 .post_id {
     color: #444;
 }
 
 .post, .dead_post, #posts-table {
     margin: 5px;
     padding: 10px;
     background: rgb(221, 221, 221);
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
     clear: left;
     word-wrap: break-word;
     display: table;
 }
 
 .metadata {
     padding: 5px;
     margin-top: 10px;
     border: solid 1px #666;
     font-size: 0.9em;
     display: table;
 }
 
 .navigation_panel, .tag_info, .page_link {
     margin: 5px;
     padding: 10px;
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #000;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #000;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 p {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     display: table;
     padding: 10px;
     margin: 5px
 }
 
 .form-row {
     display: table-row;
 }
 
 .form-label, .form-input, .form-errors {
     display: table-cell;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     padding-left: 1ex;
     font-weight: bold;
     vertical-align: middle;
 }
 
 .post-form input:not([name="image"]), .post-form textarea {
     background: #fff;
     color: #000;
     border: solid 1px;
     padding: 0;
     width: 100%;
     font: medium sans;
 }
 
 .form-submit {
     border-bottom: 2px solid #ddd;
     margin-bottom: .5em;
     padding-bottom: .5em;
 }
 
 .form-title {
     font-weight: bold;
 }
 
 input[type="submit"] {
     background: #fff;
     border: solid 1px #000;
     color: #000;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     border-top: solid #d5494f;
 }
 
 .archive_post {
     border-top: solid #575e9f;
 }
 
 .quote {
     color: #080;
     font-style: italic;
 }
 
 .spoiler {
     background: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .comment {
     color: #8B6914;
     font-style: italic;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
 }
 
 .thread {
     margin-bottom: 3ex;
 }
 
 .post:target {
     border: solid 2px black;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     display: table;
     margin: 5px;
     padding: 5px;
     background: rgb(221, 221, 221);
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin: 5px;
 }
 
 .tag_info, .page_link {
     display: table;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .moderator_info {
     color: #e99d41;
     border: dashed 1px;
     padding: 3px;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #444;
     margin-top: 1em;
 }
 
 input[type="submit"]:hover {
         background: #ccc;
 }
 
 
 .fav {
     color: rgb(255, 102, 0);
 }
 
 .not_fav {
     color: #555;
 }
 
-.role {
-    text-decoration: underline;
-}
-
 .form-email {
     display: none;
 }
 
 .mark_btn {
     padding: 2px 2ex;
     border: 1px solid;
 }
 
 .mark_btn:hover {
     background: #ccc;
 }
 
 .bar-value {
     background: rgba(251, 199, 16, 0.61);
     padding: 2px;
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
     margin: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .skipped_replies {
     margin: 5px;
 }
 
 .current_page, .current_mode {
     border: solid 1px #000;
     padding: 2px;
 }
 
 .tag_item {
     display: inline-block;
     border: 1px solid #ccc;
     margin: 0.3ex;
     padding: 0.2ex;
 }
 
 .multiquote {
     padding: 3px;
     display: inline-block;
     background: #ddd;
     border-style: solid;
     border-width: 1px 1px 1px 4px;
     border-color: #222;
     font-size: 0.9em;
 }
 
 .highlight {
     background-color: #F9E8A5;
 }
 
 #preview-text {
     border: solid 1px black;
     margin: 1ex 0 1ex 0;
     padding: 1ex;
 }
 
 .image-metadata {
     font-style: italic;
     font-size: 0.9em;
-}
  No newline at end of file
+}
+
+.post-blink {
+    background-color: #333;
+}

boards/static/css/sw/base_page.css

@@ -1,418 +1,418
 * {
     font-size: inherit;
     margin: 0;
     padding: 0;
 }
 html {
     background: #fff;
     color: #000;
     font: medium sans-serif;
 }
 a {
     color: inherit;
     text-decoration: underline;
 }
 li {
     list-style-position: inside;
 }
 
 #admin_panel {
     background: #182F6F;
     color: #fff;
     padding: .5ex 1ex .5ex 1ex;
 }
 
 .navigation_panel {
     background: #182F6F;
     color: #B4CFEC;
     margin-bottom: 1em;
     padding: .5ex 1ex 1ex 1ex;
 }
 .navigation_panel::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 .navigation_panel a:link, .navigation_panel a:visited, .navigation_panel a:hover {
     text-decoration: none;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #fff;
     color: #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .right-link {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel .tag {
     color: #fff;
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 
 .title {
     color: #182F6F;
     font-weight: bold;
 }
 
 .post-form-w {
     background: #182F6F;
     border-radius: 1ex;
     color: #fff;
     margin: 1em 1ex;
     padding: 1ex;
 }
 
 .form-row {
     display: table;
     width: 100%;
 }
 .form-label, .form-input {
     display: table-cell;
     vertical-align: top;
 }
 .form-label {
     padding: .25em 1ex .25em 0;
     width: 14ex;
 }
 .form-input {
     padding: .25em 0;
 }
 .form-input > * {
     background: #fff;
     color: #000;
     border: none;
     padding: 0;
     resize: vertical;
 }
 
 .form-input > :not(.file_wrap) {
     width: 100%;
 }
 
 .form-submit {
     border-bottom: 1px solid #666;
     margin-bottom: .5em;
     padding-bottom: .5em;
 }
 .form-title {
     font-weight: bold;
     margin-bottom: .5em;
 }
 .post-form .settings_item {
     margin: .5em 0;
 }
 .form-submit input {
     margin-top: .5em;
     padding: .2em 1ex;
 }
 .form-label {
     text-align: left;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .post_id {
     color: #a00;
 }
 
 .post {
     clear: left;
     margin: 0 1ex 1em 1ex;
     overflow-x: auto;
     word-wrap: break-word;
     background: #FFF;
     padding: 1ex;
     border: 1px solid #666;
     box-shadow: 1px 1px 2px 1px #666;
 }
 
 #posts > .post:last-child {
     border-bottom: none;
     padding-bottom: 0;
 }
 
 .metadata {
     background: #C0E4E8;
     border: 1px solid #7F9699;
     border-radius: .4ex;
     display: table;
     margin-top: .5em;
     padding: .4em;
 }
 
 .post ul, .post ol {
     margin: .5em 0 .5em 3ex;
 }
 .post li {
     margin: .2em 0;
 }
 .post p {
     margin: .5em 0;
 }
 .post blockquote {
     border-left: 3px solid #182F6F;
     margin: .5em 0 .5em 3ex;
     padding-left: 1ex;
 }
 .post blockquote > blockquote {
     padding-top: .1em;
 }
 
 .post > .image {
     float: left;
     margin-right: 1ex;
 }
 .post > .metadata {
     clear: left;
 }
 
 .post > .message .get {
     color: #182F6F; font-weight: bold;
 }
 
 .dead_post > .metadata {
     background: #eee;
 }
 
 .quote, .multiquote {
     color: #182F6F;
 }
 
 .spoiler {
     background: black;
     color: black;
 }
 
 .spoiler:hover {
     background: #ffffff;
 }
 
 .comment {
     color: #557055;
 }
 
 .last-replies {
     margin-left: 6ex;
 }
 
 .thread > .post > .message > .post-info {
     border-bottom: 1px solid #ccc;
     padding-bottom: .5em;
 }
 
 :target .post_id {
     background: #182F6F;
     color: #FFF;
     text-decoration: none;
 }
 
 .image-mode-tab {
     background: #182F6F;
     color: #FFF;
     display: table;
     margin: 1em auto 1em 0;
     padding: .2em .5ex;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 .tag_info, .page_link {
     margin: 1em 0;
     text-align: center;
 }
 
 .form-errors {
     margin-left: 1ex;
 }
 
 .moderator_info {
     font-weight: bold;
     float: right;
 }
 
 .refmap {
     border: 1px dashed #aaa;
     padding: 0.5em;
     display: table;
 }
 
 .fav {
     color: blue;
 }
 
 .not_fav {
     color: #ccc;
 }
 
-.role {
-    text-decoration: underline;
-}
-
 .form-email {
     display: none;
 }
 
 .bar-value {
     background: #E3E7F2;
     padding: .1em 1ex;
     moz-box-sizing: border-box;
     box-sizing: border-box;
     height: 1.5em;
 }
 
 .bar-bg {
     background: #EA4649;
     border: 1px solid #666;
     margin: 0 1ex 1em 1ex;
     position: relative;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .skipped_replies {
     margin: 1ex;
 }
 
 #mark-panel {
     background: #eee;
     border-bottom: 1px solid #182F6F;
 }
 
 .mark_btn {
     display: inline-block;
     padding: .2em 1ex;
     border-left: 1px solid #182F6F;
 }
 
 .mark_btn:first-child {
     border-left: none;
 }
 
 .mark_btn:last-child {
     border-right: 1px solid #182F6F;
 }
 
 .current_page {
     border-bottom: 1px solid #FFF;
     padding: 0px 0.5ex;
 }
 
 .image-mode-tab a {
     text-decoration: none;
 }
 .image-mode-tab .current_mode::before {
     content: "✓ ";
     padding: 0 0 0 .5ex;
     color: #182F6F;
     background: #FFF;
 }
 .image-mode-tab .current_mode {
     padding: 0 .5ex 0 0;
     color: #182F6F;
     background: #FFF;
 }
 
 .gallery_image_metadata {
     margin-bottom: 1em;
 }
 
 .gallery_image {
     padding: 4px;
     margin: .5em 0 0 1ex;
     text-align: center;
     vertical-align: top;
 }
 
 .swappable-form-full > form {
     display: table;
     width: 100%;
 }
 
 #id_models li {
     list-style: none;
 }
 
 #id_q {
     margin-left: 1ex;
 }
 
 .br {
     margin-top: 0.5em;
     margin-bottom: 0.5em;
 }
 
 .message, .refmap {
     margin-top: .5em;
 }
 
 .user-cast {
     padding: 0.2em .5ex;
     background: #008;
     color: #FFF;
     display: inline-block;
     text-decoration: none;
 }
 
 .highlight {
     background-color: #D4F0F9;
 }
 
 .dead_post {
     border-right: 1ex solid #666;
 }
 
 #preview-text {
     border: solid 1px white;
     margin: 1ex 0 1ex 0;
     padding: 1ex;
 }
 
 .image-metadata {
     font-style: italic;
     font-size: 0.9em;
 }
 
 audio {
     margin-top: 1em;
 }
+
+.post-blink {
+    background-color: #ccc;
+}

boards/static/js/form.js

@@ -1,43 +1,95
 $('input[name=image]').wrap($('<div class="file_wrap"></div>'));
 
 $('body').on('change', 'input[name=image]', function(event) {
     var file = event.target.files[0];
 
     if(file.type.match('image.*')) {
         var fileReader = new FileReader();
 
         fileReader.addEventListener("load", function(event) {
             var wrapper = $('.file_wrap');
 
             wrapper.find('.file-thumb').remove();
             wrapper.append(
                 $('<div class="file-thumb" style="background-image: url('+event.target.result+')"></div>')
             );
         });
 
         fileReader.readAsDataURL(file);
     }
 });
 
 var form = $('#form');
 $('textarea').keypress(function(event) {
     if (event.which == 13 && event.ctrlKey) {
-        form.submit();
+        form.find('input[type=submit]').click();
     }
 });
 
 $('#preview-button').click(function() {
     var data = {
         raw_text: $('textarea').val()
     }
 
     var diffUrl = '/api/preview/';
 
     $.post(diffUrl,
         data,
         function(data) {
             var previewTextBlock = $('#preview-text');
             previewTextBlock.html(data);
             previewTextBlock.show();
         })
-})
+});
+
+/**
+ * Show text in the errors row of the form.
+ * @param form
+ * @param text
+ */
+function showAsErrors(form, text) {
+    form.children('.form-errors').remove();
+
+    if (text.length > 0) {
+        var errorList = $('<div class="form-errors">' + text + '<div>');
+        errorList.appendTo(form);
+    }
+}
+
+function addHiddenInput(form, name, value) {
+    form.find('input[name=' + name + ']').val(value);
+}
+
+$(document).ready(function() {
+    var powDifficulty = parseInt($('body').attr('data-pow-difficulty'));
+    if (powDifficulty > 0) {
+        var worker = new Worker($('#powScript').attr('src'));
+        worker.onmessage = function(e) {
+            var form = $('#form');
+            addHiddenInput(form, 'timestamp', e.data.timestamp);
+            addHiddenInput(form, 'iteration', e.data.iteration);
+            addHiddenInput(form, 'guess', e.data.guess);
+
+            form.submit();
+            form.find('input[type=submit]').toggle();
+        };
+
+        var form = $('#form');
+        var submitButton = form.find('input[type=submit]');
+        submitButton.click(function() {
+            showAsErrors(form, gettext('Computing PoW...'));
+            submitButton.toggle();
+
+            var msg = $('textarea').val().trim();
+
+            var data = {
+                msg: msg,
+                difficulty: parseInt($('body').attr('data-pow-difficulty')),
+                hasher: $('#sha256Script').attr('src')
+            };
+            worker.postMessage(data);
+
+            return false;
+        });
+    }
+});

boards/static/js/image.js

@@ -1,181 +1,202
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var IMAGE_POPUP_MARGIN = 10;
 
 
 var IMAGE_VIEWERS = [
     ['simple', new SimpleImageViewer()],
     ['popup', new PopupImageViewer()]
 ];
 
 var FULL_IMG_CLASS = 'post-image-full';
 
 var ATTR_SCALE = 'scale';
 
 
+// Init image viewer
+var viewerName = $('body').attr('data-image-viewer');
+var viewer = ImageViewer();
+for (var i = 0; i < IMAGE_VIEWERS.length; i++) {
+    var item = IMAGE_VIEWERS[i];
+    if (item[0] === viewerName) {
+        viewer = item[1];
+        break;
+    }
+}
+
+
+function getFullImageWidth(previewImage) {
+    var full_img_w = previewImage.attr('data-width');
+    if (full_img_w == null) {
+        full_img_w = previewImage[0].naturalWidth;
+    }
+
+    return full_img_w;
+}
+
+function getFullImageHeight(previewImage) {
+    var full_img_h = previewImage.attr('data-height');
+    if (full_img_h == null) {
+        full_img_h = previewImage[0].naturalHeight;
+    }
+
+    return full_img_h;
+}
+
+
 function ImageViewer() {}
 ImageViewer.prototype.view = function (post) {};
 
 function SimpleImageViewer() {}
 SimpleImageViewer.prototype.view = function (post) {
     var images = post.find('img');
     images.toggle();
 
     // When we first enlarge an image, a full image needs to be created
     if (images.length == 1) {
         var thumb = images.first();
 
-        var width = thumb.attr('data-width');
-        var height = thumb.attr('data-height');
+        var width = getFullImageWidth(thumb);
+        var height = getFullImageHeight(thumb);
 
         if (width == null || height == null) {
             width = '100%';
             height = '100%';
         }
 
         var parent = images.first().parent();
         var link = parent.attr('href');
 
         var fullImg = $('<img />')
             .addClass(FULL_IMG_CLASS)
             .attr('src', link)
             .attr('width', width)
             .attr('height', height);
 
         parent.append(fullImg);
     }
 };
 
 function PopupImageViewer() {}
 PopupImageViewer.prototype.view = function (post) {
     var el = post;
     var thumb_id = 'full' + el.find('img').attr('alt');
 
     var existingPopups = $('#' + thumb_id);
     if (!existingPopups.length) {
-        var imgElement= el.find('img');
+        var imgElement = el.find('img');
 
-        var full_img_w = imgElement.attr('data-width');
-        var full_img_h = imgElement.attr('data-height');
+        var full_img_w = getFullImageWidth(imgElement);
+        var full_img_h = getFullImageHeight(imgElement);
 
         var win = $(window);
 
         var win_w = win.width();
         var win_h = win.height();
 
         // New image size
         var w_scale = 1;
         var h_scale = 1;
 
         var freeWidth = win_w - 2 * IMAGE_POPUP_MARGIN;
         var freeHeight = win_h - 2 * IMAGE_POPUP_MARGIN;
 
         if (full_img_w > freeWidth) {
             w_scale = full_img_w / freeWidth;
         }
         if (full_img_h > freeHeight) {
             h_scale = full_img_h / freeHeight;
         }
 
         var scale = Math.max(w_scale, h_scale)
         var img_w = full_img_w / scale;
         var img_h = full_img_h / scale;
 
         var postNode = $(el);
 
         var img_pv = new Image();
         var newImage = $(img_pv);
         newImage.addClass('img-full')
             .attr('id', thumb_id)
             .attr('src', postNode.attr('href'))
             .attr(ATTR_SCALE, scale)
             .css({
                 'width': img_w,
                 'height': img_h,
                 'left': (win_w - img_w) / 2,
                 'top': ((win_h - img_h) / 2)
             })
             .appendTo(postNode)
         //scaling preview
         .mousewheel(function(event, delta) {
             var cx = event.originalEvent.clientX;
             var cy = event.originalEvent.clientY;
 
             var scale = newImage.attr(ATTR_SCALE) / (delta > 0 ? 1.25 : 0.8);
 
             var oldWidth = newImage.width();
             var oldHeight = newImage.height();
 
             var newIW = full_img_w / scale;
             var newIH = full_img_h / scale;
 
             newImage.width(newIW);
             newImage.height(newIH);
             newImage.attr(ATTR_SCALE, scale);
 
             // Set position
             var oldPosition = newImage.position();
             newImage.css({
                 left: parseInt(cx - (newIW/oldWidth) * (cx - parseInt(oldPosition.left, 10)), 10),
                 top:  parseInt(cy - (newIH/oldHeight) * (cy - parseInt(oldPosition.top, 10)), 10)
             });
 
             return false;
         }
         )
             .draggable({
                 addClasses: false,
                 stack: '.img-full'
             });
     } else {
         existingPopups.remove();
     }
 };
 
 function addImgPreview() {
-    var viewerName = $('body').attr('data-image-viewer');
-    var viewer = ImageViewer();
-    for (var i = 0; i < IMAGE_VIEWERS.length; i++) {
-        var item = IMAGE_VIEWERS[i];
-        if (item[0] === viewerName) {
-            viewer = item[1];
-            break;
-        }
-    }
-
     //keybind
     $(document).on('keyup.removepic', function(e) {
         if(e.which === 27) {
             $('.img-full').remove();
         }
     });
 
     $('body').on('click', '.thumb', function() {
         viewer.view($(this));
 
         return false;
     });
 }

boards/static/js/main.js

@@ -1,126 +1,160
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var FAV_POST_UPDATE_PERIOD = 10000;
+var ITEM_VOLUME_LEVEL = 'volumeLevel';
 
 /**
  * An email is a hidden file to prevent spam bots from posting. It has to be
  * hidden.
  */
 function hideEmailFromForm() {
     $('.form-email').parent().parent().hide();
 }
 
 /**
  * Highlight code blocks with code highlighter
  */
 function highlightCode(node) {
     node.find('pre code').each(function(i, e) {
         hljs.highlightBlock(e);
     });
 }
 
 function updateFavPosts() {
     var includePostBody = $('#fav-panel').is(":visible");
     var url = '/api/new_posts/';
     if (includePostBody) {
         url += '?include_posts'
     }
     $.getJSON(url,
         function(data) {
             var allNewPostCount = 0;
 
             if (includePostBody) {
                 var favoriteThreadPanel = $('#fav-panel');
                 favoriteThreadPanel.empty();
             }
 
             $.each(data, function (_, dict) {
                 var newPostCount = dict.new_post_count;
                 allNewPostCount += newPostCount;
 
                 if (includePostBody) {
                     var favThreadNode = $('<div class="post"></div>');
                     favThreadNode.append($(dict.post_url));
                     favThreadNode.append(' ');
                     favThreadNode.append($('<span class="title">' + dict.title + '</span>'));
 
                     if (newPostCount > 0) {
                         favThreadNode.append(' (<a href="' + dict.newest_post_link + '">+' + newPostCount + "</a>)");
                     }
 
                     favoriteThreadPanel.append(favThreadNode);
 
                     addRefLinkPreview(favThreadNode[0]);
                 }
             });
 
             var newPostCountNode = $('#new-fav-post-count');
             if (allNewPostCount > 0) {
                 newPostCountNode.text('(+' + allNewPostCount + ')');
                 newPostCountNode.show();
             } else {
                 newPostCountNode.hide();
             }
         }
     );
 }
 
 function initFavPanel() {
     updateFavPosts();
 
     if ($('#fav-panel-btn').length > 0) {
         setInterval(updateFavPosts, FAV_POST_UPDATE_PERIOD);
         $('#fav-panel-btn').click(function() {
             $('#fav-panel').toggle();
             updateFavPosts();
 
             return false;
         });
 
         $(document).on('keyup.removepic', function(e) {
             if(e.which === 27) {
                 $('#fav-panel').hide();
             }
         });
     }
 }
 
+function setVolumeLevel(level) {
+    localStorage.setItem(ITEM_VOLUME_LEVEL, level);
+}
+
+function getVolumeLevel() {
+    var level = localStorage.getItem(ITEM_VOLUME_LEVEL);
+    if (level == null) {
+        level = 1.0;
+    }
+    return level
+}
+
+function processVolumeUser(node) {
+    node.prop("volume", getVolumeLevel());
+    node.on('volumechange', function(event) {
+        setVolumeLevel(event.target.volume);
+        $("video,audio").prop("volume", getVolumeLevel());
+    });
+}
+
+/**
+ * Add all scripts than need to work on post, when the post is added to the
+ * document.
+ */
+function addScriptsToPost(post) {
+    addRefLinkPreview(post[0]);
+    highlightCode(post);
+    processVolumeUser(post.find("video,audio"));
+}
+
 $( document ).ready(function() {
     hideEmailFromForm();
 
     $("a[href='#top']").click(function() {
         $("html, body").animate({ scrollTop: 0 }, "slow");
         return false;
     });
 
     addImgPreview();
 
     addRefLinkPreview();
 
     highlightCode($(document));
 
     initFavPanel();
+
+    var volumeUsers = $("video,audio");
+    processVolumeUser(volumeUsers);
 });

boards/static/js/refpopup.js

@@ -1,120 +1,119
 function $X(path, root) {
     return document.evaluate(path, root || document, null, 6, null);
 }
 function $x(path, root) {
     return document.evaluate(path, root || document, null, 8, null).singleNodeValue;
 }
 
 function $del(el) {
     if(el) el.parentNode.removeChild(el);
 }
 
 function $each(list, fn) {
     if(!list) return;
     var i = list.snapshotLength;
     if(i > 0) while(i--) fn(list.snapshotItem(i), i);
 }
 
 function mkPreview(cln, html) {
     cln.innerHTML = html;
 
-    highlightCode($(cln));
-    addRefLinkPreview(cln);
-};
+    addScriptsToPost($(cln));
+}
 
 function isElementInViewport (el) {
     //special bonus for those using jQuery
     if (typeof jQuery === "function" && el instanceof jQuery) {
         el = el[0];
     }
 
     var rect = el.getBoundingClientRect();
 
     return (
         rect.top >= 0 &&
         rect.left >= 0 &&
         rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && /*or $(window).height() */
         rect.right <= (window.innerWidth || document.documentElement.clientWidth) /*or $(window).width() */
     );
 }
 
 function addRefLinkPreview(node) {
     $each($X('.//a[starts-with(text(),">>")]', node || document), function(link) {
         link.addEventListener('mouseover', showPostPreview, false);
         link.addEventListener('mouseout', delPostPreview, false);
     });
 }
 
 function showPostPreview(e) {
     var doc = document;
     //ref id
     var pNum = $(this).text().match(/\d+/);
 
     if (pNum == null || pNum.length == 0) {
         return;
     }
 
     var post = $('#' + pNum);
     if (post.length > 0 && isElementInViewport(post)) {
         post.addClass('highlight');
     } else {
         var x = e.clientX + (doc.documentElement.scrollLeft || doc.body.scrollLeft) + 2;
         var y = e.clientY + (doc.documentElement.scrollTop || doc.body.scrollTop);
 
         var cln = doc.createElement('div');
         cln.id = 'pstprev_' + pNum;
         cln.className = 'post_preview';
 
         cln.style.cssText = 'top:' + y + 'px;' + (x < doc.body.clientWidth/2 ? 'left:' + x + 'px' : 'right:' + parseInt(doc.body.clientWidth - x + 1) + 'px');
 
         cln.addEventListener('mouseout', delPostPreview, false);
 
         cln.innerHTML = "<div class=\"post\">" + gettext('Loading...') + "</div>";
 
         if(post.length > 0) {
             var postdata = post.clone().wrap("<div/>").parent().html();
 
             mkPreview(cln, postdata);
         } else {
             $.ajax({
                 url: '/api/post/' + pNum + '/?truncated'
             })
                 .success(function(data) {
                     var postdata = $(data).wrap("<div/>").parent().html();
 
                     //make preview
                     mkPreview(cln, postdata);
 
                 })
                 .error(function() {
                     cln.innerHTML = "<div class=\"post\">"
                         + gettext('Post not found') + "</div>";
                 });
         }
 
         $del(doc.getElementById(cln.id));
 
         //add preview
         $(cln).fadeIn(200);
         $('body').append(cln);
     }
 }
 
 function delPostPreview(e) {
     var el = $x('ancestor-or-self::*[starts-with(@id,"pstprev")]', e.relatedTarget);
     if(!el) {
         $each($X('.//div[starts-with(@id,"pstprev")]'), function(clone) {
             $del(clone)
         });
     } else {
         while(el.nextSibling) $del(el.nextSibling);
     }
 
     $('.highlight').removeClass('highlight');
 }
 
 function addPreview() {
     $('.post').find('a').each(function() {
         showPostPreview($(this));
     });
 }

boards/static/js/thread_update.js

@@ -1,457 +1,444
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013-2014  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var CLASS_POST = '.post'
 
 var POST_ADDED = 0;
 var POST_UPDATED = 1;
 
+// TODO These need to be syncronized with board settings.
 var JS_AUTOUPDATE_PERIOD = 20000;
+// TODO This needs to be the same for attachment download time limit.
+var POST_AJAX_TIMEOUT = 30000;
+var BLINK_SPEED = 500;
 
 var ALLOWED_FOR_PARTIAL_UPDATE = [
     'refmap',
     'post-info'
 ];
 
 var ATTR_CLASS = 'class';
 var ATTR_UID = 'data-uid';
 
 var wsUser = '';
 
 var unreadPosts = 0;
 var documentOriginalTitle = '';
 
 // Thread ID does not change, can be stored one time
 var threadId = $('div.thread').children(CLASS_POST).first().attr('id');
+var blinkColor = $('<div class="post-blink"></div>').css('background-color');
 
 /**
  * Connect to websocket server and subscribe to thread updates. On any update we
  * request a thread diff.
  *
  * @returns {boolean} true if connected, false otherwise
  */
 function connectWebsocket() {
     var metapanel = $('.metapanel')[0];
 
     var wsHost = metapanel.getAttribute('data-ws-host');
     var wsPort = metapanel.getAttribute('data-ws-port');
 
     if (wsHost.length > 0 && wsPort.length > 0) {
         var centrifuge = new Centrifuge({
             "url": 'ws://' + wsHost + ':' + wsPort + "/connection/websocket",
             "project": metapanel.getAttribute('data-ws-project'),
             "user": wsUser,
             "timestamp": metapanel.getAttribute('data-ws-token-time'),
             "token": metapanel.getAttribute('data-ws-token'),
             "debug": false
         });
 
         centrifuge.on('error', function(error_message) {
             console.log("Error connecting to websocket server.");
             console.log(error_message);
             console.log("Using javascript update instead.");
 
             // If websockets don't work, enable JS update instead
             enableJsUpdate()
         });
 
         centrifuge.on('connect', function() {
             var channelName = 'thread:' + threadId;
             centrifuge.subscribe(channelName, function(message) {
                 getThreadDiff();
             });
 
             // For the case we closed the browser and missed some updates
             getThreadDiff();
             $('#autoupdate').hide();
         });
 
         centrifuge.connect();
 
         return true;
     } else {
         return false;
     }
 }
 
 /**
  * Get diff of the posts from the current thread timestamp.
  * This is required if the browser was closed and some post updates were
  * missed.
  */
 function getThreadDiff() {
     var all_posts = $('.post');
 
     var uids = '';
     var posts = all_posts;
     for (var i = 0; i < posts.length; i++) {
         uids += posts[i].getAttribute('data-uid') + ' ';
     }
 
     var data = {
         uids: uids,
         thread: threadId
     };
 
     var diffUrl = '/api/diff_thread/';
 
     $.post(diffUrl,
         data,
         function(data) {
             var updatedPosts = data.updated;
             var addedPostCount = 0;
 
             for (var i = 0; i < updatedPosts.length; i++) {
                 var postText = updatedPosts[i];
                 var post = $(postText);
 
                 if (updatePost(post) == POST_ADDED) {
                     addedPostCount++;
                 }
             }
 
             var hasMetaUpdates = updatedPosts.length > 0;
             if (hasMetaUpdates) {
                 updateMetadataPanel();
             }
 
             if (addedPostCount > 0) {
                 updateBumplimitProgress(addedPostCount);
             }
 
             if (updatedPosts.length > 0) {
                 showNewPostsTitle(addedPostCount);
             }
 
             // TODO Process removed posts if any
             $('.metapanel').attr('data-last-update', data.last_update);
         },
         'json'
     )
 }
 
 /**
  * Add or update the post on html page.
  */
 function updatePost(postHtml) {
     // This needs to be set on start because the page is scrolled after posts
     // are added or updated
     var bottom = isPageBottom();
 
     var post = $(postHtml);
 
     var threadBlock = $('div.thread');
 
     var postId = post.attr('id');
 
     // If the post already exists, replace it. Otherwise add as a new one.
     var existingPosts = threadBlock.children('.post[id=' + postId + ']');
 
     var type;
 
     if (existingPosts.size() > 0) {
         replacePartial(existingPosts.first(), post, false);
         post = existingPosts.first();
 
         type = POST_UPDATED;
     } else {
         post.appendTo(threadBlock);
 
         if (bottom) {
             scrollToBottom();
         }
 
         type = POST_ADDED;
     }
 
     processNewPost(post);
 
     return type;
 }
 
 /**
  * Initiate a blinking animation on a node to show it was updated.
  */
 function blink(node) {
-    var blinkCount = 2;
-
-    var nodeToAnimate = node;
-    for (var i = 0; i < blinkCount; i++) {
-        nodeToAnimate = nodeToAnimate.fadeTo('fast', 0.5).fadeTo('fast', 1.0);
-    }
+    node.effect('highlight', { color: blinkColor }, BLINK_SPEED);
 }
 
 function isPageBottom() {
     var scroll = $(window).scrollTop() / ($(document).height()
         - $(window).height());
 
     return scroll == 1
 }
 
 function enableJsUpdate() {
     setInterval(getThreadDiff, JS_AUTOUPDATE_PERIOD);
     return true;
 }
 
 function initAutoupdate() {
     if (location.protocol === 'https:') {
         return enableJsUpdate();
     } else {
         if (connectWebsocket()) {
             return true;
         } else {
             return enableJsUpdate();
         }
     }
 }
 
 function getReplyCount() {
     return $('.thread').children(CLASS_POST).length
 }
 
 function getImageCount() {
     return $('.thread').find('img').length
 }
 
 /**
  * Update post count, images count and last update time in the metadata
  * panel.
  */
 function updateMetadataPanel() {
     var replyCountField = $('#reply-count');
     var imageCountField = $('#image-count');
 
     var replyCount = getReplyCount();
     replyCountField.text(replyCount);
     var imageCount = getImageCount();
     imageCountField.text(imageCount);
 
     var lastUpdate = $('.post:last').children('.post-info').first()
         .children('.pub_time').first().html();
     if (lastUpdate !== '') {
         var lastUpdateField = $('#last-update');
         lastUpdateField.html(lastUpdate);
         blink(lastUpdateField);
     }
 
     blink(replyCountField);
     blink(imageCountField);
 
     $('#message-count-text').text(ngettext('message', 'messages', replyCount));
     $('#image-count-text').text(ngettext('image', 'images', imageCount));
 }
 
 /**
  * Update bumplimit progress bar
  */
 function updateBumplimitProgress(postDelta) {
     var progressBar = $('#bumplimit_progress');
     if (progressBar) {
         var postsToLimitElement = $('#left_to_limit');
 
         var oldPostsToLimit = parseInt(postsToLimitElement.text());
         var postCount = getReplyCount();
         var bumplimit = postCount - postDelta + oldPostsToLimit;
 
         var newPostsToLimit = bumplimit - postCount;
         if (newPostsToLimit <= 0) {
             $('.bar-bg').remove();
         } else {
             postsToLimitElement.text(newPostsToLimit);
             progressBar.width((100 - postCount / bumplimit * 100.0) + '%');
         }
     }
 }
 
 /**
  * Show 'new posts' text in the title if the document is not visible to a user
  */
 function showNewPostsTitle(newPostCount) {
     if (document.hidden) {
         if (documentOriginalTitle === '') {
             documentOriginalTitle = document.title;
         }
         unreadPosts = unreadPosts + newPostCount;
 
         var newTitle = '* ';
         if (unreadPosts > 0) {
             newTitle += '[' + unreadPosts + '] ';
         }
         newTitle += documentOriginalTitle;
 
         document.title = newTitle;
 
         document.addEventListener('visibilitychange', function() {
             if (documentOriginalTitle !== '') {
                 document.title = documentOriginalTitle;
                 documentOriginalTitle = '';
                 unreadPosts = 0;
             }
 
             document.removeEventListener('visibilitychange', null);
         });
     }
 }
 
 /**
  * Clear all entered values in the form fields
  */
 function resetForm(form) {
     form.find('input:text, input:password, input:file, select, textarea').val('');
     form.find('input:radio, input:checkbox')
              .removeAttr('checked').removeAttr('selected');
     $('.file_wrap').find('.file-thumb').remove();
     $('#preview-text').hide();
 }
 
 /**
  * When the form is posted, this method will be run as a callback
  */
 function updateOnPost(response, statusText, xhr, form) {
     var json = $.parseJSON(response);
     var status = json.status;
 
     showAsErrors(form, '');
 
     if (status === 'ok') {
         resetFormPosition();
         resetForm(form);
         getThreadDiff();
         scrollToBottom();
     } else {
         var errors = json.errors;
         for (var i = 0; i < errors.length; i++) {
             var fieldErrors = errors[i];
 
             var error = fieldErrors.errors;
 
             showAsErrors(form, error);
         }
     }
 }
 
-/**
- * Show text in the errors row of the form.
- * @param form
- * @param text
- */
-function showAsErrors(form, text) {
-    form.children('.form-errors').remove();
-
-    if (text.length > 0) {
-        var errorList = $('<div class="form-errors">' + text + '<div>');
-        errorList.appendTo(form);
-    }
-}
 
 /**
  * Run js methods that are usually run on the document, on the new post
  */
 function processNewPost(post) {
-    addRefLinkPreview(post[0]);
-    highlightCode(post);
+    addScriptsToPost(post);
     blink(post);
 }
 
 function replacePartial(oldNode, newNode, recursive) {
     if (!equalNodes(oldNode, newNode)) {
         // Update parent node attributes
         updateNodeAttr(oldNode, newNode, ATTR_CLASS);
         updateNodeAttr(oldNode, newNode, ATTR_UID);
 
         // Replace children
         var children = oldNode.children();
         if (children.length == 0) {
             oldNode.replaceWith(newNode);
         } else {
             var newChildren = newNode.children();
             newChildren.each(function(i) {
                 var newChild = newChildren.eq(i);
                 var newChildClass = newChild.attr(ATTR_CLASS);
 
                 // Update only certain allowed blocks (e.g. not images)
                 if (ALLOWED_FOR_PARTIAL_UPDATE.indexOf(newChildClass) > -1) {
                     var oldChild = oldNode.children('.' + newChildClass);
 
                     if (oldChild.length == 0) {
                         oldNode.append(newChild);
                     } else {
                         if (!equalNodes(oldChild, newChild)) {
                             if (recursive) {
                                 replacePartial(oldChild, newChild, false);
                             } else {
                                 oldChild.replaceWith(newChild);
                             }
                         }
                     }
                 }
             });
         }
     }
 }
 
 /**
  * Compare nodes by content
  */
 function equalNodes(node1, node2) {
     return node1[0].outerHTML == node2[0].outerHTML;
 }
 
 /**
  * Update attribute of a node if it has changed
  */
 function updateNodeAttr(oldNode, newNode, attrName) {
     var oldAttr = oldNode.attr(attrName);
     var newAttr = newNode.attr(attrName);
     if (oldAttr != newAttr) {
         oldNode.attr(attrName, newAttr);
     }
 }
 
-$(document).ready(function(){
+$(document).ready(function() {
     if (initAutoupdate()) {
         // Post form data over AJAX
         var threadId = $('div.thread').children('.post').first().attr('id');
 
         var form = $('#form');
 
         if (form.length > 0) {
             var options = {
-                beforeSubmit: function(arr, $form, options) {
-                    showAsErrors($('#form'), gettext('Sending message...'));
+                beforeSubmit: function(arr, form, options) {
+                    showAsErrors(form, gettext('Sending message...'));
                 },
                 success: updateOnPost,
                 error: function() {
-                    showAsErrors($('#form'), gettext('Server error!'));
+                    showAsErrors(form, gettext('Server error!'));
                 },
-                url: '/api/add_post/' + threadId + '/'
+                url: '/api/add_post/' + threadId + '/',
+                timeout: POST_AJAX_TIMEOUT
             };
 
             form.ajaxForm(options);
 
             resetForm(form);
         }
     }
 });

boards/templates/boards/all_threads.html

@@ -1,186 +1,202
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     {% if tag %}
         <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
-            <div>{{ banner.text }}</div>
-            <div>{% trans 'Related message' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
+            <div>{{ banner.get_text|safe }}</div>
+            <div>{% trans 'Details' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
 {% if tag %}
     <div class="tag_info" style="border-bottom: solid .5ex #{{ tag.get_color }}">
         {% if random_image_post %}
             <div class="tag-image">
                 {% with image=random_image_post.images.first %}
                     <a href="{{ random_image_post.get_absolute_url }}"><img 
                         src="{{ image.image.url_200x150 }}"
                         width="{{ image.pre_width }}"
-                        height="{{ image.pre_height }}"/></a>
+                        height="{{ image.pre_height }}"
+                        alt="{{ random_image_post.id }}"/></a>
                 {% endwith %}
             </div>
         {% endif %}
         <div class="tag-text-data">
             <h2>
+                /{{ tag.get_view|safe }}/
+                {% if perms.change_tag %}
+                <span class="moderator_info">| <a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></span>
+                {% endif %}
+            </h2>
+            <p>
                 <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
                     {% if is_favorite %}
-                        <button name="method" value="unsubscribe" class="fav">★</button>
+                        <button name="method" value="unsubscribe" class="fav">★ {% trans "Remove from favorites" %}</button>
                     {% else %}
-                        <button name="method" value="subscribe" class="not_fav">★</button>
+                        <button name="method" value="subscribe" class="not_fav">★ {% trans "Add to favorites" %}</button>
                     {% endif %}
                 </form>
                 <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
                     {% if is_hidden %}
-                        <button name="method" value="unhide" class="fav">H</button>
+                        <button name="method" value="unhide" class="fav">{% trans "Show" %}</button>
                     {% else %}
-                        <button name="method" value="hide" class="not_fav">H</button>
+                        <button name="method" value="hide" class="not_fav">{% trans "Hide" %}</button>
                     {% endif %}
                 </form>
-                {{ tag.get_view|safe }}
-                {% if moderator %}
-                <span class="moderator_info">| <a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></span>
-                {% endif %}
-            </h2>
+                <a href="{% url 'tag_gallery' tag.name %}">{% trans 'Gallery' %}</a>
+            </p>
             {% if tag.get_description %}
                 <p>{{ tag.get_description|safe }}</p>
             {% endif %}
             <p>
-                {% blocktrans count count=tag.get_active_thread_count %}{{ count }} active thread{% plural %}active threads{% endblocktrans %},
-                {% blocktrans count count=tag.get_bumplimit_thread_count %}{{ count }} thread in bumplimit{% plural %} threads in bumplimit{% endblocktrans %},
-                {% blocktrans count count=tag.get_archived_thread_count %}{{ count }} archived thread{% plural %}archived threads{% endblocktrans %},
+                {% with active_count=tag.get_active_thread_count bumplimit_count=tag.get_bumplimit_thread_count archived_count=tag.get_archived_thread_count %}
+                    {% if active_count %}
+                        {% blocktrans count count=active_count %}{{ count }} active thread{% plural %}active threads{% endblocktrans %},
+                    {% endif %}
+                    {% if bumplimit_count %}
+                        {% blocktrans count count=bumplimit_count %}{{ count }} thread in bumplimit{% plural %} threads in bumplimit{% endblocktrans %},
+                    {% endif %}
+                    {% if archived_count %}
+                        {% blocktrans count count=archived_count %}{{ count }} archived thread{% plural %}archived threads{% endblocktrans %},
+                    {% endif %}
+                {% endwith %}
                 {% blocktrans count count=tag.get_post_count %}{{ count }} message{% plural %}messages{% endblocktrans %}.
             </p>
             {% if tag.get_all_parents %}
                 <p>
                     {% for parent in tag.get_all_parents %}
                         {{ parent.get_view|safe }} &gt;
                     {% endfor %}
                     {{ tag.get_view|safe }}
                 </p>
             {% endif %}
         </div>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page_link %}
             <div class="page_link">
                 <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             <div class="thread">
-                {% post_view thread.get_opening_post moderator=moderator thread=thread truncated=True need_open_link=True %}
+                {% post_view thread.get_opening_post thread=thread truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% with skipped_replies_count=thread.get_skipped_replies_count %}
                                 {% if skipped_replies_count %}
                                     <div class="skipped_replies">
                                         <a href="{% url 'thread' thread.get_opening_post_id %}">
                                             {% blocktrans count count=skipped_replies_count %}Skipped {{ count }} reply. Open thread to see all replies.{% plural %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                                         </a>
                                     </div>
                                 {% endif %}
                             {% endwith %}
                             <div class="last-replies">
                                 {% for post in last_replies %}
-                                    {% post_view post moderator=moderator truncated=True %}
+                                    {% post_view post truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
             </div>
         {% endfor %}
 
         {% if next_page_link %}
             <div class="page_link">
                 <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <div class="swappable-form-full">
             <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                     <button id="preview-button" onclick="return false;">{% trans 'Preview' %}</button>
                 </div>
             </form>
             </div>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
+                {% with size=max_file_size|filesizeformat %}
+                    {% blocktrans %}Max file size is {{ size }}.{% endblocktrans %}
+                {% endwith %}
             </div>
             <div id="preview-text"></div>
             <div><a href="{% url "staticpage" name="help" %}">{% trans 'Text syntax' %}</a></div>
             <div><a href="{% url "tags" "required" %}">{% trans 'Tags' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/form.js' %}"></script>
+    <script id="sha256Script" src="{% static 'js/3party/sha256.js' %}"></script>
+    <script id="powScript" src="{% static 'js/proof_of_work.js' %}"></script>
     <script src="{% static 'js/thread_create.js' %}"></script>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         [
         {% with dividers=paginator.get_dividers %}
             {% for page in paginator.get_divided_range %}
                 {% if page in dividers %}
                     …,
                 {% endif %}
                 <a
                     {% ifequal page current_page.number %}
                         class="current_page"
                     {% endifequal %}
                     href="{% page_url paginator page %}">{{ page }}</a>
                 {% if not forloop.last %},{% endif %}
             {% endfor %}
         {% endwith %}
         ]
-        [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/authors.html

@@ -1,34 +1,34
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 
 {% block head %}
     <title>{% trans "Authors" %}</title>
 {% endblock %}
 
 {% block content %}
     <div class="post">
         <p><img src="{{ STATIC_URL }}favicon.png" width="200" /></p>
+        <h2>{% trans 'Statistics' %}</h2>
+        <p>{% trans 'Size of media:' %} {{ media_size|filesizeformat }}.
+        <p>{% blocktrans count count=post_count %}{{ count }} message{% plural %}messages{% endblocktrans %}.</p>
         <h2>{% trans 'Authors' %}</h2>
         {% for nick, values in authors.items %}
             <p>
                 <b>{{ nick }}</b> ({{ values.name }}):
                 {% for value in values.contacts %}
                     <a href="mailto:{{ value }}">{{ value }}</a>
                 {% endfor %} -
-                {% for role in values.roles %}
-                    <span class="role">{% trans role %}</span>
-                    {% if not forloop.last %}, {% endif %}
-                {% endfor %}
+                {{ values.roles|join:', ' }}
             </p>
         {% endfor %}
         <br />
         <p>{% trans "Distributed under the" %}
             <a href="http://www.gnu.org/licenses/gpl.html" >GNU GPLv3</a>
             {% trans "license" %}</p>
         <p><a href="https://bitbucket.org/neko259/neboard">
             {% trans "Repository" %}</a></p>
 
         <p>Bitcoin: <b>1A4dePg6CGfYcJ7SH1tbaVdjjj1VLv8X1H</b></p>
     </div>
 {% endblock %}

boards/templates/boards/base.html

@@ -1,80 +1,87
 {% load staticfiles %}
 {% load i18n %}
 {% load l10n %}
 {% load static from staticfiles %}
 
 <!DOCTYPE html>
 <html>
 <head>
     <link rel="stylesheet" type="text/css" href="{% static 'css/base.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static 'css/3party/highlight.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static 'css/3party/jquery-ui.min.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static theme_css %}" media="all"/>
 
-    <link rel="alternate" type="application/rss+xml" href="rss/" title="{% trans 'Feed' %}"/>
+    {% if rss_url %}
+        <link rel="alternate" type="application/rss+xml" href="{{ rss_url }}" title="{% trans 'Feed' %}"/>
+    {% endif %}
 
     <link rel="icon" type="image/png"
         href="{% static 'favicon.png' %}">
 
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
     <meta charset="utf-8"/>
 
     {% block head %}{% endblock %}
 </head>
-<body data-image-viewer="{{ image_viewer }}">
+<body data-image-viewer="{{ image_viewer }}" data-pow-difficulty="{{ pow_difficulty }}">
     <script src="{% static 'js/jquery-2.0.1.min.js' %}"></script>
-    <script src="{% static 'js/3party/jquery-ui.min.js' %}"></script>
-    <script src="{% static 'js/jquery.mousewheel.js' %}"></script>
-    <script src="{% url 'js_info_dict' %}"></script>
 
     <div class="navigation_panel header">
         <a class="link" href="{% url 'index' %}">{% trans "All threads" %}</a>
         {% if tags_str %}
             {% autoescape off %}
                 {{ tags_str }},
             {% endautoescape %}
         {% else %}
             {% trans 'Add tags' %} → 
         {% endif %}
         <a href="{% url 'tags' 'required'%}" title="{% trans 'Tag management' %}">{% trans "tags" %}</a>,
         <a href="{% url 'search' %}" title="{% trans 'Search' %}">{% trans 'search' %}</a>,
         <a href="{% url 'feed' %}" title="{% trans 'Feed' %}">{% trans 'feed' %}</a>,
         <a href="{% url 'random' %}" title="{% trans 'Random images' %}">{% trans 'random' %}</a>{% if has_fav_threads %},
 
             <a href="#" id="fav-panel-btn">{% trans 'favorites' %} <span id="new-fav-post-count"></span></a>
         {% endif %}
 
-        {% if username %}
-            <a class="right-link link" href="{% url 'notifications' username %}" title="{% trans 'Notifications' %}">
+        {% if usernames %}
+            <a class="right-link link" href="{% url 'notifications' %}" title="{% trans 'Notifications' %}">
                 {% trans 'Notifications' %}
                 {% ifnotequal new_notifications_count 0 %}
                     (<b>{{ new_notifications_count }}</b>)
                 {% endifnotequal %}
             </a>
         {% endif %}
 
         <a class="right-link link" href="{% url 'settings' %}">{% trans 'Settings' %}</a>
     </div>
 
     <div id="fav-panel"><div class="post">{% trans "Loading..." %}</div></div>
 
     {% block content %}{% endblock %}
 
+    <script src="{% static 'js/3party/jquery-ui.min.js' %}"></script>
+    <script src="{% static 'js/jquery.mousewheel.js' %}"></script>
     <script src="{% static 'js/3party/highlight.min.js' %}"></script>
+
+    <script src="{% url 'js_info_dict' %}"></script>
+
     <script src="{% static 'js/popup.js' %}"></script>
     <script src="{% static 'js/image.js' %}"></script>
     <script src="{% static 'js/refpopup.js' %}"></script>
     <script src="{% static 'js/main.js' %}"></script>
 
     <div class="navigation_panel footer">
         {% block metapanel %}{% endblock %}
+        {% if rss_url %}
+            [<a href="{{ rss_url }}">RSS</a>]
+        {% endif %}
         [<a href="{% url 'admin:index' %}">{% trans 'Admin' %}</a>]
         [<a href="{% url 'index' %}?order=pub">{% trans 'New threads' %}</a>]
         {% with ppd=posts_per_day|floatformat:2 %}
             {% blocktrans %}Speed: {{ ppd }} posts per day{% endblocktrans %}
         {% endwith %}
         <a class="link" href="#top" id="up">{% trans 'Up' %}</a>
     </div>
 
 </body>
 </html>

boards/templates/boards/notifications.html

@@ -1,31 +1,35
 {% extends 'boards/base.html' %}
 
 {% load board %}
 {% load i18n %}
 
 {% block head %}
     <meta name="robots" content="noindex">
-    <title>{{ site_name }} - {% trans 'Notifications' %} - {{ notification_username }}</title>
+    <title>{{ site_name }} - {% trans 'Notifications' %} - {{ notification_usernames|join:', ' }}</title>
 {% endblock %}
 
 {% block content %}
-    <div class="tag_info"><a href="{% url 'notifications' notification_username %}" class="user-cast">@{{ notification_username }}</a></div>
+    <div class="tag_info">
+    {% for username in notification_usernames %}
+        <a href="{% url 'notifications' username %}" class="user-cast">@{{ username }}</a>
+    {% endfor %}
+    </div>
 
     {% if page %}
         {% if page.has_previous %}
             <div class="page_link">
             <a href="?page={{ page.previous_page_number }}">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for post in page.object_list %}
             {% post_view post need_op_data=True %}
         {% endfor %}
 
         {% if page.has_next %}
             <div class="page_link">
                 <a href="?page={{ page.next_page_number }}">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% endif %}
 {% endblock %}

boards/templates/boards/post.html

@@ -1,114 +1,115
 {% load i18n %}
 {% load board %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 <div class="{{ css_class }}" id="{{ post.id }}" data-uid="{{ post.uid }}">
     <div class="post-info">
         <a class="post_id" href="{{ post.get_absolute_url }}">#{{ post.get_absolute_id }}</a>
         <span class="title">{{ post.title }}</span>
         <span class="pub_time"><time datetime="{{ post.pub_time|date:'c' }}">{{ post.pub_time }}</time></span>
         {% if post.tripcode %}
             /
             {% with tripcode=post.get_tripcode %}
             <a href="{% url 'feed' %}?tripcode={{ tripcode.get_full_text }}"
                class="tripcode" title="{{ tripcode.get_full_text }}"
                style="border: solid 2px #{{ tripcode.get_color }}; border-left: solid 1ex #{{ tripcode.get_color }};">{{ tripcode.get_short_text }}</a>
             {% endwith %}
         {% endif %}
         {% comment %}
             Thread death time needs to be shown only if the thread is alredy archived
             and this is an opening post (thread death time) or a post for popup
             (we don't see OP here so we show the death time in the post itself).
         {% endcomment %}
-        {% if thread.archived %}
+        {% if thread.is_archived %}
             {% if is_opening %}
             — <time datetime="{{ thread.bump_time|date:'c' }}">{{ thread.bump_time }}</time>
             {% endif %}
         {% endif %}
         {% if is_opening %}
             {% if need_open_link %}
-                {% if thread.archived %}
+                {% if thread.is_archived %}
                     <a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>
                 {% else %}
                     <a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>
                 {% endif %}
             {% endif %}
         {% else %}
             {% if need_op_data %}
                 {% with thread.get_opening_post as op %}
                     {% trans " in " %}{{ op.get_link_view|safe }} <span class="title">{{ op.get_title_or_text }}</span>
                 {% endwith %}
             {% endif %}
         {% endif %}
-        {% if reply_link and not thread.archived %}
+        {% if reply_link and not thread.is_archived %}
             <a href="#form" onclick="addQuickReply('{{ post.id }}'); return false;">{% trans 'Reply' %}</a>
         {% endif %}
 
         {% if post.global_id %}
             <a class="global-id" href="{% url 'post_sync_data' post.id %}"> [RAW] </a>
         {% endif %}
 
-        {% if moderator %}
+        {% if perms.boards.change_post or perms.boards.delete_post or perms.boards.change_thread or perms_boards.delete_thread %}
             <span class="moderator_info">
-                | <a href="{% url 'admin:boards_post_change' post.id %}">{% trans 'Edit' %}</a>
-                {% if is_opening %}
-                   | <a href="{% url 'admin:boards_thread_change' thread.id %}">{% trans 'Edit thread' %}</a>
+                {% if perms.boards.change_post or perms.boards.delete_post %}
+                    | <a href="{% url 'admin:boards_post_change' post.id %}">{% trans 'Edit' %}</a>
                 {% endif %}
-                <form action="{% url 'thread' thread.get_opening_post_id %}?post_id={{ post.id }}" method="post" class="post-button-form">
-                | <button name="method" value="toggle_hide_post">H</button>
-                </form>
+                {% if perms.boards.change_thread or perms_boards.delete_thread %}
+                    {% if is_opening %}
+                       | <a href="{% url 'admin:boards_thread_change' thread.id %}">{% trans 'Edit thread' %}</a>
+                    {% endif %}
+                {% endif %}
             </form>
             </span>
         {% endif %}
     </div>
     {% comment %}
         Post images. Currently only 1 image can be posted and shown, but post model
         supports multiple.
     {%  endcomment %}
     {% for image in post.images.all %}
         {{ image.get_view|safe }}
     {% endfor %}
     {% for file in post.attachments.all %}
         {{ file.get_view|safe }}
     {% endfor %}
     {% comment %}
         Post message (text)
     {% endcomment %}
     <div class="message">
         {% autoescape off %}
             {% if truncated %}
                 {{ post.get_text|truncatewords_html:50 }}
             {% else %}
                 {{ post.get_text }}
             {% endif %}
         {% endautoescape %}
     </div>
     {% if post.is_referenced %}
         {% if mode_tree %}
             <div class="tree_reply">
                 {% for refpost in post.get_referenced_posts %}
                     {% post_view refpost mode_tree=True %}
                 {% endfor %}
             </div>
         {% else %}
             <div class="refmap">
                 {% trans "Replies" %}: {{ post.refmap|safe }}
             </div>
         {% endif %}
     {% endif %}
     {% comment %}
         Thread metadata: counters, tags etc
     {% endcomment %}
     {% if is_opening %}
         <div class="metadata">
             {% if is_opening and need_open_link %}
                 {% blocktrans count count=thread.get_reply_count %}{{ count }} message{% plural %}{{ count }} messages{% endblocktrans %},
                 {% blocktrans count count=thread.get_images_count %}{{ count }} image{% plural %}{{ count }} images{% endblocktrans %}.
             {% endif %}
             <span class="tags">
                 {{ thread.get_tag_url_list|safe }}
             </span>
         </div>
     {% endif %}
 </div>

boards/templates/boards/staticpages/help.html

@@ -1,22 +1,22
 {% extends "boards/static_base.html" %}
 
 {% load i18n %}
 
 {% block head %}
     <title>{% trans "Syntax" %}</title>
 {% endblock %}
 
 {% block staticcontent %}
     <h2>{% trans 'Syntax' %}</h2>
     <p>[i]<i>{% trans 'Italic text' %}</i>[/i]</p>
     <p>[b]<b>{% trans 'Bold text' %}</b>[/b]</p>
     <p>[spoiler]<span class="spoiler">{% trans 'Spoiler' %}</span>[/spoiler]</p>
     <p>[post]123[/post] — {% trans 'Link to a post' %}</p>
     <p>[s]<span class="strikethrough">{% trans 'Strikethrough text' %}</span>[/s]</p>
     <p>[comment]<span class="comment">{% trans 'Comment' %}</span>[/comment]</p>
     <p>[quote]<span class="quote">&gt;{% trans 'Quote' %}</span>[/quote]</p>
-    <p>[quote source=src]<div class="multiquote"><div class="quote-header">src</div><div class="quote-text">{% trans 'Quote' %}</div></div><br />[/quote]</p>
+    <p>[quote=src]<div class="multiquote"><div class="quote-header">src</div><div class="quote-text">{% trans 'Quote' %}</div></div><br />[/quote]</p>
     <p>[tag]<a class="tag">tag</a>[/tag]</p>
     <br/>
     <p>{% trans 'You can try pasting the text and previewing the result here:' %} <a href="{% url 'preview' %}">{% trans 'Preview' %}</a></p>
 {% endblock %}

boards/templates/boards/tag_gallery.html

@@ -1,186 +1,128
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
-    {% if tag %}
-        <title>{{ tag.name }} - {{ site_name }}</title>
-    {% else %}
-        <title>{{ site_name }}</title>
-    {% endif %}
+    <title>{{ tag.name }} - {% trans 'Gallery' %} - {{ site_name }}</title>
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
-            <div>{{ banner.text }}</div>
-            <div>{% trans 'Related message' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
+            <div>{{ banner.get_text }}</div>
+            <div>{% trans 'Details' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
-{% if tag %}
     <div class="tag_info" style="border-bottom: solid .5ex #{{ tag.get_color }}">
         {% if random_image_post %}
             <div class="tag-image">
                 {% with image=random_image_post.images.first %}
                     <a href="{{ random_image_post.get_absolute_url }}"><img 
                         src="{{ image.image.url_200x150 }}"
                         width="{{ image.pre_width }}"
-                        height="{{ image.pre_height }}"/></a>
+                        height="{{ image.pre_height }}"
+                        alt="{{ random_image_post.id }}"/></a>
                 {% endwith %}
             </div>
         {% endif %}
         <div class="tag-text-data">
             <h2>
-                <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
-                    {% if is_favorite %}
-                        <button name="method" value="unsubscribe" class="fav">★</button>
-                    {% else %}
-                        <button name="method" value="subscribe" class="not_fav">★</button>
-                    {% endif %}
-                </form>
-                <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
-                    {% if is_hidden %}
-                        <button name="method" value="unhide" class="fav">H</button>
-                    {% else %}
-                        <button name="method" value="hide" class="not_fav">H</button>
-                    {% endif %}
-                </form>
-                {{ tag.get_view|safe }}
-                {% if moderator %}
+                /{{ tag.get_view|safe }}/
+                {% if perms.change_tag %}
                 <span class="moderator_info">| <a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></span>
                 {% endif %}
             </h2>
             {% if tag.get_description %}
                 <p>{{ tag.get_description|safe }}</p>
             {% endif %}
             <p>
-                {% blocktrans count count=tag.get_active_thread_count %}{{ count }} active thread{% plural %}active threads{% endblocktrans %},
-                {% blocktrans count count=tag.get_bumplimit_thread_count %}{{ count }} thread in bumplimit{% plural %} threads in bumplimit{% endblocktrans %},
-                {% blocktrans count count=tag.get_archived_thread_count %}{{ count }} archived thread{% plural %}archived threads{% endblocktrans %},
+                {% with active_count=tag.get_active_thread_count bumplimit_count=tag.get_bumplimit_thread_count archived_count=tag.get_archived_thread_count %}
+                    {% if active_count %}
+                        {% blocktrans count count=active_count %}{{ count }} active thread{% plural %}active threads{% endblocktrans %},
+                    {% endif %}
+                    {% if bumplimit_count %}
+                        {% blocktrans count count=bumplimit_count %}{{ count }} thread in bumplimit{% plural %} threads in bumplimit{% endblocktrans %},
+                    {% endif %}
+                    {% if archived_count %}
+                        {% blocktrans count count=archived_count %}{{ count }} archived thread{% plural %}archived threads{% endblocktrans %},
+                    {% endif %}
+                {% endwith %}
                 {% blocktrans count count=tag.get_post_count %}{{ count }} message{% plural %}messages{% endblocktrans %}.
             </p>
             {% if tag.get_all_parents %}
                 <p>
                     {% for parent in tag.get_all_parents %}
                         {{ parent.get_view|safe }} &gt;
                     {% endfor %}
                     {{ tag.get_view|safe }}
                 </p>
             {% endif %}
         </div>
     </div>
-{% endif %}
 
-    {% if threads %}
-        {% if prev_page_link %}
-            <div class="page_link">
-                <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
-            </div>
-        {% endif %}
-
-        {% for thread in threads %}
-            <div class="thread">
-                {% post_view thread.get_opening_post moderator=moderator thread=thread truncated=True need_open_link=True %}
-                {% if not thread.archived %}
-                    {% with last_replies=thread.get_last_replies %}
-                        {% if last_replies %}
-                            {% with skipped_replies_count=thread.get_skipped_replies_count %}
-                                {% if skipped_replies_count %}
-                                    <div class="skipped_replies">
-                                        <a href="{% url 'thread' thread.get_opening_post_id %}">
-                                            {% blocktrans count count=skipped_replies_count %}Skipped {{ count }} reply. Open thread to see all replies.{% plural %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
-                                        </a>
-                                    </div>
-                                {% endif %}
-                            {% endwith %}
-                            <div class="last-replies">
-                                {% for post in last_replies %}
-                                    {% post_view post moderator=moderator truncated=True %}
-                                {% endfor %}
-                            </div>
-                        {% endif %}
-                    {% endwith %}
-                {% endif %}
-            </div>
-        {% endfor %}
-
-        {% if next_page_link %}
-            <div class="page_link">
-                <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
-            </div>
-        {% endif %}
-    {% else %}
-        <div class="post">
-            {% trans 'No threads exist. Create the first one!' %}</div>
+    {% if prev_page_link %}
+        <div class="page_link">
+            <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
+        </div>
     {% endif %}
 
-    <div class="post-form-w">
-        <script src="{% static 'js/panel.js' %}"></script>
-        <div class="post-form">
-            <div class="form-title">{% trans "Create new thread" %}</div>
-            <div class="swappable-form-full">
-            <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
-                {{ form.as_div }}
-                <div class="form-submit">
-                    <input type="submit" value="{% trans "Post" %}"/>
-                    <button id="preview-button" onclick="return false;">{% trans 'Preview' %}</button>
-                </div>
-            </form>
+    {% for image in images %}
+        <div class="gallery_image">
+            {% autoescape off %}
+                {{ image.get_view }}
+            {% endautoescape %}
+            <div class="gallery_image_metadata">
+                {{ image.width }}x{{ image.height }}
             </div>
-            <div>
-                {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
-            </div>
-            <div id="preview-text"></div>
-            <div><a href="{% url "staticpage" name="help" %}">{% trans 'Text syntax' %}</a></div>
-            <div><a href="{% url "tags" "required" %}">{% trans 'Tags' %}</a></div>
         </div>
-    </div>
+    {% endfor %}
 
-    <script src="{% static 'js/form.js' %}"></script>
-    <script src="{% static 'js/thread_create.js' %}"></script>
-
+    {% if next_page_link %}
+        <div class="page_link">
+            <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
+        </div>
+    {% endif %}
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         [
         {% with dividers=paginator.get_dividers %}
             {% for page in paginator.get_divided_range %}
                 {% if page in dividers %}
                     …,
                 {% endif %}
                 <a
-                    {% ifequal page current_page.number %}
+                    {% ifequal page paginator.current_page %}
                         class="current_page"
                     {% endifequal %}
                     href="{% page_url paginator page %}">{{ page }}</a>
                 {% if not forloop.last %},{% endif %}
             {% endfor %}
         {% endwith %}
         ]
-        [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/thread.html

@@ -1,44 +1,43
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block head %}
     <title>{{ opening_post.get_title_or_text }} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
     <div class="image-mode-tab">
         <a {% ifequal mode 'normal' %}class="current_mode"{% endifequal %} href="{% url 'thread' opening_post.id %}">{% trans 'Normal' %}</a>,
         <a {% ifequal mode 'gallery' %}class="current_mode"{% endifequal %} href="{% url 'thread_gallery' opening_post.id %}">{% trans 'Gallery' %}</a>,
         <a {% ifequal mode 'tree' %}class="current_mode"{% endifequal %} href="{% url 'thread_tree' opening_post.id %}">{% trans 'Tree' %}</a>
     </div>
 
     {% block thread_content %}
     {% endblock %}
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel"
           data-last-update="{{ last_update }}"
           data-ws-token-time="{{ ws_token_time }}"
           data-ws-token="{{ ws_token }}"
           data-ws-project="{{ ws_project }}"
           data-ws-host="{{ ws_host }}"
           data-ws-port="{{ ws_port }}">
 
         {% with replies_count=thread.get_reply_count%}
             <span id="reply-count">{{ thread.get_reply_count }}</span>{% if thread.has_post_limit %}/{{ thread.max_posts }}{% endif %}
             <span id="message-count-text">{% blocktrans count repliess_count=replies_count %}message{% plural %}messages{% endblocktrans %}</span>,
         {% endwith %}
         {% with images_count=thread.get_images_count%}
             <span id="image-count">{{ images_count }}</span> <span id="image-count-text">{% blocktrans count count=images_count %}image{% plural %}images{% endblocktrans %}</span>.
         {% endwith %}
-            {% trans 'Last update: ' %}<span id="last-update"><time datetime="{{ thread.last_edit_time|date:'c' }}">{{ thread.last_edit_time }}</time></span>
-            [<a href="rss/">RSS</a>]
+        {% trans 'Last update: ' %}<span id="last-update"><time datetime="{{ thread.last_edit_time|date:'c' }}">{{ thread.last_edit_time }}</time></span>
     </span>
 
 {% endblock %}

boards/templates/boards/thread_normal.html

@@ -1,70 +1,78
 {% extends "boards/thread.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block thread_content %}
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     <div class="tag_info">
         <h2>
             <form action="{% url 'thread' opening_post.id %}" method="post" class="post-button-form">
+                {% csrf_token %}
                 {% if is_favorite %}
                     <button name="method" value="unsubscribe" class="fav">★</button>
                 {% else %}
                     <button name="method" value="subscribe" class="not_fav">★</button>
                 {% endif %}
             </form>
             {{ opening_post.get_title_or_text }}
         </h2>
     </div>
 
     {% if bumpable and thread.has_post_limit %}
         <div class="bar-bg">
             <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
             </div>
             <div class="bar-text">
                 <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
             </div>
         </div>
     {% endif %}
 
     <div class="thread">
         {% for post in thread.get_replies %}
-            {% post_view post moderator=moderator reply_link=True %}
+            {% post_view post reply_link=True %}
         {% endfor %}
     </div>
 
-    {% if not thread.archived %}
+    {% if not thread.is_archived %}
         <div class="post-form-w">
             <script src="{% static 'js/panel.js' %}"></script>
             <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}<span class="reply-to-message"> {% trans "to message " %} #<span id="reply-to-message-id"></span></span></div>
             <div class="post-form" id="compact-form">
                 <div class="swappable-form-full">
                     <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                         <div class="compact-form-text"></div>
                         {{ form.as_div }}
                         <div class="form-submit">
                             <input type="submit" value="{% trans "Post" %}"/>
                             <button id="preview-button" onclick="return false;">{% trans 'Preview' %}</button>
                         </div>
                     </form>
                 </div>
                 <div id="preview-text"></div>
+                <div>
+                    {% with size=max_file_size|filesizeformat %}
+                        {% blocktrans %}Max file size is {{ size }}.{% endblocktrans %}
+                    {% endwith %}
+                </div>
                 <div><a href="{% url "staticpage" name="help" %}">
                     {% trans 'Text syntax' %}</a></div>
                 <div><a id="form-close-button" href="#" onClick="resetFormPosition(); return false;">{% trans 'Close form' %}</a></div>
             </div>
         </div>
 
+        <script src="{% static 'js/form.js' %}"></script>
         <script src="{% static 'js/jquery.form.min.js' %}"></script>
+        <script id="sha256Script" src="{% static 'js/3party/sha256.js' %}"></script>
+        <script id="powScript" src="{% static 'js/proof_of_work.js' %}"></script>
+        <script src="{% static 'js/thread.js' %}"></script>
+        <script src="{% static 'js/thread_update.js' %}"></script>
     {% endif %}
 
-    <script src="{% static 'js/form.js' %}"></script>
-    <script src="{% static 'js/thread.js' %}"></script>
-    <script src="{% static 'js/thread_update.js' %}"></script>
     <script src="{% static 'js/3party/centrifuge.js' %}"></script>
 {% endblock %}

boards/templates/boards/thread_tree.html

@@ -1,19 +1,19
 {% extends "boards/thread.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block thread_content %}
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     <div class="thread">
         {% for post in thread.get_top_level_replies %}
-            {% post_view post moderator=moderator mode_tree=True %}
+            {% post_view post mode_tree=True %}
         {% endfor %}
     </div>
 
     <script src="{% static 'js/thread.js' %}"></script>
 {% endblock %}

boards/templatetags/board.py

@@ -1,49 +1,50
 import re
 from django.shortcuts import get_object_or_404
 from django import template
 
 
 IMG_ACTION_URL = '[<a href="{}">{}</a>]'
 
 
 register = template.Library()
 
 actions = [
     {
         'name': 'google',
         'link': 'http://google.com/searchbyimage?image_url=%s',
     },
     {
         'name': 'iqdb',
         'link': 'http://iqdb.org/?url=%s',
     },
 ]
 
 
 @register.simple_tag(name='post_url')
 def post_url(*args, **kwargs):
     post_id = args[0]
 
     post = get_object_or_404('Post', id=post_id)
 
     return post.get_absolute_url()
 
 
 @register.simple_tag(name='image_actions')
 def image_actions(*args, **kwargs):
     image_link = args[0]
     if len(args) > 1:
         image_link = 'http://' + args[1] + image_link  # TODO https?
 
     return ', '.join([IMG_ACTION_URL.format(
         action['link'] % image_link, action['name']) for action in actions])
 
 
[e-mail]_tag(name='post_view')
-def post_view(post, *args, **kwargs):
[e-mail]_tag(name='post_view', takes_context=True)
+def post_view(context, post, *args, **kwargs):
+    kwargs['perms'] = context['perms']
     return post.get_view(*args, **kwargs)
 
 @register.simple_tag(name='page_url')
 def page_url(paginator, page_number, *args, **kwargs):
     if paginator.supports_urls():
         return paginator.get_page_url(page_number)

boards/tests/test_api.py

@@ -1,69 +1,70
 import simplejson
 
 from django.test import TestCase
 from boards.views import api
 
 from boards.models import Tag, Post
 from boards.tests.mocks import MockRequest
 from boards.utils import datetime_to_epoch
 
 
 class ApiTest(TestCase):
     def test_thread_diff(self):
         tag = Tag.objects.create(name='test_tag')
         opening_post = Post.objects.create_post(title='title', text='text',
                                                 tags=[tag])
 
         req = MockRequest()
         req.POST['thread'] = opening_post.id
         req.POST['uids'] = opening_post.uid
         # Check the exact timestamp post was added
         empty_response = api.api_get_threaddiff(req)
         diff = simplejson.loads(empty_response.content)
         self.assertEqual(0, len(diff['updated']),
                          'There must be no updated posts in the diff.')
 
         uids = [opening_post.uid]
 
         reply = Post.objects.create_post(title='',
                                          text='[post]%d[/post]\ntext' % opening_post.id,
                                          thread=opening_post.get_thread())
         req = MockRequest()
         req.POST['thread'] = opening_post.id
         req.POST['uids'] = ' '.join(uids)
+        req.user = None
         # Check the timestamp before post was added
         response = api.api_get_threaddiff(req)
         diff = simplejson.loads(response.content)
         self.assertEqual(2, len(diff['updated']),
                          'There must be 2 updated posts in the diff.')
 
         # Reload post to get the new UID
         opening_post = Post.objects.get(id=opening_post.id)
         req = MockRequest()
         req.POST['thread'] = opening_post.id
         req.POST['uids'] = ' '.join([opening_post.uid, reply.uid])
         empty_response = api.api_get_threaddiff(req)
         diff = simplejson.loads(empty_response.content)
         self.assertEqual(0, len(diff['updated']),
                          'There must be no updated posts in the diff.')
 
     def test_get_threads(self):
         # Create 10 threads
         tag = Tag.objects.create(name='test_tag')
         for i in range(5):
             Post.objects.create_post(title='title', text='text', tags=[tag])
 
         # Get all threads
         response = api.api_get_threads(MockRequest(), 5)
         diff = simplejson.loads(response.content)
         self.assertEqual(5, len(diff), 'Invalid thread list response.')
 
         # Get less threads then exist
         response = api.api_get_threads(MockRequest(), 3)
         diff = simplejson.loads(response.content)
         self.assertEqual(3, len(diff), 'Invalid thread list response.')
 
         # Get more threads then exist
         response = api.api_get_threads(MockRequest(), 10)
         diff = simplejson.loads(response.content)
         self.assertEqual(5, len(diff), 'Invalid thread list response.')

boards/tests/test_post.py

@@ -1,199 +1,200
 from django.core.paginator import Paginator
 from django.test import TestCase
 
 from boards import settings
 from boards.models import Tag, Post, Thread, KeyPair
+from boards.models.thread import STATUS_ARCHIVE
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         tag, created = Tag.objects.get_or_create(name='test_tag')
         return Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
         self.assertIsNotNone(post, 'No post was created.')
         self.assertEqual('test_tag', post.get_thread().tags.all()[0].name,
                          'No tags were added to the post.')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         post.delete()
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_delete_thread(self):
         """Test thread deletion"""
 
         opening_post = self._create_post()
         thread = opening_post.get_thread()
         reply = Post.objects.create_post("", "", thread=thread)
 
         thread.delete()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists(),
                          'Reply was not deleted with the thread.')
         self.assertFalse(Post.objects.filter(id=opening_post.id).exists(),
                          'Opening post was not deleted with the thread.')
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
         post = Post.objects.create_post("", "", thread=op.get_thread())
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
         self.assertEqual(op.get_thread().last_edit_time, post.pub_time,
                          'Post\'s create time doesn\'t match thread last edit'
                          ' time')
 
     def test_delete_posts_by_ip(self):
         """Test deleting posts with the given ip"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_get_thread(self):
         """Test getting all posts of a thread"""
 
         opening_post = self._create_post()
 
         for i in range(2):
             Post.objects.create_post('title', 'text',
                                      thread=opening_post.get_thread())
 
         thread = opening_post.get_thread()
 
         self.assertEqual(3, thread.get_replies().count())
 
     def test_create_post_with_tag(self):
         """Test adding tag to post"""
 
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
 
         thread = post.get_thread()
         self.assertIsNotNone(post, 'Post not created')
         self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.get_int('Messages', 'MaxThreadCount') + 1):
             self._create_post()
 
         self.assertEqual(settings.get_int('Messages', 'MaxThreadCount'),
-                         len(Thread.objects.filter(archived=False)))
+                         len(Thread.objects.exclude(status=STATUS_ARCHIVE)))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.get_int('Messages', 'MaxThreadCount')):
             self._create_post()
 
-        all_threads = Thread.objects.filter(archived=False)
+        all_threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
 
-        paginator = Paginator(Thread.objects.filter(archived=False),
+        paginator = Paginator(Thread.objects.exclude(status=STATUS_ARCHIVE),
                               settings.get_int('View', 'ThreadsPerPage'))
         posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.get_int('View', 'ThreadsPerPage')].id,
                          first_post.id)
 
     def test_reflinks(self):
         """
         Tests that reflinks are parsed within post and connecting replies
         to the replied posts.
 
         Local reflink example: [post]123[/post]
         Global reflink example: [post]key_type::key::123[/post]
         """
 
         key = KeyPair.objects.generate_key(primary=True)
 
         tag = Tag.objects.create(name='test_tag')
 
         post = Post.objects.create_post(title='', text='', tags=[tag])
         post_local_reflink = Post.objects.create_post(title='',
                 text='[post]%d[/post]' % post.id, thread=post.get_thread())
 
         self.assertTrue(post_local_reflink in post.referenced_posts.all(),
             'Local reflink not connecting posts.')
 
 
     def test_thread_replies(self):
         """
         Tests that the replies can be queried from a thread in all possible
         ways.
         """
 
         tag = Tag.objects.create(name='test_tag')
         opening_post = Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
         thread = opening_post.get_thread()
 
         Post.objects.create_post(title='title', text='text', thread=thread)
         Post.objects.create_post(title='title', text='text', thread=thread)
 
         replies = thread.get_replies()
         self.assertTrue(len(replies) > 0, 'No replies found for thread.')
 
         replies = thread.get_replies(view_fields_only=True)
         self.assertTrue(len(replies) > 0,
                 'No replies found for thread with view fields only.')
 
     def test_bumplimit(self):
         """
         Tests that the thread bumpable status is changed and post uids and
         last update times are updated across all post threads.
         """
 
         op1 = Post.objects.create_post(title='title', text='text')
         op2 = Post.objects.create_post(title='title', text='text')
 
         thread1 = op1.get_thread()
         thread1.max_posts = 5
         thread1.save()
 
         uid_1 = op1.uid
         uid_2 = op2.uid
 
         # Create multi reply
         Post.objects.create_post(
             title='title', text='text', thread=thread1,
             opening_posts=[op1, op2])
         thread_update_time_2 = op2.get_thread().last_edit_time
         for i in range(6):
             Post.objects.create_post(title='title', text='text',
                                      thread=thread1)
 
         self.assertFalse(op1.get_thread().can_bump(),
                          'Thread is bumpable when it should not be.')
         self.assertTrue(op2.get_thread().can_bump(),
                         'Thread is not bumpable when it should be.')
         self.assertNotEqual(
             uid_1, Post.objects.get(id=op1.id).uid,
             'UID of the first OP should be changed but it is not.')
         self.assertEqual(
             uid_2, Post.objects.get(id=op2.id).uid,
             'UID of the first OP should not be changed but it is.')
 
         self.assertNotEqual(
             thread_update_time_2,
             Thread.objects.get(id=op2.get_thread().id).last_edit_time,
             'Thread last update time should change when the other thread '
             'changes status.')

boards/tests/test_views.py

@@ -1,48 +1,46
 import logging
 from django.core.urlresolvers import reverse, NoReverseMatch
 from django.test import TestCase, Client
 from boards import urls
 
 
 logger = logging.getLogger(__name__)
 
 HTTP_CODE_OK = 200
 
 EXCLUDED_VIEWS = {
     'banned',
     'get_thread_diff',
     'api_sync_pull',
 }
 
 
 class ViewTest(TestCase):
 
     def test_all_views(self):
         """
         Try opening all views defined in ulrs.py that don't need additional
         parameters
         """
 
         client = Client()
         for url in urls.urlpatterns:
             try:
                 view_name = url.name
                 if view_name in EXCLUDED_VIEWS:
                     logger.debug('View {} is excluded.'.format(view_name))
                     continue
 
                 logger.debug('Testing view %s' % view_name)
 
                 try:
                     response = client.get(reverse(view_name))
 
                     self.assertEqual(HTTP_CODE_OK, response.status_code,
                             'View not opened: {}'.format(view_name))
                 except NoReverseMatch:
                     # This view just needs additional arguments
                     pass
-                except Exception as e:
-                    self.fail('Got exception %s at %s view' % (e, view_name))
             except AttributeError:
                 # This is normal, some views do not have names
                 pass

boards/urls.py

@@ -1,92 +1,96
 from django.conf.urls import patterns, url
-from django.views.i18n import javascript_catalog
+#from django.views.i18n import javascript_catalog
 
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags, feed
 from boards.views.authors import AuthorsView
 from boards.views.notifications import NotificationView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.preview import PostPreviewView
 from boards.views.sync import get_post_sync_data, response_get, response_pull
 from boards.views.random import RandomImageView
+from boards.views.tag_gallery import TagGalleryView
+from boards.views.translation import cached_javascript_catalog
 
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\d+)/$', views.thread.NormalThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\d+)/mode/gallery/$', views.thread.GalleryThreadView.as_view(),
         name='thread_gallery'),
     url(r'^thread/(?P<post_id>\d+)/mode/tree/$', views.thread.TreeThreadView.as_view(),
         name='thread_tree'),
     # /feed/
     url(r'^feed/$', views.feed.FeedView.as_view(), name='feed'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/(?P<query>\w+)?/?$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     url(r'^random/$', RandomImageView.as_view(), name='random'),
+    url(r'^tag/(?P<tag_name>\w+)/gallery/$', TagGalleryView.as_view(), name='tag_gallery'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\d+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\d+)/rss/$', ThreadPostsFeed()),
 
     # i18n
-    url(r'^jsi18n/$', javascript_catalog, js_info_dict,
+    url(r'^jsi18n/$', cached_javascript_catalog, js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\d+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/$', api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
     url(r'^api/notifications/(?P<username>\w+)/$', api.api_get_notifications,
             name='api_notifications'),
     url(r'^api/preview/$', api.api_get_preview, name='preview'),
     url(r'^api/new_posts/$', api.api_get_new_posts, name='new_posts'),
 
     # Sync protocol API
     url(r'^api/sync/pull/$', response_pull, name='api_sync_pull'),
     url(r'^api/sync/get/$', response_get, name='api_sync_pull'),
     # TODO 'get' request
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
     # Notifications
-    url(r'^notifications/(?P<username>\w+)$', NotificationView.as_view(), name='notifications'),
+    url(r'^notifications/(?P<username>\w+)/$', NotificationView.as_view(), name='notifications'),
+    url(r'^notifications/$', NotificationView.as_view(), name='notifications'),
 
     # Post preview
     url(r'^preview/$', PostPreviewView.as_view(), name='preview'),
 
     url(r'^post_xml/(?P<post_id>\d+)$', get_post_sync_data,
         name='post_sync_data'),
 
 )

boards/utils.py

@@ -1,148 +1,144
 """
 This module contains helper functions and helper classes.
 """
 import hashlib
 from random import random
 import time
 import hmac
 
 from django.core.cache import cache
 from django.db.models import Model
 from django import forms
+from django.template.defaultfilters import filesizeformat
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
 import magic
 from portage import os
 
 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'
 
 UPLOAD_DIRS ={
     'PostImage': 'images/',
     'Attachment': 'files/',
 }
 FILE_EXTENSION_DELIMITER = '.'
 
 
 def is_anonymous_mode():
     return get_bool(SETTING_MESSAGES, SETTING_ANON_MODE)
 
 
 def get_client_ip(request):
     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(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
 
 
+# TODO Test this carefully
 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.
+    object name, model id if object is a Django model, args and kwargs if any.
     """
     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__]
+
+            cache_key_params += args
+            for key, value in kwargs:
+                cache_key_params.append(key + ':' + value)
+
             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))
+            _('File must be less than %s but is %s.')
+            % (filesizeformat(max_size), filesizeformat(size)))
 
 
 def get_extension(filename):
     return filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
 
 def get_upload_filename(model_instance, old_filename):
     # TODO Use something other than random number in file name
     extension = get_extension(old_filename)
     new_name = '{}{}.{}'.format(
         str(int(time.mktime(time.gmtime()))),
         str(int(random() * 1000)),
         extension)
 
     directory = UPLOAD_DIRS[type(model_instance).__name__]
 
     return os.path.join(directory, new_name)
 
 
 def get_file_mimetype(file) -> str:
     return magic.from_buffer(file.chunks().__next__(), mime=True).decode()

boards/views/all_threads.py

@@ -1,157 +1,163
+from dbus.decorators import method
 from django.core.urlresolvers import reverse
 from django.core.files import File
 from django.core.files.temp import NamedTemporaryFile
 from django.core.paginator import EmptyPage
 from django.db import transaction
 from django.http import Http404
 from django.shortcuts import render, redirect
 import requests
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_protect
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban, Tag, PostImage, Banner
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
-
+from boards.views.mixins import FileUploadMixin, PaginatedMixin
 
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 PARAMETER_BANNERS = 'banners'
 PARAMETER_ADDITIONAL = 'additional_params'
-
-PARAMETER_PREV_LINK = 'prev_page_link'
-PARAMETER_NEXT_LINK = 'next_page_link'
+PARAMETER_MAX_FILE_SIZE = 'max_file_size'
+PARAMETER_RSS_URL = 'rss_url'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
-class AllThreadsView(PostMixin, BaseBoardView):
+class AllThreadsView(PostMixin, FileUploadMixin, BaseBoardView, PaginatedMixin):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
+    @method_decorator(csrf_protect)
     def get(self, request, form: ThreadForm=None):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
         order = request.GET.get('order', 'bump')
         if order == 'bump':
             threads = threads.order_by('-bump_time')
         else:
             threads = threads.filter(multi_replies__opening=True).order_by('-multi_replies__pub_time')
 
         paginator = get_paginator(threads,
                                   settings.get_int('View', 'ThreadsPerPage'))
         paginator.current_page = int(page)
 
         try:
             threads = paginator.page(page).object_list
         except EmptyPage:
             raise Http404()
 
         params[PARAMETER_THREADS] = threads
         params[CONTEXT_FORM] = form
         params[PARAMETER_BANNERS] = Banner.objects.order_by('-id').all()
+        params[PARAMETER_MAX_FILE_SIZE] = self.get_max_upload_size()
+        params[PARAMETER_RSS_URL] = self.get_rss_url()
 
         paginator.set_url(self.get_reverse_url(), request.GET.dict())
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
+    @method_decorator(csrf_protect)
     def post(self, request):
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return self.create_thread(request, form)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             self._ban_current_user(request)
 
         return self.get(request, form)
 
     def get_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
         params[PARAMETER_PAGINATOR] = paginator
         current_page = paginator.page(int(page))
         params[PARAMETER_CURRENT_PAGE] = current_page
-        if current_page.has_previous():
-            params[PARAMETER_PREV_LINK] = paginator.get_page_url(
-                    current_page.previous_page_number())
-        if current_page.has_next():
-            params[PARAMETER_NEXT_LINK] = paginator.get_page_url(
-                    current_page.next_page_number())
+        self.set_page_urls(paginator, params)
 
     def get_reverse_url(self):
         return reverse('index')
 
     @transaction.atomic
     def create_thread(self, request, form: ThreadForm, html_response=True):
         """
         Creates a new thread with an opening post.
         """
 
         ip = utils.get_client_ip(request)
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         if is_banned:
             if html_response:
                 return redirect(BannedView().as_view())
             else:
                 return
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         file = form.get_file()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         tags = data[FORM_TAGS]
+        monochrome = form.is_monochrome()
 
         post = Post.objects.create_post(title=title, text=text, file=file,
                                         ip=ip, tags=tags, opening_posts=threads,
-                                        tripcode=form.get_tripcode())
+                                        tripcode=form.get_tripcode(),
+                                        monochrome=monochrome)
 
         # This is required to update the threads to which posts we have replied
         # when creating this one
         post.notify_clients()
 
         if html_response:
             return redirect(post.get_absolute_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         return Thread.objects\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())
+
+    def get_rss_url(self):
+        return self.get_reverse_url() + 'rss/'

boards/views/api.py

@@ -1,296 +1,295
-from collections import OrderedDict
 import json
 import logging
 
-import xml.etree.ElementTree as ET
-
+from django.core import serializers
 from django.db import transaction
-from django.db.models import Count
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
-from django.core import serializers
-from boards.abstracts.settingsmanager import get_settings_manager,\
-        FAV_THREAD_NO_UPDATES
+from django.views.decorators.csrf import csrf_protect
 
+from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
-from boards.models import Post, Thread, Tag, GlobalId
-from boards.models.post.sync import SyncManager
+from boards.mdx_neboard import Parser
+from boards.models import Post, Thread, Tag
+from boards.models.thread import STATUS_ARCHIVE
+from boards.models.user import Notification
 from boards.utils import datetime_to_epoch
 from boards.views.thread import ThreadView
-from boards.models.user import Notification
-from boards.mdx_neboard import Parser
-
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_POST = 'post'
 PARAMETER_UPDATED = 'updated'
 PARAMETER_LAST_UPDATE = 'last_update'
 PARAMETER_THREAD = 'thread'
 PARAMETER_UIDS = 'uids'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 STATUS_OK = 'ok'
 STATUS_ERROR = 'error'
 
 logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
 def api_get_threaddiff(request):
     """
     Gets posts that were changed or added since time
     """
 
     thread_id = request.POST.get(PARAMETER_THREAD)
-    uids_str = request.POST.get(PARAMETER_UIDS).strip()
-    uids = uids_str.split(' ')
+    uids_str = request.POST.get(PARAMETER_UIDS)
+
+    if not thread_id or not uids_str:
+        return HttpResponse(content='Invalid request.')
+
+    uids = uids_str.strip().split(' ')
 
     opening_post = get_object_or_404(Post, id=thread_id)
     thread = opening_post.get_thread()
 
     json_data = {
         PARAMETER_UPDATED: [],
         PARAMETER_LAST_UPDATE: None,  # TODO Maybe this can be removed already?
     }
     posts = Post.objects.filter(threads__in=[thread]).exclude(uid__in=uids)
 
     diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     for post in posts:
         json_data[PARAMETER_UPDATED].append(post.get_post_data(
             format_type=diff_type, request=request))
     json_data[PARAMETER_LAST_UPDATE] = str(thread.last_edit_time)
 
     # If the tag is favorite, update the counter
     settings_manager = get_settings_manager(request)
     favorite = settings_manager.thread_is_fav(opening_post)
     if favorite:
         settings_manager.add_or_read_fav_thread(opening_post)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
+@csrf_protect
 def api_add_post(request, opening_post_id):
     """
     Adds a post and return the JSON response for it
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     logger.info('Adding post via api...')
 
     status = STATUS_OK
     errors = []
 
     if request.method == 'POST':
         form = PostForm(request.POST, request.FILES, error_class=PlainErrorList)
         form.session = request.session
 
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             # _ban_current_user(request)
             status = STATUS_ERROR
         if form.is_valid():
             post = ThreadView().new_post(request, form, opening_post,
                                          html_response=False)
             if not post:
                 status = STATUS_ERROR
             else:
                 logger.info('Added post #%d via api.' % post.id)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
 
     response = {
         'status': status,
         'errors': errors,
     }
 
     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Gets the html of a post. Used for popups. Post can be truncated if used
     in threads list with 'truncated' get parameter.
     """
 
     post = get_object_or_404(Post, id=post_id)
     truncated = PARAMETER_TRUNCATED in request.GET
 
-    return HttpResponse(content=post.get_view(truncated=truncated))
+    return HttpResponse(content=post.get_view(truncated=truncated, need_op_data=True))
 
 
 def api_get_threads(request, count):
     """
     Gets the JSON thread opening posts list.
     Parameters that can be used for filtering:
     tag, offset (from which thread to get results)
     """
 
     if PARAMETER_TAG in request.GET:
         tag_name = request.GET[PARAMETER_TAG]
         if tag_name is not None:
             tag = get_object_or_404(Tag, name=tag_name)
-            threads = tag.get_threads().filter(archived=False)
+            threads = tag.get_threads().exclude(status=STATUS_ARCHIVE)
     else: 
-        threads = Thread.objects.filter(archived=False)
+        threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
 
     if PARAMETER_OFFSET in request.GET:
         offset = request.GET[PARAMETER_OFFSET]
         offset = int(offset) if offset is not None else 0
     else:
         offset = 0
 
     threads = threads.order_by('-bump_time')
     threads = threads[offset:offset + int(count)]
 
     opening_posts = []
     for thread in threads:
         opening_post = thread.get_opening_post()
 
         # TODO Add tags, replies and images count
         post_data = opening_post.get_post_data(include_last_update=True)
-        post_data['bumpable'] = thread.can_bump()
-        post_data['archived'] = thread.archived
+        post_data['status'] = thread.get_status()
 
         opening_posts.append(post_data)
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Gets all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
     tags = Tag.objects.get_not_empty_tags()
 
     term = request.GET.get('term')
     if term is not None:
         tags = tags.filter(name__contains=term)
 
     tag_names = [tag.name for tag in tags]
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Gets the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.get_thread()
     posts = thread.get_replies()
 
     json_data = {
         'posts': [],
         'last_update': None,
     }
     json_post_list = []
 
     for post in posts:
         json_post_list.append(post.get_post_data())
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_get_notifications(request, username):
     last_notification_id_str = request.GET.get('last', None)
     last_id = int(last_notification_id_str) if last_notification_id_str is not None else None
 
-    posts = Notification.objects.get_notification_posts(username=username,
+    posts = Notification.objects.get_notification_posts(usernames=username,
                                                         last=last_id)
 
     json_post_list = []
     for post in posts:
         json_post_list.append(post.get_post_data())
     return HttpResponse(content=json.dumps(json_post_list))
 
 
 def api_get_post(request, post_id):
     """
     Gets the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
 def api_get_preview(request):
     raw_text = request.POST['raw_text']
 
     parser = Parser()
     return HttpResponse(content=parser.parse(parser.preparse(raw_text)))
 
 
 def api_get_new_posts(request):
     """
     Gets favorite threads and unread posts count.
     """
     posts = list()
 
     include_posts = 'include_posts' in request.GET
 
     settings_manager = get_settings_manager(request)
     fav_threads = settings_manager.get_fav_threads()
     fav_thread_ops = Post.objects.filter(id__in=fav_threads.keys())\
         .order_by('-pub_time').prefetch_related('thread')
 
     ops = [{'op': op, 'last_id': fav_threads[str(op.id)]} for op in fav_thread_ops]
     if include_posts:
         new_post_threads = Thread.objects.get_new_posts(ops)
         if new_post_threads:
             thread_ids = {thread.id: thread for thread in new_post_threads}
         else:
             thread_ids = dict()
 
         for op in fav_thread_ops:
             fav_thread_dict = dict()
 
             op_thread = op.get_thread()
             if op_thread.id in thread_ids:
                 thread = thread_ids[op_thread.id]
                 new_post_count = thread.new_post_count
                 fav_thread_dict['newest_post_link'] = thread.get_replies()\
                         .filter(id__gt=fav_threads[str(op.id)])\
                         .first().get_absolute_url(thread=thread)
             else:
                 new_post_count = 0
             fav_thread_dict['new_post_count'] = new_post_count
 
             fav_thread_dict['id'] = op.id
 
             fav_thread_dict['post_url'] = op.get_link_view()
             fav_thread_dict['title'] = op.title
 
             posts.append(fav_thread_dict)
     else:
         fav_thread_dict = dict()
         fav_thread_dict['new_post_count'] = \
             Thread.objects.get_new_post_count(ops)
         posts.append(fav_thread_dict)
 
     return HttpResponse(content=json.dumps(posts))

boards/views/authors.py

@@ -1,13 +1,34
+import os
+
 from django.shortcuts import render
 
+import neboard
 from boards.authors import authors
+from boards.utils import cached_result
 from boards.views.base import BaseBoardView
+from boards.models import Post
+
+
+PARAM_AUTHORS = 'authors'
+PARAM_MEDIA_SIZE = 'media_size'
+PARAM_POST_COUNT = 'post_count'
 
 
 class AuthorsView(BaseBoardView):
 
     def get(self, request):
         params = dict()
-        params['authors'] = authors
+        params[PARAM_AUTHORS] = authors
+        params[PARAM_MEDIA_SIZE] = self._get_directory_size(neboard.settings.MEDIA_ROOT)
+        params[PARAM_POST_COUNT] = Post.objects.count()
 
         return render(request, 'boards/authors.html', params)
+
+    @cached_result()
+    def _get_directory_size(self, directory):
+        total_size = 0
+        for dirpath, dirnames, filenames in os.walk(directory):
+            for f in filenames:
+                fp = os.path.join(dirpath, f)
+                total_size += os.path.getsize(fp)
+        return total_size

boards/views/mixins.py

@@ -1,26 +1,40
+import boards
+
+
 PARAM_NEXT = 'next'
 PARAMETER_METHOD = 'method'
 
 
 class DispatcherMixin:
     """
     This class contains a dispather method that can run a method specified by
     'method' request parameter.
     """
 
     def __init__(self):
         self.user = None
 
     def dispatch_method(self, *args, **kwargs):
         request = args[0]
 
         self.user = request.user
 
         method_name = None
         if PARAMETER_METHOD in request.GET:
             method_name = request.GET[PARAMETER_METHOD]
         elif PARAMETER_METHOD in request.POST:
             method_name = request.POST[PARAMETER_METHOD]
 
         if method_name:
             return getattr(self, method_name)(*args, **kwargs)
+
+
+class FileUploadMixin:
+    def get_max_upload_size(self):
+        return boards.settings.get_int('Forms', 'MaxFileSize')
+
+
+class PaginatedMixin:
+    def set_page_urls(self, paginator, params):
+        params['prev_page_link'] = paginator.get_prev_page_url()
+        params['next_page_link'] = paginator.get_next_page_url()

boards/views/notifications.py

@@ -1,46 +1,49
 from django.shortcuts import render
 
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_USERNAME, SETTING_LAST_NOTIFICATION_ID
 from boards.models.user import Notification
 from boards.views.base import BaseBoardView
 
 DEFAULT_PAGE = '1'
 
 TEMPLATE = 'boards/notifications.html'
 PARAM_PAGE = 'page'
-PARAM_USERNAME = 'notification_username'
+PARAM_USERNAMES = 'notification_usernames'
 REQUEST_PAGE = 'page'
 RESULTS_PER_PAGE = 10
 
 
 class NotificationView(BaseBoardView):
 
-    def get(self, request, username):
+    def get(self, request, username=None):
         params = self.get_context_data()
 
         settings_manager = get_settings_manager(request)
 
         # If we open our notifications, reset the "new" count
-        my_username = settings_manager.get_setting(SETTING_USERNAME)
-
-        notification_username = username.lower()
+        if username is None:
+            notification_usernames = settings_manager.get_notification_usernames()
+        else:
+            notification_usernames = [username]
 
         posts = Notification.objects.get_notification_posts(
-            username=notification_username)
-        if notification_username == my_username:
+                usernames=notification_usernames)
+
+        if username is None:
             last = posts.first()
             if last is not None:
                 last_id = last.id
                 settings_manager.set_setting(SETTING_LAST_NOTIFICATION_ID,
                                              last_id)
 
+
         paginator = get_paginator(posts, RESULTS_PER_PAGE)
 
         page = int(request.GET.get(REQUEST_PAGE, DEFAULT_PAGE))
 
         params[PARAM_PAGE] = paginator.page(page)
-        params[PARAM_USERNAME] = notification_username
+        params[PARAM_USERNAMES] = notification_usernames
 
         return render(request, TEMPLATE, params)

boards/views/thread/normal.py

@@ -1,30 +1,33
 from boards.views.thread import ThreadView
+from boards.views.mixins import FileUploadMixin
 
 TEMPLATE_NORMAL = 'boards/thread_normal.html'
 
 CONTEXT_BUMPLIMIT_PRG = 'bumplimit_progress'
 CONTEXT_POSTS_LEFT = 'posts_left'
 CONTEXT_BUMPABLE = 'bumpable'
+PARAM_MAX_FILE_SIZE = 'max_file_size'
 
 
-class NormalThreadView(ThreadView):
+class NormalThreadView(ThreadView, FileUploadMixin):
 
     def get_template(self):
         return TEMPLATE_NORMAL
 
     def get_mode(self):
         return 'normal'
 
     def get_data(self, thread):
         params = dict()
 
         bumpable = thread.can_bump()
         params[CONTEXT_BUMPABLE] = bumpable
         max_posts = thread.max_posts
         if bumpable and thread.has_post_limit():
             left_posts = max_posts - thread.get_reply_count()
             params[CONTEXT_POSTS_LEFT] = left_posts
             params[CONTEXT_BUMPLIMIT_PRG] = str(
                 float(left_posts) / max_posts * 100)
+        params[PARAM_MAX_FILE_SIZE] = self.get_max_upload_size()
 
         return params

boards/views/thread/thread.py

@@ -1,173 +1,175
 from django.contrib.auth.decorators import permission_required
 
 from django.core.exceptions import ObjectDoesNotExist
+from django.core.urlresolvers import reverse
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
+from django.template.context_processors import csrf
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_protect
 from django.views.generic.edit import FormMixin
 from django.utils import timezone
 from django.utils.dateformat import format
 
 from boards import utils, settings
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.views.posting_mixin import PostMixin
 import neboard
 
 REQ_POST_ID = 'post_id'
 
 CONTEXT_LASTUPDATE = "last_update"
 CONTEXT_THREAD = 'thread'
 CONTEXT_WS_TOKEN = 'ws_token'
 CONTEXT_WS_PROJECT = 'ws_project'
 CONTEXT_WS_HOST = 'ws_host'
 CONTEXT_WS_PORT = 'ws_port'
 CONTEXT_WS_TIME = 'ws_token_time'
 CONTEXT_MODE = 'mode'
 CONTEXT_OP = 'opening_post'
 CONTEXT_FAVORITE = 'is_favorite'
+CONTEXT_RSS_URL = 'rss_url'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin, DispatcherMixin):
 
+    @method_decorator(csrf_protect)
     def get(self, request, post_id, form: PostForm=None):
         try:
             opening_post = Post.objects.get(id=post_id)
         except ObjectDoesNotExist:
             raise Http404
 
         # If the tag is favorite, update the counter
         settings_manager = get_settings_manager(request)
         favorite = settings_manager.thread_is_fav(opening_post)
         if favorite:
             settings_manager.add_or_read_fav_thread(opening_post)
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             return redirect(opening_post.get_thread().get_opening_post()
                             .get_absolute_url())
 
         if not form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.get_thread()
 
         params = dict()
 
         params[CONTEXT_FORM] = form
         params[CONTEXT_LASTUPDATE] = str(thread_to_show.last_edit_time)
         params[CONTEXT_THREAD] = thread_to_show
         params[CONTEXT_MODE] = self.get_mode()
         params[CONTEXT_OP] = opening_post
         params[CONTEXT_FAVORITE] = favorite
+        params[CONTEXT_RSS_URL] = self.get_rss_url(post_id)
 
         if settings.get_bool('External', 'WebsocketsEnabled'):
             token_time = format(timezone.now(), u'U')
 
             params[CONTEXT_WS_TIME] = token_time
             params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
                 timestamp=token_time)
             params[CONTEXT_WS_PROJECT] = neboard.settings.CENTRIFUGE_PROJECT_ID
             params[CONTEXT_WS_HOST] = request.get_host().split(':')[0]
             params[CONTEXT_WS_PORT] = neboard.settings.CENTRIFUGE_PORT
 
         params.update(self.get_data(thread_to_show))
 
         return render(request, self.get_template(), params)
 
+    @method_decorator(csrf_protect)
     def post(self, request, post_id):
         opening_post = get_object_or_404(Post, id=post_id)
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             raise Http404
 
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request, opening_post)
 
             return redirect('thread', post_id)  # FIXME Different for different modes
 
-        if not opening_post.get_thread().archived:
+        if not opening_post.get_thread().is_archived():
             form = PostForm(request.POST, request.FILES,
                             error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.new_post(request, form, opening_post)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, post_id, form)
 
     def new_post(self, request, form: PostForm, opening_post: Post=None,
                  html_response=True):
         """
         Adds a new post (in thread or as a reply).
         """
 
         ip = utils.get_client_ip(request)
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         file = form.get_file()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, file=file,
                                         thread=post_thread, ip=ip,
                                         opening_posts=threads,
                                         tripcode=form.get_tripcode())
         post.notify_clients()
 
         if html_response:
             if opening_post:
                 return redirect(post.get_absolute_url())
         else:
             return post
 
     def get_data(self, thread) -> dict:
         """
         Returns context params for the view.
         """
 
         return dict()
 
     def get_template(self) -> str:
         """
         Gets template to show the thread mode on.
         """
 
         pass
 
     def get_mode(self) -> str:
         pass
 
     def subscribe(self, request, opening_post):
         settings_manager = get_settings_manager(request)
         settings_manager.add_or_read_fav_thread(opening_post)
 
     def unsubscribe(self, request, opening_post):
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_thread(opening_post)
 
-    @permission_required('boards.post_hide_unhide')
-    def toggle_hide_post(self, request, opening_post):
-        post_id = request.GET.get(REQ_POST_ID)
-
-        if post_id:
-            post = get_object_or_404(Post, id=post_id)
-            post.set_hidden(not post.is_hidden())
-            post.save(update_fields=['hidden'])
+    def get_rss_url(self, opening_id):
+        return reverse('thread', kwargs={'post_id': opening_id}) + 'rss/'

neboard/settings.py

@@ -1,240 +1,241
 # 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.
 	'CONN_MAX_AGE': None,
     }
 }
 
 # 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 = 'en'
 
 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
 
 USE_ETAGS = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = './media/' 
 
 # 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 = '/media/'
 
 # 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',
 )
 
 if DEBUG:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.StaticFilesStorage'
 else:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
 
 # 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',
-)
+TEMPLATES = [{
+    'BACKEND': 'django.template.backends.django.DjangoTemplates',
+    'DIRS': ['templates'],
+    'OPTIONS': {
+        'loaders': [
+            ('django.template.loaders.cached.Loader', [
+                'django.template.loaders.filesystem.Loader',
+                'django.template.loaders.app_directories.Loader',
+            ]),
+        ],
+        'context_processors': [
+            'django.template.context_processors.csrf',
+            'django.core.context_processors.media',
+            'django.core.context_processors.static',
+            'django.core.context_processors.request',
+            'django.contrib.auth.context_processors.auth',
+            'boards.context_processors.user_and_ui_processor',
+        ],
+    },
+}]
 
-TEMPLATE_CONTEXT_PROCESSORS = (
-    'django.core.context_processors.media',
-    'django.core.context_processors.static',
-    'django.core.context_processors.request',
-    'django.contrib.auth.context_processors.auth',
-    'boards.context_processors.user_and_ui_processor',
-)
 
 MIDDLEWARE_CLASSES = [
     'django.middleware.http.ConditionalGetMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.locale.LocaleMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'boards.middlewares.BanMiddleware',
     'boards.middlewares.TimezoneMiddleware',
 ]
 
 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.humanize',
 
     'debug_toolbar',
 
     # Search
     'haystack',
 
     '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,
     'formatters': {
         'verbose': {
             'format': '%(levelname)s %(asctime)s %(name)s %(process)d %(thread)d %(message)s'
         },
         'simple': {
             'format': '%(levelname)s %(asctime)s [%(name)s] %(message)s'
         },
     },
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'console': {
             'level': 'DEBUG',
             'class': 'logging.StreamHandler',
             'formatter': 'simple'
         },
     },
     'loggers': {
         'boards': {
             'handlers': ['console'],
             'level': 'DEBUG',
         }
     },
 }
 
 HAYSTACK_CONNECTIONS = {
     'default': {
         'ENGINE': 'haystack.backends.whoosh_backend.WhooshEngine',
         'PATH': os.path.join(os.path.dirname(__file__), 'whoosh_index'),
     },
 }
 
 THEMES = [
     ('md', 'Mystic Dark'),
     ('md_centered', 'Mystic Dark (centered)'),
     ('sw', 'Snow White'),
     ('pg', 'Photon Gray'),
 ]
 
 IMAGE_VIEWERS = [
     ('simple', 'Simple'),
     ('popup', 'Popup'),
 ]
 
 ALLOWED_HOSTS = ['*']
 
 POSTING_DELAY = 20  # seconds
 
 # Websocket settins
 CENTRIFUGE_HOST = 'localhost'
 CENTRIFUGE_PORT = '9090'
 
 CENTRIFUGE_ADDRESS = 'http://{}:{}'.format(CENTRIFUGE_HOST, CENTRIFUGE_PORT)
 CENTRIFUGE_PROJECT_ID = '<project id here>'
 CENTRIFUGE_PROJECT_SECRET = '<project secret here>'
 CENTRIFUGE_TIMEOUT = 5
 
 # Debug middlewares
 MIDDLEWARE_CLASSES += [
     'debug_toolbar.middleware.DebugToolbarMiddleware',
 ]
 
 def custom_show_toolbar(request):
     return request.user.has_perm('admin.debug')
 
 DEBUG_TOOLBAR_CONFIG = {
     'ENABLE_STACKTRACES': True,
     'SHOW_TOOLBAR_CALLBACK': 'neboard.settings.custom_show_toolbar',
 }
 
 # FIXME Uncommenting this fails somehow. Need to investigate this
 #DEBUG_TOOLBAR_PANELS += (
 #    'debug_toolbar.panels.profiling.ProfilingDebugPanel',
 #)