Merged with default branch

boards/migrations/0002_auto_20141118_2234.py

@@ -0,0 +1,23 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='post',
+            name='text_markup_type',
+        ),
+        migrations.AlterField(
+            model_name='post',
+            name='_text_rendered',
+            field=models.TextField(null=True, blank=True, editable=False),
+        ),
+    ]

boards/migrations/0003_remove_tag_threads.py

@@ -0,0 +1,18 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0002_auto_20141118_2234'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='tag',
+            name='threads',
+        ),
+    ]

boards/migrations/0004_tag_required.py

@@ -0,0 +1,20 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0003_remove_tag_threads'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tag',
+            name='required',
+            field=models.BooleanField(default=False),
+            preserve_default=True,
+        ),
+    ]

boards/static/js/3party/centrifuge.js

@@ -0,0 +1,1256 b''
+/**
+ * Centrifuge javascript client
+ * v0.5.2
+ */
+;(function () {
+    'use strict';
+
+    /**
+     * Oliver Caldwell
+     * http://oli.me.uk/2013/06/01/prototypical-inheritance-done-right/
+     */
+
+    if (!Object.create) {
+        Object.create = (function(){
+            function F(){}
+
+            return function(o){
+                if (arguments.length != 1) {
+                    throw new Error('Object.create implementation only accepts one parameter.');
+                }
+                F.prototype = o;
+                return new F()
+            }
+        })()
+    }
+
+    if (!Array.prototype.indexOf) {
+        Array.prototype.indexOf = function (searchElement /*, fromIndex */) {
+            'use strict';
+            if (this == null) {
+                throw new TypeError();
+            }
+            var n, k, t = Object(this),
+                len = t.length >>> 0;
+
+            if (len === 0) {
+                return -1;
+            }
+            n = 0;
+            if (arguments.length > 1) {
+                n = Number(arguments[1]);
+                if (n != n) { // shortcut for verifying if it's NaN
+                    n = 0;
+                } else if (n != 0 && n != Infinity && n != -Infinity) {
+                    n = (n > 0 || -1) * Math.floor(Math.abs(n));
+                }
+            }
+            if (n >= len) {
+                return -1;
+            }
+            for (k = n >= 0 ? n : Math.max(len - Math.abs(n), 0); k < len; k++) {
+                if (k in t && t[k] === searchElement) {
+                    return k;
+                }
+            }
+            return -1;
+        };
+    }
+
+    function extend(destination, source) {
+        destination.prototype = Object.create(source.prototype);
+        destination.prototype.constructor = destination;
+        return source.prototype;
+    }
+
+    /**
+     * EventEmitter v4.2.3 - git.io/ee
+     * Oliver Caldwell
+     * MIT license
+     * @preserve
+     */
+
+    /**
+     * Class for managing events.
+     * Can be extended to provide event functionality in other classes.
+     *
+     * @class EventEmitter Manages event registering and emitting.
+     */
+    function EventEmitter() {}
+
+    // Shortcuts to improve speed and size
+
+    // Easy access to the prototype
+    var proto = EventEmitter.prototype;
+
+    /**
+     * Finds the index of the listener for the event in it's storage array.
+     *
+     * @param {Function[]} listeners Array of listeners to search through.
+     * @param {Function} listener Method to look for.
+     * @return {Number} Index of the specified listener, -1 if not found
+     * @api private
+     */
+    function indexOfListener(listeners, listener) {
+        var i = listeners.length;
+        while (i--) {
+            if (listeners[i].listener === listener) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    /**
+     * Alias a method while keeping the context correct, to allow for overwriting of target method.
+     *
+     * @param {String} name The name of the target method.
+     * @return {Function} The aliased method
+     * @api private
+     */
+    function alias(name) {
+        return function aliasClosure() {
+            return this[name].apply(this, arguments);
+        };
+    }
+
+    /**
+     * Returns the listener array for the specified event.
+     * Will initialise the event object and listener arrays if required.
+     * Will return an object if you use a regex search. The object contains keys for each matched event. So /ba[rz]/ might return an object containing bar and baz. But only if you have either defined them with defineEvent or added some listeners to them.
+     * Each property in the object response is an array of listener functions.
+     *
+     * @param {String|RegExp} evt Name of the event to return the listeners from.
+     * @return {Function[]|Object} All listener functions for the event.
+     */
+    proto.getListeners = function getListeners(evt) {
+        var events = this._getEvents();
+        var response;
+        var key;
+
+        // Return a concatenated array of all matching events if
+        // the selector is a regular expression.
+        if (typeof evt === 'object') {
+            response = {};
+            for (key in events) {
+                if (events.hasOwnProperty(key) && evt.test(key)) {
+                    response[key] = events[key];
+                }
+            }
+        }
+        else {
+            response = events[evt] || (events[evt] = []);
+        }
+
+        return response;
+    };
+
+    /**
+     * Takes a list of listener objects and flattens it into a list of listener functions.
+     *
+     * @param {Object[]} listeners Raw listener objects.
+     * @return {Function[]} Just the listener functions.
+     */
+    proto.flattenListeners = function flattenListeners(listeners) {
+        var flatListeners = [];
+        var i;
+
+        for (i = 0; i < listeners.length; i += 1) {
+            flatListeners.push(listeners[i].listener);
+        }
+
+        return flatListeners;
+    };
+
+    /**
+     * Fetches the requested listeners via getListeners but will always return the results inside an object. This is mainly for internal use but others may find it useful.
+     *
+     * @param {String|RegExp} evt Name of the event to return the listeners from.
+     * @return {Object} All listener functions for an event in an object.
+     */
+    proto.getListenersAsObject = function getListenersAsObject(evt) {
+        var listeners = this.getListeners(evt);
+        var response;
+
+        if (listeners instanceof Array) {
+            response = {};
+            response[evt] = listeners;
+        }
+
+        return response || listeners;
+    };
+
+    /**
+     * Adds a listener function to the specified event.
+     * The listener will not be added if it is a duplicate.
+     * If the listener returns true then it will be removed after it is called.
+     * If you pass a regular expression as the event name then the listener will be added to all events that match it.
+     *
+     * @param {String|RegExp} evt Name of the event to attach the listener to.
+     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.addListener = function addListener(evt, listener) {
+        var listeners = this.getListenersAsObject(evt);
+        var listenerIsWrapped = typeof listener === 'object';
+        var key;
+
+        for (key in listeners) {
+            if (listeners.hasOwnProperty(key) && indexOfListener(listeners[key], listener) === -1) {
+                listeners[key].push(listenerIsWrapped ? listener : {
+                    listener: listener,
+                    once: false
+                });
+            }
+        }
+
+        return this;
+    };
+
+    /**
+     * Alias of addListener
+     */
+    proto.on = alias('addListener');
+
+    /**
+     * Semi-alias of addListener. It will add a listener that will be
+     * automatically removed after it's first execution.
+     *
+     * @param {String|RegExp} evt Name of the event to attach the listener to.
+     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.addOnceListener = function addOnceListener(evt, listener) {
+        //noinspection JSValidateTypes
+        return this.addListener(evt, {
+            listener: listener,
+            once: true
+        });
+    };
+
+    /**
+     * Alias of addOnceListener.
+     */
+    proto.once = alias('addOnceListener');
+
+    /**
+     * Defines an event name. This is required if you want to use a regex to add a listener to multiple events at once. If you don't do this then how do you expect it to know what event to add to? Should it just add to every possible match for a regex? No. That is scary and bad.
+     * You need to tell it what event names should be matched by a regex.
+     *
+     * @param {String} evt Name of the event to create.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.defineEvent = function defineEvent(evt) {
+        this.getListeners(evt);
+        return this;
+    };
+
+    /**
+     * Uses defineEvent to define multiple events.
+     *
+     * @param {String[]} evts An array of event names to define.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.defineEvents = function defineEvents(evts) {
+        for (var i = 0; i < evts.length; i += 1) {
+            this.defineEvent(evts[i]);
+        }
+        return this;
+    };
+
+    /**
+     * Removes a listener function from the specified event.
+     * When passed a regular expression as the event name, it will remove the listener from all events that match it.
+     *
+     * @param {String|RegExp} evt Name of the event to remove the listener from.
+     * @param {Function} listener Method to remove from the event.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.removeListener = function removeListener(evt, listener) {
+        var listeners = this.getListenersAsObject(evt);
+        var index;
+        var key;
+
+        for (key in listeners) {
+            if (listeners.hasOwnProperty(key)) {
+                index = indexOfListener(listeners[key], listener);
+
+                if (index !== -1) {
+                    listeners[key].splice(index, 1);
+                }
+            }
+        }
+
+        return this;
+    };
+
+    /**
+     * Alias of removeListener
+     */
+    proto.off = alias('removeListener');
+
+    /**
+     * Adds listeners in bulk using the manipulateListeners method.
+     * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. You can also pass it an event name and an array of listeners to be added.
+     * You can also pass it a regular expression to add the array of listeners to all events that match it.
+     * Yeah, this function does quite a bit. That's probably a bad thing.
+     *
+     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.
+     * @param {Function[]} [listeners] An optional array of listener functions to add.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.addListeners = function addListeners(evt, listeners) {
+        // Pass through to manipulateListeners
+        return this.manipulateListeners(false, evt, listeners);
+    };
+
+    /**
+     * Removes listeners in bulk using the manipulateListeners method.
+     * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
+     * You can also pass it an event name and an array of listeners to be removed.
+     * You can also pass it a regular expression to remove the listeners from all events that match it.
+     *
+     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.
+     * @param {Function[]} [listeners] An optional array of listener functions to remove.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.removeListeners = function removeListeners(evt, listeners) {
+        // Pass through to manipulateListeners
+        return this.manipulateListeners(true, evt, listeners);
+    };
+
+    /**
+     * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.
+     * The first argument will determine if the listeners are removed (true) or added (false).
+     * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
+     * You can also pass it an event name and an array of listeners to be added/removed.
+     * You can also pass it a regular expression to manipulate the listeners of all events that match it.
+     *
+     * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
+     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.
+     * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.manipulateListeners = function manipulateListeners(remove, evt, listeners) {
+        var i;
+        var value;
+        var single = remove ? this.removeListener : this.addListener;
+        var multiple = remove ? this.removeListeners : this.addListeners;
+
+        // If evt is an object then pass each of it's properties to this method
+        if (typeof evt === 'object' && !(evt instanceof RegExp)) {
+            for (i in evt) {
+                if (evt.hasOwnProperty(i) && (value = evt[i])) {
+                    // Pass the single listener straight through to the singular method
+                    if (typeof value === 'function') {
+                        single.call(this, i, value);
+                    }
+                    else {
+                        // Otherwise pass back to the multiple function
+                        multiple.call(this, i, value);
+                    }
+                }
+            }
+        }
+        else {
+            // So evt must be a string
+            // And listeners must be an array of listeners
+            // Loop over it and pass each one to the multiple method
+            i = listeners.length;
+            while (i--) {
+                single.call(this, evt, listeners[i]);
+            }
+        }
+
+        return this;
+    };
+
+    /**
+     * Removes all listeners from a specified event.
+     * If you do not specify an event then all listeners will be removed.
+     * That means every event will be emptied.
+     * You can also pass a regex to remove all events that match it.
+     *
+     * @param {String|RegExp} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.removeEvent = function removeEvent(evt) {
+        var type = typeof evt;
+        var events = this._getEvents();
+        var key;
+
+        // Remove different things depending on the state of evt
+        if (type === 'string') {
+            // Remove all listeners for the specified event
+            delete events[evt];
+        }
+        else if (type === 'object') {
+            // Remove all events matching the regex.
+            for (key in events) {
+                //noinspection JSUnresolvedFunction
+                if (events.hasOwnProperty(key) && evt.test(key)) {
+                    delete events[key];
+                }
+            }
+        }
+        else {
+            // Remove all listeners in all events
+            delete this._events;
+        }
+
+        return this;
+    };
+
+    /**
+     * Emits an event of your choice.
+     * When emitted, every listener attached to that event will be executed.
+     * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
+     * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
+     * So they will not arrive within the array on the other side, they will be separate.
+     * You can also pass a regular expression to emit to all events that match it.
+     *
+     * @param {String|RegExp} evt Name of the event to emit and execute listeners for.
+     * @param {Array} [args] Optional array of arguments to be passed to each listener.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.emitEvent = function emitEvent(evt, args) {
+        var listeners = this.getListenersAsObject(evt);
+        var listener;
+        var i;
+        var key;
+        var response;
+
+        for (key in listeners) {
+            if (listeners.hasOwnProperty(key)) {
+                i = listeners[key].length;
+
+                while (i--) {
+                    // If the listener returns true then it shall be removed from the event
+                    // The function is executed either with a basic call or an apply if there is an args array
+                    listener = listeners[key][i];
+
+                    if (listener.once === true) {
+                        this.removeListener(evt, listener.listener);
+                    }
+
+                    response = listener.listener.apply(this, args || []);
+
+                    if (response === this._getOnceReturnValue()) {
+                        this.removeListener(evt, listener.listener);
+                    }
+                }
+            }
+        }
+
+        return this;
+    };
+
+    /**
+     * Alias of emitEvent
+     */
+    proto.trigger = alias('emitEvent');
+
+    //noinspection JSValidateJSDoc,JSCommentMatchesSignature
+    /**
+     * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as opposed to taking a single array of arguments to pass on.
+     * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.
+     *
+     * @param {String|RegExp} evt Name of the event to emit and execute listeners for.
+     * @param {...*} Optional additional arguments to be passed to each listener.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.emit = function emit(evt) {
+        var args = Array.prototype.slice.call(arguments, 1);
+        return this.emitEvent(evt, args);
+    };
+
+    /**
+     * Sets the current value to check against when executing listeners. If a
+     * listeners return value matches the one set here then it will be removed
+     * after execution. This value defaults to true.
+     *
+     * @param {*} value The new value to check for when executing listeners.
+     * @return {Object} Current instance of EventEmitter for chaining.
+     */
+    proto.setOnceReturnValue = function setOnceReturnValue(value) {
+        this._onceReturnValue = value;
+        return this;
+    };
+
+    /**
+     * Fetches the current value to check against when executing listeners. If
+     * the listeners return value matches this one then it should be removed
+     * automatically. It will return true by default.
+     *
+     * @return {*|Boolean} The current value to check for or the default, true.
+     * @api private
+     */
+    proto._getOnceReturnValue = function _getOnceReturnValue() {
+        if (this.hasOwnProperty('_onceReturnValue')) {
+            return this._onceReturnValue;
+        }
+        else {
+            return true;
+        }
+    };
+
+    /**
+     * Fetches the events object and creates one if required.
+     *
+     * @return {Object} The events storage object.
+     * @api private
+     */
+    proto._getEvents = function _getEvents() {
+        return this._events || (this._events = {});
+    };
+
+    /**
+     * Mixes in the given objects into the target object by copying the properties.
+     * @param deep if the copy must be deep
+     * @param target the target object
+     * @param objects the objects whose properties are copied into the target
+     */
+    function mixin(deep, target, objects) {
+        var result = target || {};
+
+        // Skip first 2 parameters (deep and target), and loop over the others
+        for (var i = 2; i < arguments.length; ++i) {
+            var object = arguments[i];
+
+            if (object === undefined || object === null) {
+                continue;
+            }
+
+            for (var propName in object) {
+                //noinspection JSUnfilteredForInLoop
+                var prop = fieldValue(object, propName);
+                //noinspection JSUnfilteredForInLoop
+                var targ = fieldValue(result, propName);
+
+                // Avoid infinite loops
+                if (prop === target) {
+                    continue;
+                }
+                // Do not mixin undefined values
+                if (prop === undefined) {
+                    continue;
+                }
+
+                if (deep && typeof prop === 'object' && prop !== null) {
+                    if (prop instanceof Array) {
+                        //noinspection JSUnfilteredForInLoop
+                        result[propName] = mixin(deep, targ instanceof Array ? targ : [], prop);
+                    } else {
+                        var source = typeof targ === 'object' && !(targ instanceof Array) ? targ : {};
+                        //noinspection JSUnfilteredForInLoop
+                        result[propName] = mixin(deep, source, prop);
+                    }
+                } else {
+                    //noinspection JSUnfilteredForInLoop
+                    result[propName] = prop;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    function fieldValue(object, name) {
+        try {
+            return object[name];
+        } catch (x) {
+            return undefined;
+        }
+    }
+
+    function endsWith(value, suffix) {
+        return value.indexOf(suffix, value.length - suffix.length) !== -1;
+    }
+
+    function stripSlash(value) {
+        if (value.substring(value.length - 1) == "/") {
+            value = value.substring(0, value.length - 1);
+        }
+        return value;
+    }
+
+    function isString(value) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        return typeof value === 'string' || value instanceof String;
+    }
+
+    function isFunction(value) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        return typeof value === 'function';
+    }
+
+    function log(level, args) {
+        if (window.console) {
+            var logger = window.console[level];
+            if (isFunction(logger)) {
+                logger.apply(window.console, args);
+            }
+        }
+    }
+
+    function Centrifuge(options) {
+        this._sockjs = false;
+        this._status = 'disconnected';
+        this._reconnect = true;
+        this._transport = null;
+        this._messageId = 0;
+        this._clientId = null;
+        this._subscriptions = {};
+        this._messages = [];
+        this._isBatching = false;
+        this._config = {
+            retry: 3000,
+            info: null,
+            debug: false,
+            server: null,
+            protocols_whitelist: [
+                'websocket',
+                'xdr-streaming',
+                'xhr-streaming',
+                'iframe-eventsource',
+                'iframe-htmlfile',
+                'xdr-polling',
+                'xhr-polling',
+                'iframe-xhr-polling',
+                'jsonp-polling'
+            ]
+        };
+        if (options) {
+            this.configure(options);
+        }
+    }
+
+    extend(Centrifuge, EventEmitter);
+
+    var centrifuge_proto = Centrifuge.prototype;
+
+    centrifuge_proto._debug = function () {
+        if (this._config.debug === true) {
+            log('debug', arguments);
+        }
+    };
+
+    centrifuge_proto._configure = function (configuration) {
+        this._debug('Configuring centrifuge object with', configuration);
+
+        if (!configuration) {
+            configuration = {};
+        }
+
+        this._config = mixin(false, this._config, configuration);
+
+        if (!this._config.url) {
+            throw 'Missing required configuration parameter \'url\' specifying the Centrifuge server URL';
+        }
+
+        if (!this._config.token) {
+            throw 'Missing required configuration parameter \'token\' specifying the sign of authorization request';
+        }
+
+        if (!this._config.project) {
+            throw 'Missing required configuration parameter \'project\' specifying project ID in Centrifuge';
+        }
+
+        if (!this._config.user && this._config.user !== '') {
+            throw 'Missing required configuration parameter \'user\' specifying user\'s unique ID in your application';
+        }
+
+        if (!this._config.timestamp) {
+            throw 'Missing required configuration parameter \'timestamp\'';
+        }
+
+        this._config.url = stripSlash(this._config.url);
+
+        if (endsWith(this._config.url, 'connection')) {
+            //noinspection JSUnresolvedVariable
+            if (typeof window.SockJS === 'undefined') {
+                throw 'You need to include SockJS client library before Centrifuge javascript client library or use pure Websocket connection endpoint';
+            }
+            this._sockjs = true;
+        }
+    };
+
+    centrifuge_proto._setStatus = function (newStatus) {
+        if (this._status !== newStatus) {
+            this._debug('Status', this._status, '->', newStatus);
+            this._status = newStatus;
+        }
+    };
+
+    centrifuge_proto._isDisconnected = function () {
+        return this._isConnected() === false;
+    };
+
+    centrifuge_proto._isConnected = function () {
+        return this._status === 'connected';
+    };
+
+    centrifuge_proto._nextMessageId = function () {
+        return ++this._messageId;
+    };
+
+    centrifuge_proto._clearSubscriptions = function () {
+        this._subscriptions = {};
+    };
+
+    centrifuge_proto._send = function (messages) {
+        // We must be sure that the messages have a clientId.
+        // This is not guaranteed since the handshake may take time to return
+        // (and hence the clientId is not known yet) and the application
+        // may create other messages.
+        for (var i = 0; i < messages.length; ++i) {
+            var message = messages[i];
+            message.uid = '' + this._nextMessageId();
+
+            if (this._clientId) {
+                message.clientId = this._clientId;
+            }
+
+            this._debug('Send', message);
+            this._transport.send(JSON.stringify(message));
+        }
+    };
+
+    centrifuge_proto._connect = function (callback) {
+
+        this._clientId = null;
+
+        this._reconnect = true;
+
+        this._clearSubscriptions();
+
+        this._setStatus('connecting');
+
+        var self = this;
+
+        if (callback) {
+            this.on('connect', callback);
+        }
+
+        if (this._sockjs === true) {
+            //noinspection JSUnresolvedFunction
+            var sockjs_options = {
+                protocols_whitelist: this._config.protocols_whitelist
+            };
+            if (this._config.server !== null) {
+                sockjs_options['server'] = this._config.server;
+            }
+
+            this._transport = new SockJS(this._config.url, null, sockjs_options);
+
+        } else {
+            this._transport = new WebSocket(this._config.url);
+        }
+
+        this._setStatus('connecting');
+
+        this._transport.onopen = function () {
+
+            var centrifugeMessage = {
+                'method': 'connect',
+                'params': {
+                    'token': self._config.token,
+                    'user': self._config.user,
+                    'project': self._config.project,
+                    'timestamp': self._config.timestamp
+                }
+            };
+
+            if (self._config.info !== null) {
+                self._debug("connect using additional info");
+                centrifugeMessage['params']['info'] = self._config.info;
+            } else {
+                self._debug("connect without additional info");
+            }
+            self.send(centrifugeMessage);
+        };
+
+        this._transport.onerror = function (error) {
+            self._debug(error);
+        };
+
+        this._transport.onclose = function () {
+            self._setStatus('disconnected');
+            self.trigger('disconnect');
+            if (self._reconnect === true) {
+                window.setTimeout(function () {
+                    if (self._reconnect === true) {
+                        self._connect.call(self);
+                    }
+                }, self._config.retry);
+            }
+        };
+
+        this._transport.onmessage = function (event) {
+            var data;
+            data = JSON.parse(event.data);
+            self._debug('Received', data);
+            self._receive(data);
+        };
+    };
+
+    centrifuge_proto._disconnect = function () {
+        this._clientId = null;
+        this._setStatus('disconnected');
+        this._subscriptions = {};
+        this._reconnect = false;
+        this._transport.close();
+    };
+
+    centrifuge_proto._getSubscription = function (channel) {
+        var subscription;
+        subscription = this._subscriptions[channel];
+        if (!subscription) {
+            return null;
+        }
+        return subscription;
+    };
+
+    centrifuge_proto._removeSubscription = function (channel) {
+        try {
+            delete this._subscriptions[channel];
+        } catch (e) {
+            this._debug('nothing to delete for channel ', channel);
+        }
+    };
+
+    centrifuge_proto._connectResponse = function (message) {
+        if (message.error === null) {
+            this._clientId = message.body;
+            this._setStatus('connected');
+            this.trigger('connect', [message]);
+        } else {
+            this.trigger('error', [message]);
+            this.trigger('connect:error', [message]);
+        }
+    };
+
+    centrifuge_proto._disconnectResponse = function (message) {
+        if (message.error === null) {
+            this.disconnect();
+            //this.trigger('disconnect', [message]);
+            //this.trigger('disconnect:success', [message]);
+        } else {
+            this.trigger('error', [message]);
+            this.trigger('disconnect:error', [message.error]);
+        }
+    };
+
+    centrifuge_proto._subscribeResponse = function (message) {
+        if (message.error !== null) {
+            this.trigger('error', [message]);
+        }
+        var body = message.body;
+        if (body === null) {
+            return;
+        }
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        if (message.error === null) {
+            subscription.trigger('subscribe:success', [body]);
+            subscription.trigger('ready', [body]);
+        } else {
+            subscription.trigger('subscribe:error', [message.error]);
+            subscription.trigger('error', [message]);
+        }
+    };
+
+    centrifuge_proto._unsubscribeResponse = function (message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        if (message.error === null) {
+            subscription.trigger('unsubscribe', [body]);
+            this._centrifuge._removeSubscription(channel);
+        }
+    };
+
+    centrifuge_proto._publishResponse = function (message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        if (message.error === null) {
+            subscription.trigger('publish:success', [body]);
+        } else {
+            subscription.trigger('publish:error', [message.error]);
+            this.trigger('error', [message]);
+        }
+    };
+
+    centrifuge_proto._presenceResponse = function (message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        if (message.error === null) {
+            subscription.trigger('presence', [body]);
+            subscription.trigger('presence:success', [body]);
+        } else {
+            subscription.trigger('presence:error', [message.error]);
+            this.trigger('error', [message]);
+        }
+    };
+
+    centrifuge_proto._historyResponse = function (message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        if (message.error === null) {
+            subscription.trigger('history', [body]);
+            subscription.trigger('history:success', [body]);
+        } else {
+            subscription.trigger('history:error', [message.error]);
+            this.trigger('error', [message]);
+        }
+    };
+
+    centrifuge_proto._joinResponse = function(message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        subscription.trigger('join', [body]);
+    };
+
+    centrifuge_proto._leaveResponse = function(message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (!subscription) {
+            return;
+        }
+        subscription.trigger('leave', [body]);
+    };
+
+    centrifuge_proto._messageResponse = function (message) {
+        var body = message.body;
+        var channel = body.channel;
+        var subscription = this.getSubscription(channel);
+        if (subscription === null) {
+            return;
+        }
+        subscription.trigger('message', [body]);
+    };
+
+    centrifuge_proto._dispatchMessage = function(message) {
+        if (message === undefined || message === null) {
+            return;
+        }
+
+        var method = message.method;
+
+        if (!method) {
+            return;
+        }
+
+        switch (method) {
+            case 'connect':
+                this._connectResponse(message);
+                break;
+            case 'disconnect':
+                this._disconnectResponse(message);
+                break;
+            case 'subscribe':
+                this._subscribeResponse(message);
+                break;
+            case 'unsubscribe':
+                this._unsubscribeResponse(message);
+                break;
+            case 'publish':
+                this._publishResponse(message);
+                break;
+            case 'presence':
+                this._presenceResponse(message);
+                break;
+            case 'history':
+                this._historyResponse(message);
+                break;
+            case 'join':
+                this._joinResponse(message);
+                break;
+            case 'leave':
+                this._leaveResponse(message);
+                break;
+            case 'ping':
+                break;
+            case 'message':
+                this._messageResponse(message);
+                break;
+            default:
+                break;
+        }
+    };
+
+    centrifuge_proto._receive = function (data) {
+        if (Object.prototype.toString.call(data) === Object.prototype.toString.call([])) {
+            for (var i in data) {
+                if (data.hasOwnProperty(i)) {
+                    var msg = data[i];
+                    this._dispatchMessage(msg);
+                }
+            }
+        } else if (Object.prototype.toString.call(data) === Object.prototype.toString.call({})) {
+            this._dispatchMessage(data);
+        }
+    };
+
+    centrifuge_proto._flush = function() {
+        var messages = this._messages.slice(0);
+        this._messages = [];
+        this._send(messages);
+    };
+
+    centrifuge_proto._ping = function () {
+        var centrifugeMessage = {
+            "method": "ping",
+            "params": {}
+        };
+        this.send(centrifugeMessage);
+    };
+
+    /* PUBLIC API */
+
+    centrifuge_proto.getClientId = function () {
+        return this._clientId;
+    };
+
+    centrifuge_proto.isConnected = centrifuge_proto._isConnected;
+
+    centrifuge_proto.isDisconnected = centrifuge_proto._isDisconnected;
+
+    centrifuge_proto.configure = function (configuration) {
+        this._configure.call(this, configuration);
+    };
+
+    centrifuge_proto.connect = centrifuge_proto._connect;
+
+    centrifuge_proto.disconnect = centrifuge_proto._disconnect;
+
+    centrifuge_proto.getSubscription = centrifuge_proto._getSubscription;
+
+    centrifuge_proto.ping = centrifuge_proto._ping;
+
+    centrifuge_proto.send = function (message) {
+        if (this._isBatching === true) {
+            this._messages.push(message);
+        } else {
+            this._send([message]);
+        }
+    };
+
+    centrifuge_proto.startBatching = function () {
+        // start collecting messages without sending them to Centrifuge until flush
+        // method called
+        this._isBatching = true;
+    };
+
+    centrifuge_proto.stopBatching = function(flush) {
+        // stop collecting messages
+        flush = flush || false;
+        this._isBatching = false;
+        if (flush === true) {
+            this.flush();
+        }
+    };
+
+    centrifuge_proto.flush = function() {
+        this._flush();
+    };
+
+    centrifuge_proto.subscribe = function (channel, callback) {
+
+        if (arguments.length < 1) {
+            throw 'Illegal arguments number: required 1, got ' + arguments.length;
+        }
+        if (!isString(channel)) {
+            throw 'Illegal argument type: channel must be a string';
+        }
+        if (this.isDisconnected()) {
+            throw 'Illegal state: already disconnected';
+        }
+
+        var current_subscription = this.getSubscription(channel);
+
+        if (current_subscription !== null) {
+            return current_subscription;
+        } else {
+            var subscription = new Subscription(this, channel);
+            this._subscriptions[channel] = subscription;
+            subscription.subscribe(callback);
+            return subscription;
+        }
+    };
+
+    centrifuge_proto.unsubscribe = function (channel) {
+        if (arguments.length < 1) {
+            throw 'Illegal arguments number: required 1, got ' + arguments.length;
+        }
+        if (!isString(channel)) {
+            throw 'Illegal argument type: channel must be a string';
+        }
+        if (this.isDisconnected()) {
+            return;
+        }
+
+        var subscription = this.getSubscription(channel);
+        if (subscription !== null) {
+            subscription.unsubscribe();
+        }
+    };
+
+    centrifuge_proto.publish = function (channel, data, callback) {
+        var subscription = this.getSubscription(channel);
+        if (subscription === null) {
+            this._debug("subscription not found for channel " + channel);
+            return null;
+        }
+        subscription.publish(data, callback);
+        return subscription;
+    };
+
+    centrifuge_proto.presence = function (channel, callback) {
+        var subscription = this.getSubscription(channel);
+        if (subscription === null) {
+            this._debug("subscription not found for channel " + channel);
+            return null;
+        }
+        subscription.presence(callback);
+        return subscription;
+    };
+
+    centrifuge_proto.history = function (channel, callback) {
+        var subscription = this.getSubscription(channel);
+        if (subscription === null) {
+            this._debug("subscription not found for channel " + channel);
+            return null;
+        }
+        subscription.history(callback);
+        return subscription;
+    };
+
+    function Subscription(centrifuge, channel) {
+        /**
+         * The constructor for a centrifuge object, identified by an optional name.
+         * The default name is the string 'default'.
+         * @param name the optional name of this centrifuge object
+         */
+        this._centrifuge = centrifuge;
+        this.channel = channel;
+    }
+
+    extend(Subscription, EventEmitter);
+
+    var sub_proto = Subscription.prototype;
+
+    sub_proto.getChannel = function () {
+        return this.channel;
+    };
+
+    sub_proto.getCentrifuge = function () {
+        return this._centrifuge;
+    };
+
+    sub_proto.subscribe = function (callback) {
+        var centrifugeMessage = {
+            "method": "subscribe",
+            "params": {
+                "channel": this.channel
+            }
+        };
+        this._centrifuge.send(centrifugeMessage);
+        if (callback) {
+            this.on('message', callback);
+        }
+    };
+
+    sub_proto.unsubscribe = function () {
+        this._centrifuge._removeSubscription(this.channel);
+        var centrifugeMessage = {
+            "method": "unsubscribe",
+            "params": {
+                "channel": this.channel
+            }
+        };
+        this._centrifuge.send(centrifugeMessage);
+    };
+
+    sub_proto.publish = function (data, callback) {
+        var centrifugeMessage = {
+            "method": "publish",
+            "params": {
+                "channel": this.channel,
+                "data": data
+            }
+        };
+        if (callback) {
+            this.on('publish:success', callback);
+        }
+        this._centrifuge.send(centrifugeMessage);
+    };
+
+    sub_proto.presence = function (callback) {
+        var centrifugeMessage = {
+            "method": "presence",
+            "params": {
+                "channel": this.channel
+            }
+        };
+        if (callback) {
+            this.on('presence', callback);
+        }
+        this._centrifuge.send(centrifugeMessage);
+    };
+
+    sub_proto.history = function (callback) {
+        var centrifugeMessage = {
+            "method": "history",
+            "params": {
+                "channel": this.channel
+            }
+        };
+        if (callback) {
+            this.on('history', callback);
+        }
+        this._centrifuge.send(centrifugeMessage);
+    };
+
+    // Expose the class either via AMD, CommonJS or the global object
+    if (typeof define === 'function' && define.amd) {
+        define(function () {
+            return Centrifuge;
+        });
+    } else if (typeof module === 'object' && module.exports) {
+        //noinspection JSUnresolvedVariable
+        module.exports = Centrifuge;
+    } else {
+        //noinspection JSUnusedGlobalSymbols
+        this.Centrifuge = Centrifuge;
+    }
+
+}.call(this));

boards/tests/test_parser.py

@@ -0,0 +1,27 b''
+from django.test import TestCase
+from boards.models import Post
+
+
+class ParserTest(TestCase):
+    def test_preparse_quote(self):
+        raw_text = '>quote\nQuote in >line\nLine\n>Quote'
+        preparsed_text = Post.objects._preparse_text(raw_text)
+
+        self.assertEqual(
+            '[quote]quote[/quote]\nQuote in >line\nLine\n[quote]Quote[/quote]',
+            preparsed_text, 'Quote not preparsed.')
+
+    def test_preparse_comment(self):
+        raw_text = '//comment'
+        preparsed_text = Post.objects._preparse_text(raw_text)
+
+        self.assertEqual('[comment]comment[/comment]', preparsed_text,
+                         'Comment not preparsed.')
+
+    def test_preparse_reflink(self):
+        raw_text = '>>12\nText'
+        preparsed_text = Post.objects._preparse_text(raw_text)
+
+        self.assertEqual('[post]12[/post]\nText',
+                         preparsed_text, 'Reflink not preparsed.')
+

tools/neboard.service

@@ -0,0 +1,10 b''
+[Unit]
+Description=Neboard imageboard
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/uwsgi_python33 --ini uwsgi.ini
+WorkingDirectory=<where is your neboard located>
+
+[Install]
+WantedBy=multi-user.target

tools/uwsgi.ini

@@ -0,0 +1,11 b''
+[uwsgi]
+module = neboard.wsgi:application
+master = true
+pidfile = /tmp/neboard.pid
+socket = 127.0.0.1:8080
+processes = 5
+harakiri = 20
+max-requests = 5000
+disable-logging = true
+vacuum = true
+# socket=/var/run/neboard.sock

.hgtags

@@ -1,18 +1,22 b''
 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

boards/abstracts/settingsmanager.py

@@ -1,146 +1,147 b''
 from django.shortcuts import get_object_or_404
 from boards.models import Tag
 
 __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_HIDDEN_TAGS = 'hidden_tags'
 SETTING_PERMISSIONS = 'permissions'
 
 DEFAULT_THEME = 'md'
 
 
 def get_settings_manager(request):
     """
     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)
 
 
 class SettingsManager:
     """
     Base settings manager class. get_setting and set_setting methods should
     be overriden.
     """
     def __init__(self):
         pass
 
     def get_theme(self):
         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):
         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):
         tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         tags = []
         if tag_names:
             for tag_name in tag_names:
                 tag = get_object_or_404(Tag, name=tag_name)
                 tags.append(tag)
         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):
         tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         tags = []
         if tag_names:
             for tag_name in tag_names:
                 tag = get_object_or_404(Tag, name=tag_name)
                 tags.append(tag)
 
         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)
 
 
 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):
         if setting in self.session:
             return self.session[setting]
         else:
             return None
 
     def set_setting(self, setting, value):
         self.session[setting] = value
 

boards/admin.py

@@ -1,43 +1,54 b''
 from django.contrib import admin
 from boards.models import Post, Tag, Ban, Thread, KeyPair
 
 
[e-mail](Post)
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text')
     list_filter = ('pub_time', 'thread_new')
     search_fields = ('id', 'title', 'text')
+    exclude = ('referenced_posts', 'refmap')
+    readonly_fields = ('poster_ip', 'thread_new')
 
 
[e-mail](Tag)
 class TagAdmin(admin.ModelAdmin):
 
-    list_display = ('name',)
+    def thread_count(self, obj: Tag) -> int:
+        return obj.get_thread_count()
 
+    list_display = ('name', 'thread_count')
+    search_fields = ('name',)
+
+
[e-mail](Thread)
 class ThreadAdmin(admin.ModelAdmin):
 
-    def title(self, obj):
-        return obj.get_opening_post().title
+    def title(self, obj: Thread) -> str:
+        return obj.get_opening_post().get_title()
 
-    def reply_count(self, obj):
+    def reply_count(self, obj: Thread) -> int:
         return obj.get_reply_count()
 
-    list_display = ('id', 'title', 'reply_count', 'archived')
-    list_filter = ('bump_time', 'archived')
+    def ip(self, obj: Thread):
+        return obj.get_opening_post().poster_ip
+
+    list_display = ('id', 'title', 'reply_count', 'archived', 'ip')
+    list_filter = ('bump_time', 'archived', 'bumpable')
     search_fields = ('id', 'title')
+    filter_horizontal = ('tags',)
 
 
[e-mail](KeyPair)
 class KeyPairAdmin(admin.ModelAdmin):
     list_display = ('public_key', 'primary')
     list_filter = ('primary',)
     search_fields = ('public_key',)
 
+
[e-mail](Ban)
 class BanAdmin(admin.ModelAdmin):
     list_display = ('ip', 'can_read')
     list_filter = ('can_read',)
     search_fields = ('ip',)
-
-admin.site.register(Post, PostAdmin)
-admin.site.register(Tag, TagAdmin)
-admin.site.register(Ban, BanAdmin)
-admin.site.register(Thread, ThreadAdmin)
-admin.site.register(KeyPair, KeyPairAdmin)

boards/context_processors.py

@@ -1,42 +1,41 b''
-from boards.abstracts.settingsmanager import PERMISSION_MODERATE, \
-    get_settings_manager
+from boards.abstracts.settingsmanager import get_settings_manager
 
 __author__ = 'neko259'
 
 from boards import settings
 from boards.models import Post
 
 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'
 
 PERMISSION_MODERATE = 'moderation'
 
 
 def user_and_ui_processor(request):
-    context = {}
+    context = dict()
 
     context[CONTEXT_PPD] = float(Post.objects.get_posts_per_day())
 
     settings_manager = get_settings_manager(request)
     context[CONTEXT_TAGS] = settings_manager.get_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
     try:
-        moderate = request.user.has_perm('moderation')
+        moderate = request.user.has_perm(PERMISSION_MODERATE)
     except AttributeError:
         moderate = False
     context[CONTEXT_MODERATOR] = moderate
 
     context[CONTEXT_VERSION] = settings.VERSION
     context[CONTEXT_SITE_NAME] = settings.SITE_NAME
 
     return context

boards/forms.py

@@ -1,294 +1,305 b''
 import re
 import time
 import hashlib
 
 from django import forms
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _
 
 from boards.mdx_neboard import formatters
 from boards.models.post import TITLE_MAX_LENGTH
-from boards.models import PostImage
+from boards.models import PostImage, Tag
 from neboard import settings
 from boards import utils
 import boards.settings as board_settings
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 
 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 = _('tag1 several_words_tag')
 
 ERROR_IMAGE_DUPLICATE = _('Such image was already posted')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 TAG_MAX_LENGTH = 20
 
 REGEX_TAG = r'^[\w\d]+$'
 
 
 class FormatPanel(forms.Textarea):
     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)
 
         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):
 
     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>'
                        '<div class="form-row"><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)
     text = forms.CharField(
         widget=FormatPanel(attrs={ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER}),
         required=False, label=LABEL_TEXT)
     image = forms.ImageField(required=False, label=_('Image'),
                              widget=forms.ClearableFileInput(
                                  attrs={'accept': 'image/*'}))
 
     # 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'}))
 
     session = None
     need_to_ban = False
 
     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:
             if len(text) > board_settings.MAX_TEXT_LENGTH:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') %
                                             str(board_settings
                                             .MAX_TEXT_LENGTH))
         return text
 
     def clean_image(self):
         image = self.cleaned_data['image']
         if image:
             if image.size > board_settings.MAX_IMAGE_SIZE:
                 raise forms.ValidationError(
                     _('Image must be less than %s bytes')
                     % str(board_settings.MAX_IMAGE_SIZE))
 
             md5 = hashlib.md5()
             for chunk in image.chunks():
                 md5.update(chunk)
             image_hash = md5.hexdigest()
             if PostImage.objects.filter(hash=image_hash).exists():
                 raise forms.ValidationError(ERROR_IMAGE_DUPLICATE)
 
         return image
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         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_image()
 
         if not self.errors and self.session:
             self._validate_posting_speed()
 
         return cleaned_data
 
     def _clean_text_image(self):
         text = self.cleaned_data.get('text')
         image = self.cleaned_data.get('image')
 
         if (not text) and (not image):
             error_message = _('Either text or image 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.LIMIT_POSTING_SPEED and LAST_POST_TIME in \
                 self.session:
             now = time.time()
             last_post_time = self.session[LAST_POST_TIME]
 
             current_delay = int(now - last_post_time)
 
             if current_delay < posting_delay:
                 error_message = _('Wait %s seconds after last posting') % str(
                     posting_delay - current_delay)
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_POST_TIME] = time.time()
 
 
 class ThreadForm(PostForm):
 
     regex_tags = re.compile(r'^[\w\s\d]+$', re.UNICODE)
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not self.regex_tags.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
+        tag_models = []
+        required_tag_exists = False
+        for tag in tags.split():
+            tag_model = Tag.objects.filter(name=tag.strip().lower(),
+                    required=True)
+            if tag_model.exists():
+                required_tag_exists = True
+
+        if not required_tag_exists:
+            raise forms.ValidationError(_('Need at least 1 required tag.'))
+
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES,
                               label=_('Theme'))
 
 
 class AddTagForm(NeboardForm):
 
     tag = forms.CharField(max_length=TAG_MAX_LENGTH, label=LABEL_TAG)
     method = forms.CharField(widget=forms.HiddenInput(), initial='add_tag')
 
     def clean_tag(self):
         tag = self.cleaned_data['tag']
 
         regex_tag = re.compile(REGEX_TAG, re.UNICODE)
         if not regex_tag.match(tag):
             raise forms.ValidationError(_('Inappropriate characters in tags.'))
 
         return tag
 
     def clean(self):
         cleaned_data = super(AddTagForm, self).clean()
 
         return cleaned_data
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)
 
 
 class LoginForm(NeboardForm):
 
     password = forms.CharField()
 
     session = None
 
     def clean_password(self):
         password = self.cleaned_data['password']
         if board_settings.MASTER_PASSWORD != password:
             raise forms.ValidationError(_('Invalid master password'))
 
         return password
 
     def _validate_login_speed(self):
         can_post = True
 
         if LAST_LOGIN_TIME in self.session:
             now = time.time()
             last_login_time = self.session[LAST_LOGIN_TIME]
 
             current_delay = int(now - last_login_time)
 
             if current_delay < board_settings.LOGIN_TIMEOUT:
                 error_message = _('Wait %s minutes after last login') % str(
                     (board_settings.LOGIN_TIMEOUT - current_delay) / 60)
                 self._errors['password'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         self._validate_login_speed()
 
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data

boards/locale/ru/LC_MESSAGES/django.po

@@ -1,365 +1,370 b''
 # 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: 2014-08-19 15:51+0300\n"
+"POT-Creation-Date: 2015-01-08 16:36+0200\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"
 
 #: 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:22
 msgid "Type message here. Use formatting panel for more advanced usage."
 msgstr ""
 "Вводите сообщение сюда. Используйте панель для более сложного форматирования."
 
 #: forms.py:23
 msgid "tag1 several_words_tag"
-msgstr "тег1 тег_из_нескольких_слов"
+msgstr "метка1 метка_из_нескольких_слов"
 
 #: forms.py:25
 msgid "Such image was already posted"
 msgstr "Такое изображение уже было загружено"
 
 #: forms.py:27
 msgid "Title"
 msgstr "Заголовок"
 
 #: forms.py:28
 msgid "Text"
 msgstr "Текст"
 
 #: forms.py:29
 msgid "Tag"
-msgstr "Тег"
+msgstr "Метка"
 
-#: forms.py:30 templates/boards/base.html:36 templates/search/search.html:9
+#: forms.py:30 templates/boards/base.html:38 templates/search/search.html:9
 #: templates/search/search.html.py:13
 msgid "Search"
 msgstr "Поиск"
 
 #: forms.py:107
 msgid "Image"
 msgstr "Изображение"
 
 #: forms.py:112
 msgid "e-mail"
 msgstr ""
 
 #: forms.py:123
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
 #: forms.py:132
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
 #: forms.py:143
 #, python-format
 msgid "Image must be less than %s bytes"
 msgstr "Изображение должно быть менее %s байт"
 
 #: forms.py:178
 msgid "Either text or image must be entered."
 msgstr "Текст или картинка должны быть введены."
 
-#: forms.py:198
+#: forms.py:194
 #, python-format
 msgid "Wait %s seconds after last posting"
 msgstr "Подождите %s секунд после последнего постинга"
 
-#: forms.py:214 templates/boards/tags.html:7 templates/boards/rss/post.html:10
+#: forms.py:210 templates/boards/rss/post.html:10 templates/boards/tags.html:7
 msgid "Tags"
-msgstr "Теги"
+msgstr "Метки"
 
-#: forms.py:221 forms.py:247
+#: forms.py:217 forms.py:254
 msgid "Inappropriate characters in tags."
-msgstr "Недопустимые символы в тегах."
+msgstr "Недопустимые символы в метках."
 
-#: forms.py:234
+#: forms.py:228
+msgid "Need at least 1 required tag."
+msgstr "Нужна хотя бы 1 обязательная метка."
+
+#: forms.py:241
 msgid "Theme"
 msgstr "Тема"
 
-#: forms.py:270
+#: forms.py:277
 msgid "Invalid master password"
 msgstr "Неверный мастер-пароль"
 
-#: forms.py:284
+#: forms.py:291
 #, python-format
 msgid "Wait %s minutes after last login"
 msgstr "Подождите %s минут после последнего входа"
 
 #: templates/boards/404.html:6
 msgid "Not found"
 msgstr "Не найдено"
 
 #: templates/boards/404.html:12
 msgid "This page does not exist"
 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:12
+#: templates/boards/base.html:13
 msgid "Feed"
 msgstr "Лента"
 
-#: templates/boards/base.html:29
+#: templates/boards/base.html:30
 msgid "All threads"
 msgstr "Все темы"
 
-#: templates/boards/base.html:34
+#: templates/boards/base.html:36
 msgid "Tag management"
-msgstr "Управление тегами"
+msgstr "Управление метками"
 
-#: templates/boards/base.html:37 templates/boards/settings.html:7
+#: templates/boards/base.html:39 templates/boards/settings.html:7
 msgid "Settings"
 msgstr "Настройки"
 
-#: templates/boards/base.html:50
+#: templates/boards/base.html:52
 msgid "Admin"
 msgstr ""
 
-#: templates/boards/base.html:52
+#: templates/boards/base.html:54
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
-#: templates/boards/base.html:54
+#: templates/boards/base.html:56
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/login.html:6 templates/boards/login.html.py:16
 msgid "Login"
 msgstr "Вход"
 
 #: templates/boards/login.html:19
 msgid "Insert your user id above"
 msgstr "Вставьте свой ID пользователя выше"
 
-#: templates/boards/post.html:21 templates/boards/staticpages/help.html:17
+#: templates/boards/post.html:19 templates/boards/staticpages/help.html:17
 msgid "Quote"
 msgstr "Цитата"
 
-#: templates/boards/post.html:31
+#: templates/boards/post.html:27
 msgid "Open"
 msgstr "Открыть"
 
-#: templates/boards/post.html:33
+#: templates/boards/post.html:29
 msgid "Reply"
 msgstr "Ответ"
 
-#: templates/boards/post.html:40
+#: templates/boards/post.html:36
 msgid "Edit"
 msgstr "Изменить"
 
-#: templates/boards/post.html:42
-msgid "Delete"
-msgstr "Удалить"
+#: templates/boards/post.html:39
+msgid "Edit thread"
+msgstr "Изменить тему"
 
-#: templates/boards/post.html:45
-msgid "Ban IP"
-msgstr "Заблокировать IP"
-
-#: templates/boards/post.html:76
+#: templates/boards/post.html:71
 msgid "Replies"
 msgstr "Ответы"
 
-#: templates/boards/post.html:86 templates/boards/thread.html:88
+#: templates/boards/post.html:79 templates/boards/thread.html:89
 #: templates/boards/thread_gallery.html:59
 msgid "messages"
 msgstr "сообщений"
 
-#: templates/boards/post.html:87 templates/boards/thread.html:89
+#: templates/boards/post.html:80 templates/boards/thread.html:90
 #: templates/boards/thread_gallery.html:60
 msgid "images"
 msgstr "изображений"
 
 #: templates/boards/post_admin.html:19
 msgid "Tags:"
-msgstr "Теги:"
+msgstr "Метки:"
 
 #: templates/boards/post_admin.html:30
 msgid "Add tag"
-msgstr "Добавить тег"
+msgstr "Добавить метку"
 
 #: templates/boards/posting_general.html:56
 msgid "Show tag"
-msgstr "Показывать тег"
+msgstr "Показывать метку"
 
 #: templates/boards/posting_general.html:60
 msgid "Hide tag"
-msgstr "Скрывать тег"
+msgstr "Скрывать метку"
 
-#: templates/boards/posting_general.html:79 templates/search/search.html:22
+#: templates/boards/posting_general.html:66
+msgid "Edit tag"
+msgstr "Изменить метку"
+
+#: templates/boards/posting_general.html:82 templates/search/search.html:22
 msgid "Previous page"
 msgstr "Предыдущая страница"
 
-#: templates/boards/posting_general.html:94
+#: templates/boards/posting_general.html:97
 #, python-format
 msgid "Skipped %(count)s replies. Open thread to see all replies."
 msgstr "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
-#: templates/boards/posting_general.html:121 templates/search/search.html:33
+#: templates/boards/posting_general.html:124 templates/search/search.html:33
 msgid "Next page"
 msgstr "Следующая страница"
 
-#: templates/boards/posting_general.html:126
+#: templates/boards/posting_general.html:129
 msgid "No threads exist. Create the first one!"
 msgstr "Нет тем. Создайте первую!"
 
-#: templates/boards/posting_general.html:132
+#: templates/boards/posting_general.html:135
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
-#: templates/boards/posting_general.html:137 templates/boards/preview.html:16
-#: templates/boards/thread.html:58
+#: templates/boards/posting_general.html:140 templates/boards/preview.html:16
+#: templates/boards/thread.html:54
 msgid "Post"
 msgstr "Отправить"
 
-#: templates/boards/posting_general.html:142
+#: templates/boards/posting_general.html:145
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
-"Теги должны быть разделены пробелами. Текст или изображение обязательны."
+"Метки должны быть разделены пробелами. Текст или изображение обязательны."
 
-#: templates/boards/posting_general.html:145 templates/boards/thread.html:66
+#: templates/boards/posting_general.html:148 templates/boards/thread.html:62
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
-#: templates/boards/posting_general.html:157
+#: templates/boards/posting_general.html:160
 msgid "Pages:"
 msgstr "Страницы: "
 
 #: templates/boards/preview.html:6 templates/boards/staticpages/help.html:19
 msgid "Preview"
 msgstr "Предпросмотр"
 
+#: 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 "Скрытые теги:"
+msgstr "Скрытые метки:"
 
 #: templates/boards/settings.html:26
 msgid "No hidden tags."
-msgstr "Нет скрытых тегов."
+msgstr "Нет скрытых меток."
 
 #: templates/boards/settings.html:35
 msgid "Save"
 msgstr "Сохранить"
 
-#: templates/boards/tags.html:22
-msgid "No tags found."
-msgstr "Теги не найдены."
-
-#: templates/boards/thread.html:20 templates/boards/thread_gallery.html:19
-msgid "Normal mode"
-msgstr "Нормальный режим"
-
-#: templates/boards/thread.html:21 templates/boards/thread_gallery.html:20
-msgid "Gallery mode"
-msgstr "Режим галереи"
-
-#: templates/boards/thread.html:29
-msgid "posts to bumplimit"
-msgstr "сообщений до бамплимита"
-
-#: templates/boards/thread.html:50
-msgid "Reply to thread"
-msgstr "Ответить в тему"
-
-#: templates/boards/thread.html:63
-msgid "Switch mode"
-msgstr "Переключить режим"
-
-#: templates/boards/thread.html:90 templates/boards/thread_gallery.html:61
-msgid "Last update: "
-msgstr "Последнее обновление: "
-
-#: templates/boards/rss/post.html:5
-msgid "Post image"
-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:19
 msgid "You can try pasting the text and previewing the result here:"
 msgstr "Вы можете попробовать вставить текст и проверить результат здесь:"
+
+#: templates/boards/tags.html:23
+msgid "No tags found."
+msgstr "Метки не найдены."
+
+#: templates/boards/thread.html:19 templates/boards/thread_gallery.html:19
+msgid "Normal mode"
+msgstr "Нормальный режим"
+
+#: templates/boards/thread.html:20 templates/boards/thread_gallery.html:20
+msgid "Gallery mode"
+msgstr "Режим галереи"
+
+#: templates/boards/thread.html:28
+msgid "posts to bumplimit"
+msgstr "сообщений до бамплимита"
+
+#: templates/boards/thread.html:46
+msgid "Reply to thread"
+msgstr "Ответить в тему"
+
+#: templates/boards/thread.html:59
+msgid "Switch mode"
+msgstr "Переключить режим"
+
+#: templates/boards/thread.html:91 templates/boards/thread_gallery.html:61
+msgid "Last update: "
+msgstr "Последнее обновление: "
+

boards/mdx_neboard.py

@@ -1,201 +1,202 b''
 # coding=utf-8
 
 import re
 import bbcode
 
 import boards
 
 
 __author__ = 'neko259'
 
 
 REFLINK_PATTERN = re.compile(r'^\d+$')
 GLOBAL_REFLINK_PATTERN = re.compile(r'^(\w+)::([^:]+)::(\d+)$')
 MULTI_NEWLINES_PATTERN = re.compile(r'(\r?\n){2,}')
 ONE_NEWLINE = '\n'
 
 
 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="multiquote">'
     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):
     post_id = None
 
     matches = REFLINK_PATTERN.findall(value)
     if matches:
         post_id = int(matches[0][0])
     else:
         match = GLOBAL_REFLINK_PATTERN.match(value)
         if match:
             key_type = match.group(1)
             key = match.group(2)
             local_id = match.group(3)
 
             try:
                 global_id = boards.models.GlobalId.objects.get(key_type=key_type,
                     key=key, local_id=local_id)
                 for post in boards.models.Post.objects.filter(global_id=global_id).only('id'):
                     post_id = post.id
             except boards.models.GlobalId.DoesNotExist:
                 pass
 
     if not post_id:
         return value
 
     posts = boards.models.Post.objects.filter(id=post_id)
     if posts.exists():
         post = posts[0]
 
         return '<a href="%s">&gt;&gt;%s</a>' % (post.get_url(), post_id)
     else:
         return '>>%s' % value
 
 
 def render_quote(tag_name, value, options, parent, context):
     source = ''
     if 'source' in options:
         source = options['source']
 
     result = ''
     if source:
         result = '<div class="multiquote"><div class="quote-header">%s</div><div class="quote-text">%s</div></div>' % (source, value)
     else:
         result = '<div class="multiquote"><div class="quote-text">%s</div></div>' % value
 
     return result
 
 
 def preparse_text(text):
     """
     Performs manual parsing before the bbcode parser is used.
     """
 
     return MULTI_NEWLINES_PATTERN.sub(ONE_NEWLINE, text)
 
 
 def bbcode_extended(markup):
     # The newline hack is added because br's margin does not work in all
     # browsers except firefox, when the div's does.
     parser = bbcode.Parser(newline='<div class="br"></div>')
     parser.add_formatter('post', render_reflink, strip=True)
     parser.add_formatter('quote', render_quote, strip=True)
     parser.add_simple_formatter('comment',
-            u'<span class="comment">//%(value)s</span>')
+                                '<span class="comment">//%(value)s</span>')
     parser.add_simple_formatter('spoiler',
-            u'<span class="spoiler">%(value)s</span>')
+                                '<span class="spoiler">%(value)s</span>')
     # TODO Use <s> here
     parser.add_simple_formatter('s',
-            u'<span class="strikethrough">%(value)s</span>')
+                                '<span class="strikethrough">%(value)s</span>')
     # TODO Why not use built-in tag?
     parser.add_simple_formatter('code',
-            u'<pre><code>%(value)s</pre></code>', render_embedded=False)
+                                '<pre><code>%(value)s</pre></code>',
+                                render_embedded=False)
 
     text = preparse_text(markup)
     return parser.format(text)
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
 ]

boards/middlewares.py

@@ -1,46 +1,28 b''
 from django.shortcuts import redirect
 from boards import utils
 from boards.models import Ban
-from django.utils.html import strip_spaces_between_tags
-from django.conf import settings
-from boards.views.banned import BannedView
 
 RESPONSE_CONTENT_TYPE = 'Content-Type'
 
 TYPE_HTML = 'text/html'
 
 
 class BanMiddleware:
     """
     This is run before showing the thread. Banned users don't need to see
     anything
     """
 
     def __init__(self):
         pass
 
     def process_view(self, request, view_func, view_args, view_kwargs):
 
-        if view_func != BannedView.as_view:
+        if request.path != '/banned/':
             ip = utils.get_client_ip(request)
             bans = Ban.objects.filter(ip=ip)
 
             if bans.exists():
                 ban = bans[0]
                 if not ban.can_read:
                     return redirect('banned')
-
-
-class MinifyHTMLMiddleware(object):
-    def process_response(self, request, response):
-        try:
-            compress_html = settings.COMPRESS_HTML
-        except AttributeError:
-            compress_html = False
-
-        if RESPONSE_CONTENT_TYPE in response\
-                and TYPE_HTML in response[RESPONSE_CONTENT_TYPE]\
-                and compress_html:
-            response.content = strip_spaces_between_tags(
-                response.content.strip())
-        return response
  No newline at end of file

boards/migrations/0001_initial.py

@@ -1,95 +1,113 b''
 # -*- coding: utf-8 -*-
-import datetime
-from south.db import db
-from south.v2 import SchemaMigration
-from django.db import models
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+import boards.models.image
+import boards.models.base
+import boards.thumbs
 
 
-class Migration(SchemaMigration):
-
-    def forwards(self, orm):
-        # Adding model 'Tag'
-        db.create_table(u'boards_tag', (
-            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
-            ('name', self.gf('django.db.models.fields.CharField')(max_length=100)),
-        ))
-        db.send_create_signal(u'boards', ['Tag'])
+class Migration(migrations.Migration):
 
-        # Adding model 'Post'
-        db.create_table(u'boards_post', (
-            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
-            ('title', self.gf('django.db.models.fields.CharField')(max_length=50)),
-            ('pub_time', self.gf('django.db.models.fields.DateTimeField')()),
-            ('text', self.gf('markupfield.fields.MarkupField')(rendered_field=True)),
-            ('text_markup_type', self.gf('django.db.models.fields.CharField')(default='markdown', max_length=30)),
-            ('image', self.gf('boards.thumbs.ImageWithThumbsField')(max_length=100, blank=True)),
-            ('poster_ip', self.gf('django.db.models.fields.IPAddressField')(max_length=15)),
-            ('_text_rendered', self.gf('django.db.models.fields.TextField')()),
-            ('poster_user_agent', self.gf('django.db.models.fields.TextField')()),
-            ('parent', self.gf('django.db.models.fields.BigIntegerField')()),
-            ('last_edit_time', self.gf('django.db.models.fields.DateTimeField')()),
-        ))
-        db.send_create_signal(u'boards', ['Post'])
-
-        # Adding M2M table for field tags on 'Post'
-        m2m_table_name = db.shorten_name(u'boards_post_tags')
-        db.create_table(m2m_table_name, (
-            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
-            ('post', models.ForeignKey(orm[u'boards.post'], null=False)),
-            ('tag', models.ForeignKey(orm[u'boards.tag'], null=False))
-        ))
-        db.create_unique(m2m_table_name, ['post_id', 'tag_id'])
-
-        # Adding model 'Admin'
-        db.create_table(u'boards_admin', (
-            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
-            ('name', self.gf('django.db.models.fields.CharField')(max_length=100)),
-            ('password', self.gf('django.db.models.fields.CharField')(max_length=100)),
-        ))
-        db.send_create_signal(u'boards', ['Admin'])
-
+    dependencies = [
+    ]
 
-    def backwards(self, orm):
-        # Deleting model 'Tag'
-        db.delete_table(u'boards_tag')
-
-        # Deleting model 'Post'
-        db.delete_table(u'boards_post')
-
-        # Removing M2M table for field tags on 'Post'
-        db.delete_table(db.shorten_name(u'boards_post_tags'))
-
-        # Deleting model 'Admin'
-        db.delete_table(u'boards_admin')
-
-
-    models = {
-        u'boards.admin': {
-            'Meta': {'object_name': 'Admin'},
-            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
-            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
-            'password': ('django.db.models.fields.CharField', [], {'max_length': '100'})
-        },
-        u'boards.post': {
-            'Meta': {'object_name': 'Post'},
-            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
-            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
-            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
-            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
-            'parent': ('django.db.models.fields.BigIntegerField', [], {}),
-            'poster_ip': ('django.db.models.fields.IPAddressField', [], {'max_length': '15'}),
-            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
-            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
-            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['boards.Tag']", 'symmetrical': 'False'}),
-            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
-            'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
-            'title': ('django.db.models.fields.CharField', [], {'max_length': '50'})
-        },
-        u'boards.tag': {
-            'Meta': {'object_name': 'Tag'},
-            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
-            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
-        }
-    }
-
-    complete_apps = ['boards']
  No newline at end of file
+    operations = [
+        migrations.CreateModel(
+            name='Ban',
+            fields=[
+                ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
+                ('ip', models.GenericIPAddressField()),
+                ('reason', models.CharField(max_length=200, default='Auto')),
+                ('can_read', models.BooleanField(default=True)),
+            ],
+            options={
+            },
+            bases=(models.Model,),
+        ),
+        migrations.CreateModel(
+            name='Post',
+            fields=[
+                ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
+                ('title', models.CharField(max_length=200)),
+                ('pub_time', models.DateTimeField()),
+                ('text', models.TextField(null=True, blank=True)),
+                ('text_markup_type', models.CharField(choices=[('', '--'), ('bbcode', 'bbcode')], max_length=30, default='bbcode')),
+                ('poster_ip', models.GenericIPAddressField()),
+                ('_text_rendered', models.TextField(editable=False)),
+                ('poster_user_agent', models.TextField()),
+                ('last_edit_time', models.DateTimeField()),
+                ('refmap', models.TextField(null=True, blank=True)),
+            ],
+            options={
+                'ordering': ('id',),
+            },
+            bases=(models.Model, boards.models.base.Viewable),
+        ),
+        migrations.CreateModel(
+            name='PostImage',
+            fields=[
+                ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
+                ('width', models.IntegerField(default=0)),
+                ('height', models.IntegerField(default=0)),
+                ('pre_width', models.IntegerField(default=0)),
+                ('pre_height', models.IntegerField(default=0)),
+                ('image', boards.thumbs.ImageWithThumbsField(height_field='height', width_field='width', upload_to=boards.models.image.PostImage._update_image_filename, blank=True)),
+                ('hash', models.CharField(max_length=36)),
+            ],
+            options={
+                'ordering': ('id',),
+            },
+            bases=(models.Model,),
+        ),
+        migrations.CreateModel(
+            name='Tag',
+            fields=[
+                ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
+                ('name', models.CharField(db_index=True, max_length=100)),
+            ],
+            options={
+                'ordering': ('name',),
+            },
+            bases=(models.Model, boards.models.base.Viewable),
+        ),
+        migrations.CreateModel(
+            name='Thread',
+            fields=[
+                ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
+                ('bump_time', models.DateTimeField()),
+                ('last_edit_time', models.DateTimeField()),
+                ('archived', models.BooleanField(default=False)),
+                ('bumpable', models.BooleanField(default=True)),
+                ('replies', models.ManyToManyField(null=True, related_name='tre+', to='boards.Post', blank=True)),
+                ('tags', models.ManyToManyField(to='boards.Tag')),
+            ],
+            options={
+            },
+            bases=(models.Model,),
+        ),
+        migrations.AddField(
+            model_name='tag',
+            name='threads',
+            field=models.ManyToManyField(null=True, related_name='tag+', to='boards.Thread', blank=True),
+            preserve_default=True,
+        ),
+        migrations.AddField(
+            model_name='post',
+            name='images',
+            field=models.ManyToManyField(null=True, db_index=True, related_name='ip+', to='boards.PostImage', blank=True),
+            preserve_default=True,
+        ),
+        migrations.AddField(
+            model_name='post',
+            name='referenced_posts',
+            field=models.ManyToManyField(null=True, db_index=True, related_name='rfp+', to='boards.Post', blank=True),
+            preserve_default=True,
+        ),
+        migrations.AddField(
+            model_name='post',
+            name='thread_new',
+            field=models.ForeignKey(null=True, default=None, to='boards.Thread'),
+            preserve_default=True,
+        ),
+    ]

boards/models/base.py

@@ -1,10 +1,18 b''
 __author__ = 'neko259'
 
 
 class Viewable():
     def __init__(self):
         pass
 
     def get_view(self, *args, **kwargs):
-        """Get an HTML view for a model"""
-        pass
  No newline at end of file
+        """
+        Gets an HTML view for a model
+        """
+        pass
+
+    def get_search_view(self, *args, **kwargs):
+        """
+        Gets an HTML view for search.
+        """
+        pass

boards/models/image.py

@@ -1,62 +1,83 b''
 import hashlib
 import os
 from random import random
 import time
 from django.db import models
 from boards import thumbs
+from boards.models.base import Viewable
 
 __author__ = 'neko259'
 
 
 IMAGE_THUMB_SIZE = (200, 150)
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
+HASH_LENGTH = 36
+
+CSS_CLASS_IMAGE = 'image'
+CSS_CLASS_THUMB = 'thumb'
 
 
-class PostImage(models.Model):
+class PostImage(models.Model, Viewable):
     class Meta:
         app_label = 'boards'
         ordering = ('id',)
 
     def _update_image_filename(self, filename):
         """
         Gets unique image filename
         """
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     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=_update_image_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=36)
+    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:
             md5 = hashlib.md5()
             for chunk in self.image.chunks():
                 md5.update(chunk)
             self.hash = md5.hexdigest()
         super(PostImage, self).save(*args, **kwargs)
 
     def __str__(self):
         return self.image.url
 
+    def get_view(self):
+        return '<div class="{}">' \
+               '<a class="{}" href="{}">' \
+               '<img' \
+               ' src="{}"' \
+               ' alt="{}"' \
+               ' width="{}"' \
+               ' height="{}"' \
+               ' data-width="{}"' \
+               ' data-height="{}" />' \
+               '</a>' \
+               '</div>'\
+            .format(CSS_CLASS_IMAGE, CSS_CLASS_THUMB, self.image.url,
+                    self.image.url_200x150,
+                    str(self.hash), str(self.pre_width),
+                    str(self.pre_height), str(self.width), str(self.height))

boards/models/post.py

@@ -1,518 +1,623 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import re
 import xml.etree.ElementTree as et
 
+from adjacent import Client
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
+from django.db.models import TextField
 from django.template.loader import render_to_string
 from django.utils import timezone
 
-from markupfield.fields import MarkupField
-
 from boards.models import PostImage, KeyPair, GlobalId, Signature
+from boards import settings
+from boards.mdx_neboard import bbcode_extended
+from boards.models import PostImage
 from boards.models.base import Viewable
 from boards.models.thread import Thread
 from boards import utils
+from boards.utils import datetime_to_epoch
 
 ENCODING_UNICODE = 'unicode'
 
+WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
+WS_NOTIFICATION_TYPE = 'notification_type'
+
+WS_CHANNEL_THREAD = "thread:"
+
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = 7
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
-DEFAULT_MARKUP_TYPE = 'bbcode'
-
 # TODO This should be removed
 NO_IP = '0.0.0.0'
 
 # TODO Real user agent should be saved instead of this
 UNKNOWN_UA = ''
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 REGEX_GLOBAL_REPLY = re.compile(r'\[post\](\w+)::([^:]+)::(\d+)\[/post\]')
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_RESPONSE = 'response'
 TAG_ID = 'id'
 TAG_STATUS = 'status'
 TAG_MODELS = 'models'
 TAG_TITLE = 'title'
 TAG_TEXT = 'text'
 TAG_THREAD = 'thread'
 TAG_PUB_TIME = 'pub-time'
 TAG_SIGNATURES = 'signatures'
 TAG_SIGNATURE = 'signature'
 TAG_CONTENT = 'content'
 TAG_ATTACHMENTS = 'attachments'
 TAG_ATTACHMENT = 'attachment'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 
 STATUS_SUCCESS = 'success'
 
-logger = logging.getLogger(__name__)
+PARAMETER_TRUNCATED = 'truncated'
+PARAMETER_TAG = 'tag'
+PARAMETER_OFFSET = 'offset'
+PARAMETER_DIFF_TYPE = 'type'
+PARAMETER_BUMPABLE = 'bumpable'
+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'
+
+DIFF_TYPE_HTML = 'html'
+DIFF_TYPE_JSON = 'json'
+
+PREPARSE_PATTERNS = {
+    r'>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
+    r'^>([^>].+)': r'[quote]\1[/quote]',  # Quote ">text"
+    r'^//(.+)': r'[comment]\1[/comment]',  # Comment "//text"
+}
 
 
 class PostManager(models.Manager):
-    def create_post(self, title, text, image=None, thread=None, ip=NO_IP,
-                    tags=None):
+    @transaction.atomic
+    def create_post(self, title: str, text: str, image=None, thread=None,
+                    ip=NO_IP, tags: list=None):
         """
         Creates new post
         """
 
         if not tags:
             tags = []
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
             new_thread = True
         else:
-            thread.bump()
-            thread.last_edit_time = posting_time
-            thread.save()
             new_thread = False
 
+        pre_text = self._preparse_text(text)
+
         post = self.create(title=title,
-                           text=text,
+                           text=pre_text,
                            pub_time=posting_time,
                            thread_new=thread,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time)
 
         post.set_global_id()
 
+        logger = logging.getLogger('boards.post.create')
+
+        logger.info('Created post {} by {}'.format(
+            post, post.poster_ip))
+
         if image:
             post_image = PostImage.objects.create(image=image)
             post.images.add(post_image)
-            logger.info('Created image #%d for post #%d' % (post_image.id,
-                                                            post.id))
+            logger.info('Created image #{} for post #{}'.format(
+                post_image.id, post.id))
 
         thread.replies.add(post)
         list(map(thread.add_tag, tags))
 
         if new_thread:
             Thread.objects.process_oldest_threads()
-        self.connect_replies(post)
+        else:
+            thread.bump()
+            thread.last_edit_time = posting_time
+            thread.save()
 
-        logger.info('Created post #%d with title %s'
-                    % (post.id, post.get_title()))
+        self.connect_replies(post)
 
         return post
 
-    def delete_post(self, post):
-        """
-        Deletes post and update or delete its thread
-        """
-
-        post_id = post.id
-
-        thread = post.get_thread()
-
-        if post.is_opening():
-            thread.delete()
-        else:
-            thread.last_edit_time = timezone.now()
-            thread.save()
-
-            post.delete()
-
-        logger.info('Deleted post #%d (%s)' % (post_id, post.get_title()))
-
     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:
-            self.delete_post(post)
+            post.delete()
 
     # TODO This can be moved into a post
     def connect_replies(self, post):
         """
         Connects replies to a post to show them as a reflink map
         """
 
-        for reply_number in post.get_replied_ids():
-            ref_post = self.filter(id=reply_number)
+        for reply_number in re.finditer(REGEX_REPLY, post.get_raw_text()):
+            post_id = reply_number.group(1)
+            ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         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)
 
         cache_key = CACHE_KEY_PPD + str(day_end)
         ppd = cache.get(cache_key)
         if ppd:
             return ppd
 
         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
 
         cache.set(cache_key, ppd)
         return ppd
 
     # TODO Make a separate sync facade?
     def generate_response_get(self, model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
 
             content_tag = et.SubElement(model, TAG_CONTENT)
 
             tag_id = et.SubElement(content_tag, TAG_ID)
             post.global_id.to_xml_element(tag_id)
 
             title = et.SubElement(content_tag, TAG_TITLE)
             title.text = post.title
 
             text = et.SubElement(content_tag, TAG_TEXT)
             # TODO Replace local links by global ones in the text
             text.text = post.text.raw
 
             if not post.is_opening():
                 thread = et.SubElement(content_tag, TAG_THREAD)
                 thread.text = str(post.get_thread().get_opening_post_id())
             else:
                 # TODO Output tags here
                 pass
 
             pub_time = et.SubElement(content_tag, TAG_PUB_TIME)
             pub_time.text = str(post.get_pub_time_epoch())
 
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = post.signature.all()
             if post_signatures:
                 signatures = post.signatures
             else:
                 # TODO Maybe the signature can be computed only once after
                 # the post is added? Need to add some on_save signal queue
                 # and add this there.
                 key = KeyPair.objects.get(public_key=post.global_id.key)
                 signatures = [Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(et.tostring(model, ENCODING_UNICODE)),
                     )]
             for signature in signatures:
                 signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
                 signature_tag.set(ATTR_TYPE, signature.key_type)
                 signature_tag.set(ATTR_VALUE, signature.signature)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     def parse_response_get(self, response_xml):
         tag_root = et.fromstring(response_xml)
         tag_status = tag_root[0]
         if 'success' == tag_status.text:
             tag_models = tag_root[1]
             for tag_model in tag_models:
                 tag_content = tag_model[0]
                 tag_id = tag_content[1]
                 try:
                     GlobalId.from_xml_element(tag_id, existing=True)
                     # If this post already exists, just continue
                     # TODO Compare post content and update the post if necessary
                     pass
                 except GlobalId.DoesNotExist:
                     global_id = GlobalId.from_xml_element(tag_id)
 
                     title = tag_content.find(TAG_TITLE).text
                     text = tag_content.find(TAG_TEXT).text
                     # TODO Check that the replied posts are already present
                     # before adding new ones
 
                     # TODO Pub time, thread, tags
 
                     post = Post.objects.create(title=title, text=text)
         else:
             # TODO Throw an exception?
             pass
 
+    def _preparse_text(self, text):
+        """
+        Preparses text to change patterns like '>>' to a proper bbcode
+        tags.
+        """
+
+        for key, value in PREPARSE_PATTERNS.items():
+            text = re.sub(key, value, text, flags=re.MULTILINE)
+
+        return text
+
 
 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)
     pub_time = models.DateTimeField()
-    text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
-                       escape_html=False)
+    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='ip+', db_index=True)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread_new = models.ForeignKey('Thread', null=True, default=None,
                                    db_index=True)
     last_edit_time = models.DateTimeField()
 
     # Replies to the post
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+',
                                               db_index=True)
 
     # Replies map. This is built from the referenced posts list to speed up
     # page loading (no need to get all the referenced posts from the database).
     refmap = models.TextField(null=True, blank=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)
 
     # One post can be signed by many nodes that give their trust to it
     signature = models.ManyToManyField('Signature', null=True, blank=True)
 
-    def __unicode__(self):
-        return '#' + str(self.id) + ' ' + self.title + ' (' + \
-               self.text.raw[:50] + ')'
+    def __str__(self):
+        return 'P#{}/{}'.format(self.id, self.title)
+
+    def get_title(self) -> str:
+        """
+        Gets original post title or part of its text.
+        """
 
-    def get_title(self):
-        return self.title
+        title = self.title
+        if not title:
+            title = self.get_text()
 
-    def build_refmap(self):
+        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.
         """
         map_string = ''
 
         first = True
         for refpost in self.referenced_posts.all():
             if not first:
                 map_string += ', '
             map_string += '<a href="%s">&gt;&gt;%s</a>' % (refpost.get_url(),
                                                            refpost.id)
             first = False
 
         self.refmap = map_string
 
     def get_sorted_referenced_posts(self):
         return self.refmap
 
-    def is_referenced(self):
-        return len(self.refmap) > 0
+    def is_referenced(self) -> bool:
+        if not self.refmap:
+            return False
+        else:
+            return len(self.refmap) > 0
 
-    def is_opening(self):
+    def is_opening(self) -> bool:
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.get_thread().get_opening_post_id() == self.id
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
-    @transaction.atomic
-    def remove_tag(self, tag):
-        edit_time = timezone.now()
-
-        thread = self.get_thread()
-        thread.remove_tag(tag)
-        self.last_edit_time = edit_time
-        self.save(update_fields=['last_edit_time'])
-
-        thread.last_edit_time = edit_time
-        thread.save(update_fields=['last_edit_time'])
-
     def get_url(self, thread=None):
         """
         Gets full url to the post.
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             if not thread:
                 thread = self.get_thread()
 
             opening_id = thread.get_opening_post_id()
 
             if self.id != opening_id:
                 link = reverse('thread', kwargs={
                     'post_id': opening_id}) + '#' + str(self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
-    def get_thread(self):
+    def get_thread(self) -> Thread:
         """
         Gets post's thread.
         """
 
         return self.thread_new
 
     def get_referenced_posts(self):
         return self.referenced_posts.only('id', 'thread_new')
 
-    def get_text(self):
-        return self.text
-
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs):
-        if 'is_opening' in kwargs:
-            is_opening = kwargs['is_opening']
-        else:
-            is_opening = self.is_opening()
+        """
+        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.
+        """
 
-        if 'thread' in kwargs:
-            thread = kwargs['thread']
-        else:
-            thread = self.get_thread()
-
-        if 'can_bump' in kwargs:
-            can_bump = kwargs['can_bump']
-        else:
-            can_bump = thread.can_bump()
+        is_opening = kwargs.get(PARAMETER_IS_OPENING, self.is_opening())
+        thread = kwargs.get(PARAMETER_THREAD, self.get_thread())
+        can_bump = kwargs.get(PARAMETER_BUMPABLE, thread.can_bump())
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         return render_to_string('boards/post.html', {
-            'post': self,
-            'moderator': moderator,
-            'is_opening': is_opening,
-            'thread': thread,
-            'bumpable': can_bump,
-            'need_open_link': need_open_link,
-            'truncated': truncated,
-            'opening_post_id': opening_post_id,
+            PARAMETER_POST: self,
+            PARAMETER_MODERATOR: moderator,
+            PARAMETER_IS_OPENING: is_opening,
+            PARAMETER_THREAD: thread,
+            PARAMETER_BUMPABLE: can_bump,
+            PARAMETER_NEED_OPEN_LINK: need_open_link,
+            PARAMETER_TRUNCATED: truncated,
+            PARAMETER_OP_ID: opening_post_id,
         })
 
-    def get_first_image(self):
+    def get_search_view(self, *args, **kwargs):
+        return self.get_view(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.
+        Deletes all post images and the post itself. If the post is opening,
+        thread with all posts is deleted.
         """
 
         self.images.all().delete()
         self.signature.all().delete()
         if self.global_id:
             self.global_id.delete()
 
+        if self.is_opening():
+            self.get_thread().delete()
+        else:
+            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_epoch(self):
         return utils.datetime_to_epoch(self.pub_time)
 
+    # TODO Use this to connect replies
     def get_replied_ids(self):
         """
         Gets ID list of the posts that this post replies.
         """
 
         local_replied = REGEX_REPLY.findall(self.text.raw)
         global_replied = []
         # TODO Similar code is used in mdx_neboard, maybe it can be extracted
         # into a method?
         for match in REGEX_GLOBAL_REPLY.findall(self.text.raw):
             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):
+        """
+        Gets post HTML or JSON data that can be rendered on a page or used by
+        API.
+        """
+
+        if format_type == DIFF_TYPE_HTML:
+            params = dict()
+            params['post'] = self
+            if PARAMETER_TRUNCATED in request.GET:
+                params[PARAMETER_TRUNCATED] = True
+
+            return render_to_string('boards/api_post.html', params)
+        elif format_type == DIFF_TYPE_JSON:
+            post_json = {
+                'id': self.id,
+                'title': self.title,
+                'text': self._text_rendered,
+                }
+            if self.images.exists():
+                post_image = self.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'] = datetime_to_epoch(
+                    self.thread_new.bump_time)
+            return post_json
+
+    def send_to_websocket(self, request, recursive=True):
+        """
+        Sends post HTML data to the thread web socket.
+        """
+
+        if not settings.WEBSOCKETS_ENABLED:
+            return
+
+        client = Client()
+
+        thread = self.get_thread()
+        thread_id = thread.id
+        channel_name = WS_CHANNEL_THREAD + str(thread.get_opening_post_id())
+        client.publish(channel_name, {
+            WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
+        })
+        client.send()
+
+        logger = logging.getLogger('boards.post.websocket')
+
+        logger.info('Sent notification from post #{} to channel {}'.format(
+            self.id, channel_name))
+
+        if recursive:
+            for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
+                post_id = reply_number.group(1)
+                ref_post = Post.objects.filter(id=post_id)[0]
+
+                # If post is in this thread, its thread was already notified.
+                # Otherwise, notify its thread separately.
+                if ref_post.thread_new_id != thread_id:
+                    ref_post.send_to_websocket(request, recursive=False)
+
+    def save(self, force_insert=False, force_update=False, using=None,
+             update_fields=None):
+        self._text_rendered = bbcode_extended(self.get_raw_text())
+
+        super().save(force_insert, force_update, using, update_fields)
+
+    def get_text(self) -> str:
+        return self._text_rendered
+
+    def get_raw_text(self) -> str:
+        return self.text

boards/models/tag.py

@@ -1,78 +1,71 b''
 from django.template.loader import render_to_string
 from django.db import models
-from django.db.models import Count, Sum
+from django.db.models import Count
 from django.core.urlresolvers import reverse
 
-from boards.models import Thread
 from boards.models.base import Viewable
 
 
 __author__ = 'neko259'
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
-        tags = self.annotate(Count('threads')) \
-            .filter(threads__count__gt=0).order_by('name')
-
-        return tags
+        return self.filter(thread__archived=False)\
+            .annotate(num_threads=Count('thread')).filter(num_threads__gt=0)\
+            .order_by('-required', 'name')
 
 
 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)
-    threads = models.ManyToManyField(Thread, null=True,
-                                     blank=True, related_name='tag+')
+    required = models.BooleanField(default=False)
 
-    def __unicode__(self):
+    def __str__(self):
         return self.name
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
-    def get_thread_count(self):
-        return self.threads.count()
-
-    def get_post_count(self, archived=False):
-        """
-        Gets posts count for the tag's threads.
-        """
-
-        posts_count = 0
-
-        threads = self.threads.filter(archived=archived)
-        if threads.exists():
-            posts_count = threads.annotate(posts_count=Count('replies')) \
-                .aggregate(posts_sum=Sum('posts_count'))['posts_sum']
-
-        if not posts_count:
-            posts_count = 0
-
-        return posts_count
+    def get_thread_count(self) -> int:
+        return self.get_threads().count()
 
     def get_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
-    def get_view(self, *args, **kwargs):
+    def get_threads(self):
+        return self.thread_set.order_by('-bump_time')
+
+    def is_required(self):
+        return self.required
+
+    def get_view(self):
+        link = '<a class="tag" href="{}">{}</a>'.format(
+            self.get_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,
         })

boards/models/thread.py

@@ -1,188 +1,182 b''
 import logging
-from django.db.models import Count
+from django.db.models import Count, Sum
 from django.utils import timezone
 from django.core.cache import cache
 from django.db import models
 from boards import settings
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 CACHE_KEY_OPENING_POST = 'opening_post_id'
 
 
 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')
         thread_count = threads.count()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 if settings.ARCHIVE_THREADS:
                     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.last_edit_time = timezone.now()
-        thread.save(update_fields=['archived', 'last_edit_time'])
+        thread.save(update_fields=['archived', 'last_edit_time', 'bumpable'])
 
 
 class Thread(models.Model):
     objects = ThreadManager()
 
     class Meta:
         app_label = 'boards'
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
     archived = models.BooleanField(default=False)
+    bumpable = models.BooleanField(default=True)
 
     def get_tags(self):
         """
         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 = timezone.now()
 
+            if self.get_reply_count() >= settings.MAX_POSTS_PER_THREAD:
+                self.bumpable = False
+
             logger.info('Bumped thread %d' % self.id)
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
-        # TODO Use sum
-        total_count = 0
-        for post_with_image in self.replies.annotate(images_count=Count(
-                'images')):
-            total_count += post_with_image.images_count
-        return total_count
+        return self.replies.annotate(images_count=Count(
+                'images')).aggregate(Sum('images_count'))['images_count__sum']
 
     def can_bump(self):
         """
         Checks if the thread can be bumped by replying to it.
         """
 
-        if self.archived:
-            return False
-
-        post_count = self.get_reply_count()
-
-        return post_count < settings.MAX_POSTS_PER_THREAD
+        return self.bumpable
 
     def get_last_replies(self):
         """
         Gets several last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.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):
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.LAST_REPLIES_COUNT,
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False):
         """
         Gets sorted thread posts
         """
 
         query = self.replies.order_by('pub_time').prefetch_related('images')
         if view_fields_only:
-            query = query.defer('poster_user_agent', 'text_markup_type')
+            query = query.defer('poster_user_agent')
         return query.all()
 
     def get_replies_with_images(self, view_fields_only=False):
         return self.get_replies(view_fields_only).annotate(images_count=Count(
             'images')).filter(images_count__gt=0)
 
     def add_tag(self, tag):
         """
         Connects thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
-        tag.threads.add(self)
-
-    def remove_tag(self, tag):
-        self.tags.remove(tag)
-        tag.threads.remove(self)
 
     def get_opening_post(self, only_id=False):
         """
         Gets the first post of the thread
         """
 
         query = self.replies.order_by('pub_time')
         if only_id:
             query = query.only('id')
         opening_post = query.first()
 
         return opening_post
 
     def get_opening_post_id(self):
         """
         Gets ID of the first thread post.
         """
 
         cache_key = CACHE_KEY_OPENING_POST + str(self.id)
         opening_post_id = cache.get(cache_key)
         if not opening_post_id:
             opening_post_id = self.get_opening_post(only_id=True).id
             cache.set(cache_key, opening_post_id)
 
         return opening_post_id
 
     def __unicode__(self):
         return str(self.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 delete(self, using=None):
         if self.replies.exists():
             self.replies.all().delete()
 
-        super(Thread, self).delete(using)
  No newline at end of file
+        super(Thread, self).delete(using)
+
+    def __str__(self):
+        return 'T#{}/{}'.format(self.id, self.get_opening_post_id())
  No newline at end of file

boards/search_indexes.py

@@ -1,24 +1,24 b''
 from haystack import indexes
 from boards.models import Post, Tag
 
 __author__ = 'neko259'
 
 
 class PostIndex(indexes.SearchIndex, indexes.Indexable):
     text = indexes.CharField(document=True, use_template=True)
 
     def get_model(self):
         return Post
 
     def index_queryset(self, using=None):
         return self.get_model().objects.all()
 
 
 class TagIndex(indexes.SearchIndex, indexes.Indexable):
     text = indexes.CharField(document=True, use_template=True)
 
     def get_model(self):
         return Tag
 
     def index_queryset(self, using=None):
-        return self.get_model().objects.get_not_empty_tags()
+        return self.get_model().objects.all()

boards/settings.py

@@ -1,20 +1,22 b''
-VERSION = '2.1 Aya'
-SITE_NAME = 'n3b0a2d'
+VERSION = '2.2.3 Miyu'
+SITE_NAME = 'Neboard'
 
 CACHE_TIMEOUT = 600  # Timeout for caching, if cache is used
 LOGIN_TIMEOUT = 3600  # Timeout between login tries
 MAX_TEXT_LENGTH = 30000  # Max post length in characters
 MAX_IMAGE_SIZE = 8 * 1024 * 1024  # Max image size
 
 # Thread bumplimit
 MAX_POSTS_PER_THREAD = 10
 # Old posts will be archived or deleted if this value is reached
 MAX_THREAD_COUNT = 5
 THREADS_PER_PAGE = 3
 DEFAULT_THEME = 'md'
 LAST_REPLIES_COUNT = 3
 
 # Enable archiving threads instead of deletion when the thread limit is reached
 ARCHIVE_THREADS = True
 # Limit posting speed
 LIMIT_POSTING_SPEED = False
+# Thread update
+WEBSOCKETS_ENABLED = True

boards/static/css/md/base_page.css

@@ -1,484 +1,497 b''
+* {
+   text-decoration: none;
+   font-weight: inherit;
+}
+
+b {
+   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 {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #fff;
     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;
 }
 
 .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%;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     font-weight: bolder;
     vertical-align: middle;
 }
 
 .post-form input:not([name="image"]), .post-form textarea {
     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;
 }
 
 .post-form input[type="submit"], input[type="submit"] {
     background: #222;
     border: solid 2px #fff;
     color: #fff;
     padding: 0.5ex;
 }
 
 input[type="submit"]:hover {
     background: #060;
 }
 
 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 {
     background-color: #442222;
 }
 
 .archive_post {
     background-color: #000;
 }
 
 .mark_btn {
     border: 1px solid;
     min-width: 2ex;
     padding: 2px 2ex;
 }
 
 .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: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .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;
     float: right;
     font-weight: bold;
 }
 
 .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;
 }
 
 .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;
     padding: 0.5ex;
     margin: 0.5ex;
     text-align: center;
 }
 
 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;
     border: 1px dashed #666;
     margin: 0.2ex;
     padding: 0.1ex;
 }
 
 #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;
 }
 
 /* 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;
 }

boards/static/js/thread_update.js

@@ -1,288 +1,334 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
- Copyright (C) 2013  neko259
+ 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 THREAD_UPDATE_DELAY = 10000;
+var wsUser = '';
 
 var loading = false;
-var lastUpdateTime = null;
 var unreadPosts = 0;
+var documentOriginalTitle = '';
 
+// Thread ID does not change, can be stored one time
+var threadId = $('div.thread').children('.post').first().attr('id');
+
+/**
+ * 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-last-update'),
+        "token": metapanel.getAttribute('data-ws-token'),
+        "debug": false
+    });
+
+    centrifuge.on('error', function(error_message) {
+        console.log("Error connecting to websocket server.");
+        return false;
+    });
+
+    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').text('[+]');
+    });
+
+    centrifuge.connect();
+
+    return true;
+}
+
+/**
+ * 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 lastUpdateTime = $('.metapanel').attr('data-last-update');
+
+    var diffUrl = '/api/diff_thread/' + threadId + '/' + lastUpdateTime + '/';
+
+    $.getJSON(diffUrl)
+        .success(function(data) {
+            var addedPosts = data.added;
+
+            for (var i = 0; i < addedPosts.length; i++) {
+                var postText = addedPosts[i];
+                var post = $(postText);
+
+                updatePost(post)
+
+                lastPost = post;
+            }
+
+            var updatedPosts = data.updated;
+
+            for (var i = 0; i < updatedPosts.length; i++) {
+                var postText = updatedPosts[i];
+                var post = $(postText);
+
+                updatePost(post)
+            }
+
+            // TODO Process removed posts if any
+            $('.metapanel').attr('data-last-update', data.last_update);
+        })
+}
+
+/**
+ * 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 lastUpdate = '';
+
+    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 + ']');
+
+    if (existingPosts.size() > 0) {
+        existingPosts.replaceWith(post);
+    } else {
+        var threadPosts = threadBlock.children('.post');
+        var lastPost = threadPosts.last();
+
+        post.appendTo(lastPost.parent());
+
+        updateBumplimitProgress(1);
+        showNewPostsTitle(1);
+
+        lastUpdate = post.children('.post-info').first()
+            .children('.pub_time').first().text();
+
+        if (bottom) {
+            scrollToBottom();
+        }
+    }
+
+    processNewPost(post);
+    updateMetadataPanel(lastUpdate)
+}
+
+/**
+ * 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);
     }
 }
 
-function updateThread() {
-    if (loading) {
-        return;
-    }
-
-    loading = true;
-
-    var threadPosts = $('div.thread').children('.post');
-
-    var lastPost = threadPosts.last();
-    var threadId = threadPosts.first().attr('id');
-
-    var diffUrl = '/api/diff_thread/' + threadId + '/' + lastUpdateTime + '/';
-    $.getJSON(diffUrl)
-        .success(function(data) {
-            var bottom = isPageBottom();
-
-            var lastUpdate = '';
-
-            var addedPosts = data.added;
-            for (var i = 0; i < addedPosts.length; i++) {
-                var postText = addedPosts[i];
-
-                var post = $(postText);
-
-                if (lastUpdate === '') {
-                    lastUpdate = post.find('.pub_time').text();
-                }
-
-                post.appendTo(lastPost.parent());
-                processNewPost(post);
-
-                lastPost = post;
-                blink(post);
-            }
-
-            var updatedPosts = data.updated;
-            for (var i = 0; i < updatedPosts.length; i++) {
-                var postText = updatedPosts[i];
-
-                var post = $(postText);
-
-                if (lastUpdate === '') {
-                    lastUpdate = post.find('.pub_time').text();
-                }
-
-                var postId = post.attr('id');
-
-                var oldPost = $('div.thread').children('.post[id=' + postId + ']');
-                
-                oldPost.replaceWith(post);
-                processNewPost(post);
-
-                blink(post);
-            }
-
-            // TODO Process deleted posts
-
-            lastUpdateTime = data.last_update;
-            loading = false;
-
-            if (bottom) {
-                scrollToBottom();
-            }
-
-            var hasPostChanges = (updatedPosts.length > 0)
-                || (addedPosts.length > 0);
-            if (hasPostChanges) {
-                updateMetadataPanel(lastUpdate);
-            }
-
-            updateBumplimitProgress(data.added.length);
-
-            if (data.added.length + data.updated.length > 0) {
-                showNewPostsTitle(data.added.length);
-            }
-        })
-        .error(function(data) {
-            // TODO Show error message that server is unavailable?
-
-            loading = false;
-        });
-}
-
 function isPageBottom() {
     var scroll = $(window).scrollTop() / ($(document).height()
-        - $(window).height())
+        - $(window).height());
 
     return scroll == 1
 }
 
 function initAutoupdate() {
-    loading = false;
-
-    lastUpdateTime = $('.metapanel').attr('data-last-update');
-
-    setInterval(updateThread, THREAD_UPDATE_DELAY);
+    return connectWebsocket();
 }
 
 function getReplyCount() {
     return $('.thread').children('.post').length
 }
 
 function getImageCount() {
     return $('.thread').find('img').length
 }
 
+/**
+ * Update post count, images count and last update time in the metadata
+ * panel.
+ */
 function updateMetadataPanel(lastUpdate) {
     var replyCountField = $('#reply-count');
     var imageCountField = $('#image-count');
 
     replyCountField.text(getReplyCount());
     imageCountField.text(getImageCount());
 
     if (lastUpdate !== '') {
         var lastUpdateField = $('#last-update');
         lastUpdateField.text(lastUpdate);
         blink(lastUpdateField);
     }
 
     blink(replyCountField);
     blink(imageCountField);
 }
 
 /**
  * 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();
             $('.thread').children('.post').addClass('dead_post');
         } else {
             postsToLimitElement.text(newPostsToLimit);
             progressBar.width((100 - postCount / bumplimit * 100.0) + '%');
         }
     }
 }
 
-var documentOriginalTitle = '';
 /**
  * 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;
         document.title = '[' + unreadPosts + '] ' + documentOriginalTitle;
 
         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();
 }
 
 /**
  * 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') {
         resetForm(form);
-        updateThread();
+        getThreadDiff();
     } else {
         var errors = json.errors;
         for (var i = 0; i < errors.length; i++) {
             var fieldErrors = errors[i];
 
             var error = fieldErrors.errors;
 
             showAsErrors(form, error);
         }
     }
+
+    scrollToBottom();
 }
 
 /**
  * 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);
+    blink(post);
 }
 
 $(document).ready(function(){
-    initAutoupdate();
+    if (initAutoupdate()) {
+        // Post form data over AJAX
+        var threadId = $('div.thread').children('.post').first().attr('id');
 
-    // Post form data over AJAX
-    var threadId = $('div.thread').children('.post').first().attr('id');
-
-    var form = $('#form');
+        var form = $('#form');
 
-    var options = {
-        beforeSubmit: function(arr, $form, options) {
-            showAsErrors($('form'), gettext('Sending message...'));
-        },
-        success: updateOnPost,
-        url: '/api/add_post/' + threadId + '/'
-    };
+        var options = {
+            beforeSubmit: function(arr, $form, options) {
+                showAsErrors($('form'), gettext('Sending message...'));
+            },
+            success: updateOnPost,
+            url: '/api/add_post/' + threadId + '/'
+        };
 
-    form.ajaxForm(options);
+        form.ajaxForm(options);
 
-    resetForm(form);
+        resetForm(form);
+    }
 });

boards/templates/boards/base.html

@@ -1,58 +1,60 b''
 {% 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 theme_css %}" media="all"/>
+
     <link rel="alternate" type="application/rss+xml" href="rss/" title="{% trans 'Feed' %}"/>
 
     <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>
 <script src="{% static 'js/jquery-2.0.1.min.js' %}"></script>
 <script src="{% static 'js/jquery-ui-1.10.3.custom.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>
     {% for tag in tags %}
-        <a class="tag" href="{% url 'tag' tag_name=tag.name %}"
-                >#{{ tag.name }}</a>,
+        {% autoescape off %}
+            {{ tag.get_view }}{% if not forloop.last %},{% endif %}
+        {% endautoescape %}
     {% endfor %}
     <a href="{% url 'tags' %}" title="{% trans 'Tag management' %}"
             >[...]</a>,
         <a href="{% url 'search' %}" title="{% trans 'Search' %}">[S]</a>
     <a class="link" href="{% url 'settings' %}">{% trans 'Settings' %}</a>
 </div>
 
 {% block content %}{% endblock %}
 
+<script src="{% static 'js/3party/highlight.min.js' %}"></script>
 <script src="{% static 'js/popup.js' %}"></script>
 <script src="{% static 'js/image.js' %}"></script>
-<script src="{% static 'js/3party/highlight.min.js' %}"></script>
 <script src="{% static 'js/refpopup.js' %}"></script>
 <script src="{% static 'js/main.js' %}"></script>
 
 <div class="navigation_panel footer">
     {% block metapanel %}{% endblock %}
     [<a href="{% url 'admin:index' %}">{% trans 'Admin' %}</a>]
     {% with ppd=posts_per_day|floatformat:2 %}
         {% blocktrans %}Speed: {{ ppd }} posts per day{% endblocktrans %}
     {% endwith %}
     <a class="link" href="#top">{% trans 'Up' %}</a>
 </div>
 
 </body>
 </html>

boards/templates/boards/post.html

@@ -1,104 +1,102 b''
 {% load i18n %}
 {% load board %}
 {% load cache %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
-{% spaceless %}
-    {% cache 600 post post.id post.last_edit_time thread.archived bumpable truncated moderator LANGUAGE_CODE need_open_link %}
-        {% if thread.archived %}
-            <div class="post archive_post" id="{{ post.id }}">
-        {% elif bumpable %}
-            <div class="post" id="{{ post.id }}">
-        {% else %}
-            <div class="post dead_post" id="{{ post.id }}">
-        {% endif %}
+{% if thread.archived %}
+    <div class="post archive_post" id="{{ post.id }}">
+{% elif bumpable %}
+    <div class="post" id="{{ post.id }}">
+{% else %}
+    <div class="post dead_post" id="{{ post.id }}">
+{% endif %}
 
-        <div class="post-info">
-            <a class="post_id" href="{% post_object_url post thread=thread %}"
-                {% if not truncated and not thread.archived %}
-                    onclick="javascript:addQuickReply('{{ post.id }}'); return false;"
-                    title="{% trans 'Quote' %}"
-                {% endif %}
-                >({{ post.id }}) </a>
-            <span class="title">{{ post.title }} </span>
-            <span class="pub_time">{{ post.pub_time }}</span>
-            {% if thread.archived %}
-                — {{ thread.bump_time }}
+<div class="post-info">
+    <a class="post_id" href="{% post_object_url post thread=thread %}"
+            {% if not truncated and not thread.archived %}
+       onclick="javascript:addQuickReply('{{ post.id }}'); return false;"
+       title="{% trans 'Quote' %}" {% endif %}>({{ post.id }})</a>
+    <span class="title">{{ post.title }}</span>
+    <span class="pub_time">{{ post.pub_time }}</span>
+    {% 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 is_opening %}
+        — {{ thread.bump_time }}
+        {% endif %}
+    {% endif %}
+    {% if is_opening and need_open_link %}
+        {% if thread.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 %}
+
+    {% if post.global_id %}
+        <a class="global-id" href="
+        {% url 'post_sync_data' post.id %}"> [RAW] </a>
+    {% endif %}
+
+    {% if moderator %}
+        <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>]
             {% endif %}
-            {% if is_opening and need_open_link %}
-                {% if thread.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 %}
-
-            {% if post.global_id %}
-                <a class="global-id" href="
-                {% url 'post_sync_data' post.id %}"> [RAW] </a>
-            {% endif %}
-
-            {% if moderator %}
-                <span class="moderator_info">
-                    [<a href="{% url 'post_admin' post_id=post.id %}"
-                        >{% trans 'Edit' %}</a>]
-                    [<a href="{% url 'delete' post_id=post.id %}"
-                        >{% trans 'Delete' %}</a>]
-                    ({{ post.poster_ip }})
-                    [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
-                        >{% trans 'Ban IP' %}</a>]
-                </span>
-            {% endif %}
+        </span>
+    {% endif %}
+</div>
+{% comment %}
+    Post images. Currently only 1 image can be posted and shown, but post model
+    supports multiple.
+{%  endcomment %}
+{% if post.images.exists %}
+    {% with post.images.all.0 as image %}
+        {% autoescape off %}
+            {{ image.get_view }}
+        {% endautoescape %}
+    {% endwith %}
+{% endif %}
+{% comment %}
+    Post message (text)
+{% endcomment %}
+<div class="message">
+    {% autoescape off %}
+        {% if truncated %}
+            {{ post.get_text|truncatewords_html:50 }}
+        {% else %}
+            {{ post.get_text }}
+        {% endif %}
+    {% endautoescape %}
+    {% if post.is_referenced %}
+        <div class="refmap">
+            {% autoescape off %}
+                {% trans "Replies" %}: {{ post.refmap }}
+            {% endautoescape %}
         </div>
-        {% if post.images.exists %}
-            {% with post.images.all.0 as image %}
-            <div class="image">
-                <a
-                        class="thumb"
-                        href="{{ image.image.url }}"><img
-                        src="{{ image.image.url_200x150 }}"
-                        alt="{{ post.id }}"
-                        width="{{ image.pre_width }}"
-                        height="{{ image.pre_height }}"
-                        data-width="{{ image.width }}"
-                        data-height="{{ image.height }}"/>
-                </a>
-            </div>
-            {% endwith %}
+    {% endif %}
+</div>
+{% comment %}
+    Thread metadata: counters, tags etc
+{% endcomment %}
+{% if is_opening %}
+    <div class="metadata">
+        {% if is_opening and need_open_link %}
+            {{ thread.get_reply_count }} {% trans 'messages' %},
+            {{ thread.get_images_count }} {% trans 'images' %}.
         {% endif %}
-        <div class="message">
-            {% autoescape off %}
-                {% if truncated %}
-                    {{ post.text.rendered|truncatewords_html:50 }}
-                {% else %}
-                    {{ post.text.rendered }}
-                {% endif %}
-            {% endautoescape %}
-            {% if post.is_referenced %}
-                <div class="refmap">
-                    {% autoescape off %}
-                        {% trans "Replies" %}: {{ post.refmap }}
-                    {% endautoescape %}
-                </div>
-            {% endif %}
-        </div>
-    {% endcache %}
-        {% if is_opening %}
-        {% cache 600 post_thread thread.id thread.last_edit_time LANGUAGE_CODE need_open_link %}
-            <div class="metadata">
-                {% if is_opening and need_open_link %}
-                    {{ thread.get_reply_count }} {% trans 'messages' %},
-                    {{ thread.get_images_count }} {% trans 'images' %}.
-                {% endif %}
-                <span class="tags">
-                    {% for tag in thread.get_tags %}
-                        <a class="tag" href="{% url 'tag' tag.name %}">
-                            #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
-                    {% endfor %}
-                </span>
-            </div>
-        {% endcache %}
-        {% endif %}
-        </div>
-{% endspaceless %}
+        <span class="tags">
+            {% for tag in thread.get_tags %}
+                {% autoescape off %}
+                    {{ tag.get_view }}{% if not forloop.last %},{% endif %}
+                {% endautoescape %}
+            {% endfor %}
+        </span>
+    </div>
+{% endif %}
+</div>

boards/templates/boards/posting_general.html

@@ -1,197 +1,202 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load board %}
 {% load static %}
 
 {% block head %}
     {% if tag %}
         <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if current_page.has_previous %}
         <link rel="prev" href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=current_page.previous_page_number %}
+                {% url "tag" tag_name=tag.name page=current_page.previous_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.previous_page_number %}
             {% else %}
                 {% url "index" page=current_page.previous_page_number %}
             {% endif %}
         " />
     {% endif %}
     {% if current_page.has_next %}
         <link rel="next" href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=current_page.next_page_number %}
+                {% url "tag" tag_name=tag.name page=current_page.next_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.next_page_number %}
             {% else %}
                 {% url "index" page=current_page.next_page_number %}
             {% endif %}
         " />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
 {% if tag %}
     <div class="tag_info">
         <h2>
             {% if tag in fav_tags %}
                 <a href="{% url 'tag' tag.name %}?method=unsubscribe&next={{ request.path }}"
-                   class="fav">★</a>
+                   class="fav" rel="nofollow">★</a>
             {% else %}
                 <a href="{% url 'tag' tag.name %}?method=subscribe&next={{ request.path }}"
-                   class="not_fav">★</a>
+                   class="not_fav" rel="nofollow">★</a>
             {% endif %}
             {% if tag in hidden_tags %}
                 <a href="{% url 'tag' tag.name %}?method=unhide&next={{ request.path }}"
                    title="{% trans 'Show tag' %}"
-                   class="fav">H</a>
+                   class="fav" rel="nofollow">H</a>
             {% else %}
                 <a href="{% url 'tag' tag.name %}?method=hide&next={{ request.path }}"
                    title="{% trans 'Hide tag' %}"
-                   class="not_fav">H</a>
+                   class="not_fav" rel="nofollow">H</a>
             {% endif %}
-            #{{ tag.name }}
+            {% autoescape off %}
+                {{ tag.get_view }}
+            {% endautoescape %}
+            {% if moderator %}
+                [<a href="{% url 'admin:boards_tag_change' tag.id %}"$>{% trans 'Edit tag' %}</a>]
+            {% endif %}
         </h2>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if current_page.has_previous %}
             <div class="page_link">
                 <a href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=current_page.previous_page_number %}
+                {% url "tag" tag_name=tag.name page=current_page.previous_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.previous_page_number %}
             {% else %}
                 {% url "index" page=current_page.previous_page_number %}
             {% endif %}
                 ">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             {% cache 600 thread_short thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
             <div class="thread">
                 {% with can_bump=thread.can_bump %}
                 {% post_view thread.get_opening_post moderator is_opening=True thread=thread can_bump=can_bump truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% if thread.get_skipped_replies_count %}
                                 <div class="skipped_replies">
                                     <a href="{% url 'thread' thread.get_opening_post.id %}">
                                         {% blocktrans with count=thread.get_skipped_replies_count %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                                     </a>
                                 </div>
                             {% endif %}
                             <div class="last-replies">
                                 {% for post in last_replies %}
                                     {% post_view post moderator=moderator is_opening=False thread=thread can_bump=can_bump truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
                 {% endwith %}
             </div>
             {% endcache %}
         {% endfor %}
 
         {% if current_page.has_next %}
             <div class="page_link">
                 <a href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=current_page.next_page_number %}
+                {% url "tag" tag_name=tag.name page=current_page.next_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.next_page_number %}
             {% else %}
                 {% url "index" page=current_page.next_page_number %}
             {% endif %}
                 ">{% 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">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             </div>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
             </div>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/form.js' %}"></script>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         <a href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=paginator.page_range|first %}
+                {% url "tag" tag_name=tag.name page=paginator.page_range|first %}
             {% elif archived %}
                 {% url "archive" page=paginator.page_range|first %}
             {% else %}
                 {% url "index" page=paginator.page_range|first %}
             {% endif %}
         ">&lt;&lt;</a>
         [
         {% for page in paginator.center_range %}
             <a
                 {% ifequal page current_page.number %}
                     class="current_page"
                 {% endifequal %}
                 href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=page %}
+                {% url "tag" tag_name=tag.name page=page %}
             {% elif archived %}
                 {% url "archive" page=page %}
             {% else %}
                 {% url "index" page=page %}
             {% endif %}
             ">{{ page }}</a>
             {% if not forloop.last %},{% endif %}
         {% endfor %}
         ]
         <a href="
             {% if tag %}
-                {% url "tag" tag_name=tag page=paginator.page_range|last %}
+                {% url "tag" tag_name=tag.name page=paginator.page_range|last %}
             {% elif archived %}
                 {% url "archive" page=paginator.page_range|last %}
             {% else %}
                 {% url "index" page=paginator.page_range|last %}
             {% endif %}
         ">&gt;&gt;</a>
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/rss/post.html

@@ -1,15 +1,15 b''
 {% load i18n %}
 
 {% if obj.images.exists %}
 <img src="{{ obj.get_first_image.image.url_200x150 }}"
         alt="{% trans 'Post image' %}" />
 {% endif %}
-{{ obj.text.rendered|safe }}
+{{ obj.get_text|safe }}
 {%  if obj.tags.all %}
     <p>
         {% trans 'Tags' %}:
         {% for tag in obj.tags.all %}
             {{ tag.name }}
         {% endfor %}
     </p>
 {% endif %}
  No newline at end of file

boards/templates/boards/tag.html

@@ -1,3 +1,5 b''
 <div class="post">
-    <a class="tag" href="{% url 'tag' tag_name=tag.name %}">#{{ tag.name }}</a>
-</div>
  No newline at end of file
+    {% autoescape off %}
+        {{ tag.get_view }}
+    {% endautoescape %}
+</div>

boards/templates/boards/tags.html

@@ -1,27 +1,28 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 
 {% block head %}
     <title>Neboard - {% trans "Tags" %}</title>
 {% endblock %}
 
 {% block content %}
 
 {% cache 600 all_tags_list %}
     <div class="post">
         {% if all_tags %}
             {% for tag in all_tags %}
                 <div class="tag_item">
-                <a class="tag" href="{% url 'tag' tag.name %}">
-                #{{ tag.name }}</a>
+                    {% autoescape off %}
+                        {{ tag.get_view }}
+                    {% endautoescape %}
                 </div>
             {% endfor %}
         {% else %}
             {% trans 'No tags found.' %}
         {% endif %}
     </div>
 {% endcache %}
 
 {% endblock %}

boards/templates/boards/thread.html

@@ -1,95 +1,96 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
     <title>{{ opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
-    {% spaceless %}
     {% get_current_language as LANGUAGE_CODE %}
 
     {% cache 600 thread_view thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
 
     <div class="image-mode-tab">
         <a class="current_mode" href="{% url 'thread' opening_post.id %}">{% trans 'Normal mode' %}</a>,
         <a href="{% url 'thread_mode' opening_post.id 'gallery' %}">{% trans 'Gallery mode' %}</a>
     </div>
 
     {% if bumpable %}
         <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">
         {% with can_bump=thread.can_bump %}
         {% for post in thread.get_replies %}
-            {% if forloop.first %}
-                {% post_view post moderator=moderator is_opening=True thread=thread can_bump=can_bump opening_post_id=opening_post.id %}
-            {% else %}
-                {% post_view post moderator=moderator is_opening=False thread=thread can_bump=can_bump opening_post_id=opening_post.id %}
-            {% endif %}
+            {% with is_opening=forloop.first %}
+                {% post_view post moderator=moderator is_opening=is_opening thread=thread bumpable=can_bump opening_post_id=opening_post.id %}
+            {% endwith %}
         {% endfor %}
         {% endwith %}
     </div>
 
     {% if not thread.archived %}
-
-    <div class="post-form-w" id="form">
-        <script src="{% static 'js/panel.js' %}"></script>
-        <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}</div>
-        <div class="post-form" id="compact-form">
-            <div class="swappable-form-full">
-                <form enctype="multipart/form-data" method="post"
-                        >{% csrf_token %}
+        <div class="post-form-w" id="form">
+            <script src="{% static 'js/panel.js' %}"></script>
+            <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}</div>
+            <div class="post-form" id="compact-form">
+                <div class="swappable-form-full">
+                    <form enctype="multipart/form-data" method="post"
+                            >{% csrf_token %}
                         <div class="compact-form-text"></div>
-                    {{ form.as_div }}
-                    <div class="form-submit">
-                        <input type="submit" value="{% trans "Post" %}"/>
-                    </div>
-                </form>
+                        {{ form.as_div }}
+                        <div class="form-submit">
+                            <input type="submit" value="{% trans "Post" %}"/>
+                        </div>
+                    </form>
+                </div>
+                <a onclick="swapForm(); return false;" href="#">
+                    {% trans 'Switch mode' %}
+                </a>
+                <div><a href="{% url "staticpage" name="help" %}">
+                    {% trans 'Text syntax' %}</a></div>
             </div>
-            <a onclick="swapForm(); return false;" href="#">
-                {% trans 'Switch mode' %}
-            </a>
-            <div><a href="{% url "staticpage" name="help" %}">
-                {% trans 'Text syntax' %}</a></div>
         </div>
-    </div>
 
-    <script src="{% static 'js/jquery.form.min.js' %}"></script>
-    <script src="{% static 'js/thread_update.js' %}"></script>
+        <script src="{% static 'js/jquery.form.min.js' %}"></script>
+        <script src="{% static 'js/thread_update.js' %}"></script>
+        <script src="{% static 'js/3party/centrifuge.js' %}"></script>
     {% endif %}
 
     <script src="{% static 'js/form.js' %}"></script>
     <script src="{% static 'js/thread.js' %}"></script>
 
     {% endcache %}
-
-    {% endspaceless %}
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
-    <span class="metapanel" data-last-update="{{ last_update }}">
+    <span class="metapanel"
+          data-last-update="{{ last_update }}"
+          data-ws-token="{{ ws_token }}"
+          data-ws-project="{{ ws_project }}"
+          data-ws-host="{{ ws_host }}"
+          data-ws-port="{{ ws_port }}">
         {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
+            <span id="autoupdate">[-]</span>
             <span id="reply-count">{{ thread.get_reply_count }}</span>/{{ max_replies }} {% trans 'messages' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}<span id="last-update">{{ thread.last_edit_time }}</span>
             [<a href="rss/">RSS</a>]
         {% endcache %}
     </span>
 
 {% endblock %}

boards/templates/search/search.html

@@ -1,38 +1,38 b''
 {% extends 'boards/base.html' %}
 
 {% load board %}
 {% load i18n %}
 
 {% block content %}
     <div class="post-form-w">
         <div class="post-form">
             <h3>{% trans 'Search' %}</h3>
             <form method="get" action="">
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans 'Search' %}">
                 </div>
             </form>
         </div>
     </div>
 
     {% if page %}
         {% if page.has_previous %}
             <div class="page_link">
             <a href="?query={{ query }}&amp;page={{ page.previous_page_number }}">{% trans "Previous page" %}
             </a>
             </div>
         {% endif %}
 
         {% for result in page.object_list %}
-            {{ result.object.get_view }}
+            {{ result.object.get_search_view }}
         {% endfor %}
 
         {% if page.has_next %}
             <div class="page_link">
                 <a href="?query={{ query }}&amp;page={{ page.next_page_number }}">{% trans "Next page" %}
                 </a>
             </div>
         {% endif %}
     {% endif %}
-{% endblock %}
  No newline at end of file
+{% endblock %}

boards/tests/test_forms.py

@@ -1,55 +1,56 b''
 from django.test import TestCase, Client
 import time
 from boards import settings
-from boards.models import Post
+from boards.models import Post, Tag
 import neboard
 
 
 TEST_TAG = 'test_tag'
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 HTTP_CODE_REDIRECT = 302
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         client = Client()
 
         valid_tags = 'tag1 tag_2 тег_3'
         invalid_tags = '$%_356 ---'
+        Tag.objects.create(name='tag1', required=True)
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = neboard.settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         neboard.settings.POSTING_DELAY = 1
         time.sleep(neboard.settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg='No posts were created')

boards/tests/test_pages.py

@@ -1,56 +1,52 b''
 from django.test import TestCase, Client
 from boards.models import Tag, Post
 
 TEST_TEXT = 'test'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
-HTTP_CODE_REDIRECT = 302
+HTTP_CODE_REDIRECT = 301
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
-PAGE_404 = 'boards/404.html'
-
 
 class PagesTest(TestCase):
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         tag_name = 'test_tag'
         tag = Tag.objects.create(name=tag_name)
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=[tag])
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
-        self.assertEqual(PAGE_404, response_not_existing.templates[0].name,
+        self.assertEqual(HTTP_CODE_NOT_FOUND, response_not_existing.status_code,
                          'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + 'not_tag' + '/')
-        self.assertEqual(PAGE_404,
-                         response_not_existing.templates[0].name,
+        self.assertEqual(HTTP_CODE_NOT_FOUND, response_not_existing.status_code,
                          'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             thread=Post.objects.all()[0]
                                             .get_thread())
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
-        self.assertEqual(PAGE_404,
-                         response_not_existing.templates[0].name,
+        self.assertEqual(HTTP_CODE_REDIRECT, response_not_existing.status_code,
                          'Reply is opened as a thread')

boards/tests/test_post.py

@@ -1,142 +1,163 b''
 from django.core.paginator import Paginator
 from django.test import TestCase
 from boards import settings
 from boards.models import Tag, Post, Thread, KeyPair
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         tag = Tag.objects.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.objects.delete_post(post)
+        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()
+        opening_post.delete()
 
-        self.assertFalse(Post.objects.filter(id=reply.id).exists())
+        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.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')
-        self.assertTrue(thread in tag.threads.all(), 'Thread not added to tag')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
                          len(Thread.objects.filter(archived=False)))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.MAX_THREAD_COUNT):
             self._create_post()
 
         all_threads = Thread.objects.filter(archived=False)
 
         paginator = Paginator(Thread.objects.filter(archived=False),
                               settings.THREADS_PER_PAGE)
         posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].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.')
 
         post_global_reflink = Post.objects.create_post(title='',
                 text='[post]%s::%s::%d[/post]' % (
                     post.global_id.key_type, post.global_id.key, post.id),
                 thread=post.get_thread())
 
         self.assertTrue(post_global_reflink in post.referenced_posts.all(),
             'Global reflink not connecting posts.')
 
-        # TODO Check that links are parsed into the rendered text
+    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()
+
+        reply1 = Post.objects.create_post(title='title', text='text', thread=thread)
+        reply2 = 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.')

boards/tests/test_views.py

@@ -1,38 +1,46 b''
 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',
+}
+
 
 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,
-                                     '%s view not opened' % view_name)
+                            '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/thumbs.py

@@ -1,219 +1,215 b''
 # -*- encoding: utf-8 -*-
 """
 django-thumbs by Antonio Melé
 http://django.es
 """
 from django.core.files.images import ImageFile
 from django.db.models import ImageField
 from django.db.models.fields.files import ImageFieldFile
 from PIL import Image
 from django.core.files.base import ContentFile
 import io
 
 
 def generate_thumb(img, thumb_size, format):
     """
     Generates a thumbnail image and returns a ContentFile object with the thumbnail
 
     Parameters:
     ===========
     img         File object
 
     thumb_size  desired thumbnail size, ie: (200,120)
 
     format      format of the original image ('jpeg','gif','png',...)
                 (this format will be used for the generated thumbnail, too)
     """
 
     img.seek(0) # see http://code.djangoproject.com/ticket/8222 for details
     image = Image.open(img)
 
     # get size
     thumb_w, thumb_h = thumb_size
     # If you want to generate a square thumbnail
     if thumb_w == thumb_h:
         # quad
         xsize, ysize = image.size
         # get minimum size
         minsize = min(xsize, ysize)
         # largest square possible in the image
         xnewsize = (xsize - minsize) / 2
         ynewsize = (ysize - minsize) / 2
         # crop it
         image2 = image.crop(
             (xnewsize, ynewsize, xsize - xnewsize, ysize - ynewsize))
         # load is necessary after crop
         image2.load()
         # thumbnail of the cropped image (with ANTIALIAS to make it look better)
         image2.thumbnail(thumb_size, Image.ANTIALIAS)
     else:
         # not quad
         image2 = image
         image2.thumbnail(thumb_size, Image.ANTIALIAS)
 
     output = io.BytesIO()
     # PNG and GIF are the same, JPG is JPEG
     if format.upper() == 'JPG':
         format = 'JPEG'
 
     image2.save(output, format)
     return ContentFile(output.getvalue())
 
 
 class ImageWithThumbsFieldFile(ImageFieldFile):
     """
     See ImageWithThumbsField for usage example
     """
 
     def __init__(self, *args, **kwargs):
         super(ImageWithThumbsFieldFile, self).__init__(*args, **kwargs)
         self.sizes = self.field.sizes
 
         if self.sizes:
             def get_size(self, size):
                 if not self:
                     return ''
                 else:
                     split = self.url.rsplit('.', 1)
                     thumb_url = '%s.%sx%s.%s' % (split[0], w, h, split[1])
                     return thumb_url
 
             for size in self.sizes:
                 (w, h) = size
                 setattr(self, 'url_%sx%s' % (w, h), get_size(self, size))
 
     def save(self, name, content, save=True):
         super(ImageWithThumbsFieldFile, self).save(name, content, save)
 
         if self.sizes:
             for size in self.sizes:
                 (w, h) = size
                 split = self.name.rsplit('.', 1)
                 thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
                 # you can use another thumbnailing function if you like
                 thumb_content = generate_thumb(content, size, split[1])
 
                 thumb_name_ = self.storage.save(thumb_name, thumb_content)
 
                 if not thumb_name == thumb_name_:
                     raise ValueError(
                         'There is already a file named %s' % thumb_name)
 
     def delete(self, save=True):
         name = self.name
         super(ImageWithThumbsFieldFile, self).delete(save)
         if self.sizes:
             for size in self.sizes:
                 (w, h) = size
                 split = name.rsplit('.', 1)
                 thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
                 try:
                     self.storage.delete(thumb_name)
                 except:
                     pass
 
 
 class ImageWithThumbsField(ImageField):
     attr_class = ImageWithThumbsFieldFile
     """
     Usage example:
     ==============
     photo = ImageWithThumbsField(upload_to='images', sizes=((125,125),(300,200),)
     
     To retrieve image URL, exactly the same way as with ImageField:
         my_object.photo.url
     To retrieve thumbnails URL's just add the size to it:
         my_object.photo.url_125x125
         my_object.photo.url_300x200
     
     Note: The 'sizes' attribute is not required. If you don't provide it, 
     ImageWithThumbsField will act as a normal ImageField
         
     How it works:
     =============
     For each size in the 'sizes' atribute of the field it generates a 
     thumbnail with that size and stores it following this format:
     
     available_filename.[width]x[height].extension
 
     Where 'available_filename' is the available filename returned by the storage
     backend for saving the original file.
     
     Following the usage example above: For storing a file called "photo.jpg" it saves:
     photo.jpg          (original file)
     photo.125x125.jpg  (first thumbnail)
     photo.300x200.jpg  (second thumbnail)
     
     With the default storage backend if photo.jpg already exists it will use these filenames:
     photo_.jpg
     photo_.125x125.jpg
     photo_.300x200.jpg
     
     Note: django-thumbs assumes that if filename "any_filename.jpg" is available 
     filenames with this format "any_filename.[widht]x[height].jpg" will be available, too.
     
     To do:
     ======
     Add method to regenerate thubmnails
 
     
     """
 
     preview_width_field = None
     preview_height_field = None
 
     def __init__(self, verbose_name=None, name=None, width_field=None,
                  height_field=None, sizes=None,
                  preview_width_field=None, preview_height_field=None,
                  **kwargs):
         self.verbose_name = verbose_name
         self.name = name
         self.width_field = width_field
         self.height_field = height_field
         self.sizes = sizes
         super(ImageField, self).__init__(**kwargs)
 
         if sizes is not None and len(sizes) == 1:
             self.preview_width_field = preview_width_field
             self.preview_height_field = preview_height_field
 
     def update_dimension_fields(self, instance, force=False, *args, **kwargs):
         """
         Update original image dimension fields and thumb dimension fields
         (only if 1 thumb size is defined)
         """
 
         super(ImageWithThumbsField, self).update_dimension_fields(instance,
                                                                    force, *args,
                                                                    **kwargs)
         thumb_width_field = self.preview_width_field
         thumb_height_field = self.preview_height_field
 
         if thumb_width_field is None or thumb_height_field is None \
                 or len(self.sizes) != 1:
             return
 
         original_width = getattr(instance, self.width_field)
         original_height = getattr(instance, self.height_field)
 
         if original_width > 0 and original_height > 0:
             thumb_width, thumb_height = self.sizes[0]
 
             w_scale = float(thumb_width) / original_width
             h_scale = float(thumb_height) / original_height
             scale_ratio = min(w_scale, h_scale)
 
             if scale_ratio >= 1:
                 thumb_width_ratio = original_width
                 thumb_height_ratio = original_height
             else:
                 thumb_width_ratio = int(original_width * scale_ratio)
                 thumb_height_ratio = int(original_height * scale_ratio)
 
             setattr(instance, thumb_width_field, thumb_width_ratio)
-            setattr(instance, thumb_height_field, thumb_height_ratio)
-
-
-from south.modelsinspector import add_introspection_rules
-add_introspection_rules([], ["^boards\.thumbs\.ImageWithThumbsField"])
+            setattr(instance, thumb_height_field, thumb_height_ratio)
  No newline at end of file

boards/urls.py

@@ -1,87 +1,79 b''
 from django.conf.urls import patterns, url, include
 from django.contrib import admin
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags
 from boards.views.authors import AuthorsView
-from boards.views.delete_post import DeletePostView
 from boards.views.ban import BanUserView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
-from boards.views.post_admin import PostAdminView
 from boards.views.preview import PostPreviewView
 from boards.views.sync import get_post_sync_data
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', 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/tag/tag_id/page/
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
         tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\w+)/$', views.thread.ThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\w+)/mode/(?P<mode>\w+)/$', views.thread.ThreadView
         .as_view(), name='thread_mode'),
 
-    # /boards/post_admin/
-    url(r'^post_admin/(?P<post_id>\w+)/$', PostAdminView.as_view(),
-            name='post_admin'),
-
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
-    url(r'^delete/(?P<post_id>\w+)/$', DeletePostView.as_view(),
-            name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\w+)/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>\w+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\w+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/(?P<thread_id>\w+)/(?P<last_update_time>\w+)/$',
         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'),
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
     # 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,78 +1,43 b''
 """
 This module contains helper functions and helper classes.
 """
-import hashlib
 import time
+import hmac
 
 from django.utils import timezone
 
 from neboard import settings
 
 
 KEY_CAPTCHA_FAILS = 'key_captcha_fails'
 KEY_CAPTCHA_DELAY_TIME = 'key_captcha_delay_time'
 KEY_CAPTCHA_LAST_ACTIVITY = 'key_captcha_last_activity'
 
 
-def need_include_captcha(request):
-    """
-    Check if request is made by a user.
-    It contains rules which check for bots.
-    """
-
-    if not settings.ENABLE_CAPTCHA:
-        return False
-
-    enable_captcha = False
-
-    #newcomer
-    if KEY_CAPTCHA_LAST_ACTIVITY not in request.session:
-        return settings.ENABLE_CAPTCHA
-
-    last_activity = request.session[KEY_CAPTCHA_LAST_ACTIVITY]
-    current_delay = int(time.time()) - last_activity
-
-    delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
-                  if KEY_CAPTCHA_DELAY_TIME in request.session
-                  else settings.CAPTCHA_DEFAULT_SAFE_TIME)
-
-    if current_delay < delay_time:
-        enable_captcha = True
-
-    return enable_captcha
-
-
-def update_captcha_access(request, passed):
-    """
-    Update captcha fields.
-    It will reduce delay time if user passed captcha verification and
-    it will increase it otherwise.
-    """
-    session = request.session
-
-    delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
-                  if KEY_CAPTCHA_DELAY_TIME in request.session
-                  else settings.CAPTCHA_DEFAULT_SAFE_TIME)
-
-    if passed:
-        delay_time -= 2 if delay_time >= 7 else 5
-    else:
-        delay_time += 10
-
-    session[KEY_CAPTCHA_LAST_ACTIVITY] = int(time.time())
-    session[KEY_CAPTCHA_DELAY_TIME] = delay_time
-
-
 def get_client_ip(request):
     x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
     if x_forwarded_for:
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
         ip = request.META.get('REMOTE_ADDR')
     return ip
 
 
 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
  No newline at end of file

boards/views/all_tags.py

@@ -1,13 +1,14 b''
 from django.shortcuts import render
 
 from boards.views.base import BaseBoardView
 from boards.models.tag import Tag
 
 
 class AllTagsView(BaseBoardView):
 
     def get(self, request):
-        context = self.get_context_data(request=request)
-        context['all_tags'] = Tag.objects.get_not_empty_tags()
+        params = dict()
 
-        return render(request, 'boards/tags.html', context)
+        params['all_tags'] = Tag.objects.get_not_empty_tags()
+
+        return render(request, 'boards/tags.html', params)

boards/views/all_threads.py

@@ -1,139 +1,137 b''
-import string
-
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 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
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
+
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 
 TEMPLATE = 'boards/posting_general.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, BaseBoardView):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     def get(self, request, page=DEFAULT_PAGE, form=None):
-        context = self.get_context_data(request=request)
+        params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
         self.settings_manager = get_settings_manager(request)
         paginator = get_paginator(self.get_threads(),
                                   settings.THREADS_PER_PAGE)
         paginator.current_page = int(page)
 
         threads = paginator.page(page).object_list
 
-        context[PARAMETER_THREADS] = threads
-        context[CONTEXT_FORM] = form
+        params[PARAMETER_THREADS] = threads
+        params[CONTEXT_FORM] = form
 
-        self._get_page_context(paginator, context, page)
+        self._get_page_context(paginator, params, page)
 
-        return render(request, TEMPLATE, context)
+        return render(request, TEMPLATE, params)
 
     def post(self, request, page=DEFAULT_PAGE):
         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, page, form)
 
-    @staticmethod
-    def _get_page_context(paginator, context, page):
+    def _get_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
-        context[PARAMETER_PAGINATOR] = paginator
-        context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
+        params[PARAMETER_PAGINATOR] = paginator
+        params[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
 
     @staticmethod
     def parse_tags_string(tag_strings):
         """
         Parses tag list string and returns tag object list.
         """
 
         tags = []
 
         if tag_strings:
             tag_strings = tag_strings.split(TAG_DELIMITER)
             for tag_name in tag_strings:
                 tag_name = tag_name.strip().lower()
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
 
         return tags
 
     @transaction.atomic
     def create_thread(self, request, form, 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 = data[FORM_TITLE]
         text = data[FORM_TEXT]
+        image = data.get(FORM_IMAGE)
 
         text = self._remove_invalid_links(text)
 
-        if FORM_IMAGE in list(data.keys()):
-            image = data[FORM_IMAGE]
-        else:
-            image = None
-
         tag_strings = data[FORM_TAGS]
 
         tags = self.parse_tags_string(tag_strings)
 
         post = Post.objects.create_post(title=title, text=text, image=image,
                                         ip=ip, tags=tags)
 
+        # This is required to update the threads to which posts we have replied
+        # when creating this one
+        post.send_to_websocket(request)
+
         if html_response:
             return redirect(post.get_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         return Thread.objects.all().order_by('-bump_time')\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())

boards/views/api.py

@@ -1,248 +1,223 b''
 from datetime import datetime
 import json
 import logging
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, render
 from django.template import RequestContext
 from django.utils import timezone
 from django.core import serializers
-from django.template.loader import render_to_string
 
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Thread, Tag
 from boards.utils import datetime_to_epoch
 from boards.views.thread import ThreadView
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 
 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, thread_id, last_update_time):
     """
     Gets posts that were changed or added since time
     """
 
     thread = get_object_or_404(Post, id=thread_id).get_thread()
 
     # Add 1 to ensure we don't load the same post over and over
     last_update_timestamp = float(last_update_time) + 1
 
     filter_time = datetime.fromtimestamp(last_update_timestamp / 1000000,
                                          timezone.get_current_timezone())
 
     json_data = {
         'added': [],
         'updated': [],
         'last_update': None,
     }
     added_posts = Post.objects.filter(thread_new=thread,
                                       pub_time__gt=filter_time) \
         .order_by('pub_time')
     updated_posts = Post.objects.filter(thread_new=thread,
                                         pub_time__lte=filter_time,
                                         last_edit_time__gt=filter_time)
 
-    diff_type = DIFF_TYPE_HTML
-    if PARAMETER_DIFF_TYPE in request.GET:
-        diff_type = request.GET[PARAMETER_DIFF_TYPE]
+    diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     for post in added_posts:
-        json_data['added'].append(_get_post_data(post.id, diff_type, request))
+        json_data['added'].append(get_post_data(post.id, diff_type, request))
     for post in updated_posts:
-        json_data['updated'].append(_get_post_data(post.id, diff_type, request))
+        json_data['updated'].append(get_post_data(post.id, diff_type, request))
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 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.
     """
 
-    logger.info('Getting post #%s' % post_id)
-
     post = get_object_or_404(Post, id=post_id)
 
     context = RequestContext(request)
     context['post'] = post
     if PARAMETER_TRUNCATED in request.GET:
         context[PARAMETER_TRUNCATED] = True
 
-    return render(request, 'boards/api_post.html', context)
+    # TODO Use dict here
+    return render(request, 'boards/api_post.html', context_instance=context)
 
 
 # TODO Test this
 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.threads.filter(archived=False)
+            threads = tag.get_threads().filter(archived=False)
     else: 
         threads = Thread.objects.filter(archived=False)
 
     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
-        opening_posts.append(_get_post_data(opening_post.id,
+        opening_posts.append(get_post_data(opening_post.id,
                                             include_last_update=True))
 
     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()
     tag_names = []
     for tag in tags:
         tag_names.append(tag.name)
 
     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(_get_post_data(post.id))
+        json_post_list.append(get_post_data(post.id))
     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_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)
 
 
-# TODO Add pub time and replies
-def _get_post_data(post_id, format_type=DIFF_TYPE_JSON, request=None,
-        include_last_update=False):
-    if format_type == DIFF_TYPE_HTML:
-        post = get_object_or_404(Post, id=post_id)
-
-        context = RequestContext(request)
-        context['post'] = post
-        if PARAMETER_TRUNCATED in request.GET:
-            context[PARAMETER_TRUNCATED] = True
-
-        return render_to_string('boards/api_post.html', context)
-    elif format_type == DIFF_TYPE_JSON:
-        post = get_object_or_404(Post, id=post_id)
-        post_json = {
-            'id': post.id,
-            'title': post.title,
-            'text': post.text.rendered,
-        }
-        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'] = datetime_to_epoch(
-                post.thread_new.bump_time)
-        return post_json
+# TODO Remove this method and use post method directly
+def get_post_data(post_id, format_type=DIFF_TYPE_JSON, request=None,
+                  include_last_update=False):
+    post = get_object_or_404(Post, id=post_id)
+    return post.get_post_data(format_type=format_type, request=request,
+                              include_last_update=include_last_update)

boards/views/authors.py

@@ -1,13 +1,13 b''
 from django.shortcuts import render
 
 from boards.authors import authors
 from boards.views.base import BaseBoardView
 
 
 class AuthorsView(BaseBoardView):
 
     def get(self, request):
-        context = self.get_context_data(request=request)
-        context['authors'] = authors
+        params = dict()
+        params['authors'] = authors
 
-        return render(request, 'boards/authors.html', context)
+        return render(request, 'boards/authors.html', params)

boards/views/banned.py

@@ -1,16 +1,17 b''
 from django.shortcuts import get_object_or_404, render
 from boards import utils
 from boards.models import Ban
 from boards.views.base import BaseBoardView
 
 
 class BannedView(BaseBoardView):
 
     def get(self, request):
         """Show the page that notifies that user is banned"""
 
-        context = self.get_context_data(request=request)
+        params = dict()
 
         ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
-        context['ban_reason'] = ban.reason
-        return render(request, 'boards/staticpages/banned.html', context)
+        params['ban_reason'] = ban.reason
+
+        return render(request, 'boards/staticpages/banned.html', params)

boards/views/base.py

@@ -1,35 +1,31 b''
 from django.db import transaction
 from django.template import RequestContext
 from django.views.generic import View
 
 from boards import utils
 from boards.models.user import Ban
 
 
 BAN_REASON_SPAM = 'Autoban: spam bot'
 
 CONTEXT_FORM = 'form'
 
 
 class BaseBoardView(View):
 
     def get_context_data(self, **kwargs):
-        request = kwargs['request']
-        # context = self._default_context(request)
-        context = RequestContext(request)
-
-        return context
+        return dict()
 
     @transaction.atomic
     def _ban_current_user(self, request):
         """
         Add current user to the IP ban list
         """
 
         ip = utils.get_client_ip(request)
         ban, created = Ban.objects.get_or_create(ip=ip)
         if created:
             ban.can_read = False
             ban.reason = BAN_REASON_SPAM
         ban.save()
 

boards/views/mixins.py

@@ -1,39 +1,40 b''
+PARAM_NEXT = 'next'
 PARAMETER_METHOD = 'method'
 
 from django.shortcuts import redirect
 from django.http import HttpResponseRedirect
 
 
 class RedirectNextMixin:
 
     def redirect_to_next(self, request):
         """
         If a 'next' parameter was specified, redirect to the next page. This
         is used when the user is required to return to some page after the
         current view has finished its work.
         """
 
-        if 'next' in request.GET:
-            next_page = request.GET['next']
+        if PARAM_NEXT in request.GET:
+            next_page = request.GET[PARAM_NEXT]
             return HttpResponseRedirect(next_page)
         else:
             return redirect('index')
 
 
 class DispatcherMixin:
     """
     This class contains a dispather method that can run a method specified by
     'method' request parameter.
     """
 
     def dispatch_method(self, *args, **kwargs):
         request = args[0]
 
         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)

boards/views/not_found.py

@@ -1,13 +1,17 b''
 from django.shortcuts import render
 
 from boards.views.base import BaseBoardView
 
 
 class NotFoundView(BaseBoardView):
     """
     Page 404 (not found)
     """
 
     def get(self, request):
-        context = self.get_context_data(request=request)
-        return render(request, 'boards/404.html', context)
+        params = self.get_context_data()
+
+        response = render(request, 'boards/404.html', params)
+        response.status_code = 404
+
+        return response

boards/views/preview.py

@@ -1,35 +1,37 b''
 from django.shortcuts import render
 from django.template import RequestContext
 from django.views.generic import View
 
 from boards.mdx_neboard import bbcode_extended
 
 FORM_QUERY = 'query'
 
 CONTEXT_RESULT = 'result'
 CONTEXT_QUERY = 'query'
 
 __author__ = 'neko259'
 
 TEMPLATE = 'boards/preview.html'
 
 
 class PostPreviewView(View):
     def get(self, request):
         context = RequestContext(request)
 
-        return render(request, TEMPLATE, context)
+        # TODO Use dict here
+        return render(request, TEMPLATE, context_instance=context)
 
     def post(self, request):
         context = RequestContext(request)
 
         if FORM_QUERY in request.POST:
             raw_text = request.POST[FORM_QUERY]
 
             if len(raw_text) >= 0:
                 rendered_text = bbcode_extended(raw_text)
 
                 context[CONTEXT_RESULT] = rendered_text
                 context[CONTEXT_QUERY] = raw_text
 
-        return render(request, TEMPLATE, context)
+        # TODO Use dict here
+        return render(request, TEMPLATE, context_instance=context)

boards/views/search.py

@@ -1,40 +1,43 b''
 from django.shortcuts import render
-from django.template import RequestContext
 from django.views.generic import View
 from haystack.query import SearchQuerySet
+
 from boards.abstracts.paginator import get_paginator
 from boards.forms import SearchForm, PlainErrorList
 
+
+MIN_QUERY_LENGTH = 3
+RESULTS_PER_PAGE = 10
+
 FORM_QUERY = 'query'
 
 CONTEXT_QUERY = 'query'
 CONTEXT_FORM = 'form'
 CONTEXT_PAGE = 'page'
 
 REQUEST_PAGE = 'page'
 
 __author__ = 'neko259'
 
 TEMPLATE = 'search/search.html'
 
 
 class BoardSearchView(View):
     def get(self, request):
-        context = RequestContext(request)
+        params = dict()
+
         form = SearchForm(request.GET, error_class=PlainErrorList)
-        context[CONTEXT_FORM] = form
+        params[CONTEXT_FORM] = form
 
         if form.is_valid():
             query = form.cleaned_data[FORM_QUERY]
-            if len(query) >= 3:
-                results = SearchQuerySet().auto_query(query).order_by('-id').load_all()
-                paginator = get_paginator(results, 10)
+            if len(query) >= MIN_QUERY_LENGTH:
+                results = SearchQuerySet().auto_query(query).order_by('-id')
+                paginator = get_paginator(results, RESULTS_PER_PAGE)
 
-                if REQUEST_PAGE in request.GET:
-                    page = int(request.GET[REQUEST_PAGE])
-                else:
-                    page = 1
-                context[CONTEXT_PAGE] = paginator.page(page)
-                context[CONTEXT_QUERY] = query
+                page = int(request.GET.get(REQUEST_PAGE, '1'))
 
-        return render(request, TEMPLATE, context)
+                params[CONTEXT_PAGE] = paginator.page(page)
+                params[CONTEXT_QUERY] = query
+
+        return render(request, TEMPLATE, params)

boards/views/settings.py

@@ -1,38 +1,41 b''
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.forms import SettingsForm, PlainErrorList
 
+FORM_THEME = 'theme'
+
 CONTEXT_HIDDEN_TAGS = 'hidden_tags'
 
 
 class SettingsView(BaseBoardView):
 
     def get(self, request):
-        context = self.get_context_data(request=request)
+        params = self.get_context_data()
         settings_manager = get_settings_manager(request)
 
         selected_theme = settings_manager.get_theme()
 
-        form = SettingsForm(initial={'theme': selected_theme},
+        form = SettingsForm(initial={FORM_THEME: selected_theme},
                             error_class=PlainErrorList)
 
-        context[CONTEXT_FORM] = form
-        context[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
+        params[CONTEXT_FORM] = form
+        params[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
-        return render(request, 'boards/settings.html', context)
+        # TODO Use dict here
+        return render(request, 'boards/settings.html', params)
 
     def post(self, request):
         settings_manager = get_settings_manager(request)
 
         with transaction.atomic():
             form = SettingsForm(request.POST, error_class=PlainErrorList)
 
             if form.is_valid():
-                selected_theme = form.cleaned_data['theme']
+                selected_theme = form.cleaned_data[FORM_THEME]
 
                 settings_manager.set_theme(selected_theme)
 
             return redirect('settings')

boards/views/static.py

@@ -1,14 +1,13 b''
 from django.shortcuts import render
 
 from boards.views.base import BaseBoardView
 
 
 class StaticPageView(BaseBoardView):
 
     def get(self, request, name):
         """
         Show a static page that needs only tags list and a CSS
         """
 
-        context = self.get_context_data(request=request)
-        return render(request, 'boards/staticpages/' + name + '.html', context)
+        return render(request, 'boards/staticpages/' + name + '.html')

boards/views/tag_threads.py

@@ -1,92 +1,95 b''
 from django.shortcuts import get_object_or_404
 
 from boards.abstracts.settingsmanager import get_settings_manager
-from boards.models import Tag
+from boards.models import Tag, Thread
 from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
 from boards.views.mixins import DispatcherMixin, RedirectNextMixin
 from boards.forms import ThreadForm, PlainErrorList
 
+PARAM_HIDDEN_TAGS = 'hidden_tags'
+PARAM_FAV_TAGS = 'fav_tags'
+PARAM_TAG = 'tag'
 
 __author__ = 'neko259'
 
 
 class TagView(AllThreadsView, DispatcherMixin, RedirectNextMixin):
 
     tag_name = None
 
     def get_threads(self):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
-        return tag.threads.all().order_by('-bump_time')
+        return tag.get_threads()
 
     def get_context_data(self, **kwargs):
-        context = super(TagView, self).get_context_data(**kwargs)
+        params = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
         tag = get_object_or_404(Tag, name=self.tag_name)
-        context['tag'] = tag
+        params[PARAM_TAG] = tag
 
-        context['fav_tags'] = settings_manager.get_fav_tags()
-        context['hidden_tags'] = settings_manager.get_hidden_tags()
+        params[PARAM_FAV_TAGS] = settings_manager.get_fav_tags()
+        params[PARAM_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
-        return context
+        return params
 
     def get(self, request, tag_name, page=DEFAULT_PAGE, form=None):
         self.tag_name = tag_name
 
         dispatch_result = self.dispatch_method(request)
         if dispatch_result:
             return dispatch_result
         else:
             return super(TagView, self).get(request, page, form)
 
     def post(self, request, tag_name, page=DEFAULT_PAGE):
         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, tag_name, page, form)
 
     def subscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_fav_tag(tag)
 
         return self.redirect_to_next(request)
 
     def unsubscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_tag(tag)
 
         return self.redirect_to_next(request)
 
     def hide(self, request):
         """
         Adds tag to user's hidden tags. Threads with this tag will not be
         shown.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_hidden_tag(tag)
 
     def unhide(self, request):
         """
         Removed tag from user's hidden tags.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_hidden_tag(tag)

boards/views/thread.py

@@ -1,142 +1,142 b''
 from django.core.urlresolvers import reverse
 from django.db import transaction
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
 from django.views.generic.edit import FormMixin
 
 from boards import utils, settings
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Ban
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
+import neboard
 
 TEMPLATE_GALLERY = 'boards/thread_gallery.html'
 TEMPLATE_NORMAL = 'boards/thread.html'
 
 CONTEXT_POSTS = 'posts'
 CONTEXT_OP = 'opening_post'
 CONTEXT_BUMPLIMIT_PRG = 'bumplimit_progress'
 CONTEXT_POSTS_LEFT = 'posts_left'
 CONTEXT_LASTUPDATE = "last_update"
 CONTEXT_MAX_REPLIES = 'max_replies'
 CONTEXT_THREAD = 'thread'
 CONTEXT_BUMPABLE = 'bumpable'
+CONTEXT_WS_TOKEN = 'ws_token'
+CONTEXT_WS_PROJECT = 'ws_project'
+CONTEXT_WS_HOST = 'ws_host'
+CONTEXT_WS_PORT = 'ws_port'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 
 MODE_GALLERY = 'gallery'
 MODE_NORMAL = 'normal'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin):
 
     def get(self, request, post_id, mode=MODE_NORMAL, form=None):
         try:
             opening_post = Post.objects.filter(id=post_id).only('thread_new')[0]
         except IndexError:
             raise Http404
 
         # If this is not OP, don't show it as it is
         if not opening_post or not opening_post.is_opening():
             raise Http404
 
         if not form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.get_thread()
 
-        context = self.get_context_data(request=request)
+        params = dict()
+
+        params[CONTEXT_FORM] = form
+        params[CONTEXT_LASTUPDATE] = str(utils.datetime_to_epoch(
+            thread_to_show.last_edit_time))
+        params[CONTEXT_THREAD] = thread_to_show
+        params[CONTEXT_MAX_REPLIES] = settings.MAX_POSTS_PER_THREAD
 
-        context[CONTEXT_FORM] = form
-        context[CONTEXT_LASTUPDATE] = utils.datetime_to_epoch(
-            thread_to_show.last_edit_time)
-        context[CONTEXT_THREAD] = thread_to_show
-        context[CONTEXT_MAX_REPLIES] = settings.MAX_POSTS_PER_THREAD
+        if settings.WEBSOCKETS_ENABLED:
+            params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
+                timestamp=params[CONTEXT_LASTUPDATE])
+            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
 
+        # TODO Move this to subclasses: NormalThreadView, GalleryThreadView etc
         if MODE_NORMAL == mode:
             bumpable = thread_to_show.can_bump()
-            context[CONTEXT_BUMPABLE] = bumpable
+            params[CONTEXT_BUMPABLE] = bumpable
             if bumpable:
                 left_posts = settings.MAX_POSTS_PER_THREAD \
                              - thread_to_show.get_reply_count()
-                context[CONTEXT_POSTS_LEFT] = left_posts
-                context[CONTEXT_BUMPLIMIT_PRG] = str(
+                params[CONTEXT_POSTS_LEFT] = left_posts
+                params[CONTEXT_BUMPLIMIT_PRG] = str(
                     float(left_posts) / settings.MAX_POSTS_PER_THREAD * 100)
 
-            context[CONTEXT_OP] = opening_post
+            params[CONTEXT_OP] = opening_post
 
             document = TEMPLATE_NORMAL
         elif MODE_GALLERY == mode:
-            context[CONTEXT_POSTS] = thread_to_show.get_replies_with_images(
+            params[CONTEXT_POSTS] = thread_to_show.get_replies_with_images(
                 view_fields_only=True)
 
             document = TEMPLATE_GALLERY
         else:
             raise Http404
 
-        return render(request, document, context)
+        return render(request, document, params)
 
     def post(self, request, post_id, mode=MODE_NORMAL):
         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 not opening_post.get_thread().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, mode, form)
 
-    @transaction.atomic
     def new_post(self, request, form, opening_post=None, html_response=True):
         """Add a new post (in thread or as a reply)."""
 
         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 None
 
         data = form.cleaned_data
 
         title = data[FORM_TITLE]
         text = data[FORM_TEXT]
+        image = data.get(FORM_IMAGE)
 
         text = self._remove_invalid_links(text)
 
-        if FORM_IMAGE in list(data.keys()):
-            image = data[FORM_IMAGE]
-        else:
-            image = None
-
-        tags = []
-
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, image=image,
-                                        thread=post_thread, ip=ip, tags=tags)
+                                        thread=post_thread, ip=ip)
+        post.send_to_websocket(request)
 
         thread_to_show = (opening_post.id if opening_post else post.id)
 
         if html_response:
             if opening_post:
                 return redirect(
                     reverse('thread', kwargs={'post_id': thread_to_show})
                     + '#' + str(post.id))
         else:
             return post

manage.py

@@ -1,10 +1,10 b''
-#!/usr/bin/env python
+#!/usr/bin/env python3
 import os
 import sys
 
 if __name__ == "__main__":
     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "neboard.settings")
 
     from django.core.management import execute_from_command_line
 
     execute_from_command_line(sys.argv)

neboard/settings.py

@@ -1,235 +1,233 b''
 # Django settings for neboard project.
 import os
 from boards.mdx_neboard import bbcode_extended
 
 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
 
 # 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',
+    'compressor.finders.CompressorFinder',
 )
 
 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',
 )
 
 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.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.MinifyHTMLMiddleware',
 )
 
 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',
     'django_cleanup',
 
-    # Migrations
-    'south',
     '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 %(module)s %(process)d %(thread)d %(message)s'
+            'format': '%(levelname)s %(asctime)s %(name)s %(process)d %(thread)d %(message)s'
         },
         'simple': {
-            'format': '%(levelname)s %(asctime)s [%(module)s] %(message)s'
+            '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'),
     },
 }
 
-MARKUP_FIELD_TYPES = (
-    ('bbcode', bbcode_extended),
-)
-
 THEMES = [
     ('md', 'Mystic Dark'),
     ('md_centered', 'Mystic Dark (centered)'),
     ('sw', 'Snow White'),
     ('pg', 'Photon Gray'),
 ]
 
-POPULAR_TAGS = 10
-
 POSTING_DELAY = 20  # seconds
 
-COMPRESS_HTML = True
+# 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 mode middlewares
 if DEBUG:
     MIDDLEWARE_CLASSES += (
         'debug_toolbar.middleware.DebugToolbarMiddleware',
     )
 
     def custom_show_toolbar(request):
-        return False
+        return True
 
     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',
     #)
-

readme.markdown

@@ -1,55 +1,38 b''
 # INTRO #
 
 This project aims to create centralized forum-like discussion platform with
 anonymity in mind.
 
 Main repository: https://bitbucket.org/neko259/neboard/
 
 Site: http://neboard.me/
 
-# DEPENDENCIES #
-
-## REQUIRED ##
-
-* pillow
-* django >= 1.6
-* django_cleanup
-* django-markupfield
-* markdown
-* python-markdown
-* django-simple-captcha
-* line-profiler
-
-## OPTIONAL ##
-
-* django-debug-toolbar
-
 # INSTALLATION #
 
 1. Install all dependencies over pip or system-wide
 2. Setup a database in `neboard/settings.py`
 3. Run `./manage.py syncdb` and ensure the database was created
 4. Run `./manage.py migrate boards` to apply all south migrations
 
 # RUNNING #
 
 You can run the server using django default embedded webserver by running
 
     ./manage.py runserver <address>:<port>
 
 See django-admin command help for details
 
 Also consider using wsgi or fcgi interfaces on production servers.
 
 # UPGRADE #
 
 1. Backup your project data.
 2. Save the settings in `neboard/settings.py` and `boards/settings.py`
 3. Copy the project contents over the old project directory
 4. Run migrations by `./manage.py migrate boards`
 
 You can also just clone the mercurial project and pull it to update
 
 # CONCLUSION #
 
 Enjoy our software and thank you!

requirements.txt

@@ -1,10 +1,9 b''
 httplib2
 simplejson
-south>=0.8.4
+adjacent
 haystack
 pillow
-django>=1.6
+django>=1.7
 django_cleanup
-django-markupfield
 bbcode
 ecdsa