diff --git a/src/pretix/base/views/async.py b/src/pretix/base/views/async.py
new file mode 100644
index 0000000000..9be9f684f1
--- /dev/null
+++ b/src/pretix/base/views/async.py
@@ -0,0 +1,134 @@
+import logging
+
+from django.conf import settings
+from django.contrib import messages
+from django.http import JsonResponse
+from django.shortcuts import redirect, render
+from django.utils.translation import ugettext as _
+
+logger = logging.getLogger('pretix.base.async')
+
+
+class AsyncAction:
+    task = None
+    success_url = None
+    error_url = None
+
+    def do(self, *args):
+        if settings.HAS_CELERY:
+            from pretix.celery import app
+
+            if hasattr(self.task, 'task') and isinstance(self.task.task, app.Task):
+                return self._do_celery(args)
+            else:
+                raise TypeError('Method has no task attached')
+        else:
+            return self._do_sync(args)
+
+    def get_success_url(self, value):
+        return self.success_url
+
+    def get_error_url(self):
+        return self.error_url
+
+    def get_check_url(self, task_id, ajax):
+        return self.request.path + '?async_id=%s' % task_id + ('&ajax=1' if ajax else '')
+
+    def get(self, request, *args, **kwargs):
+        if 'async_id' in request.GET and settings.HAS_CELERY:
+            return self.get_result(request)
+        return self.http_method_not_allowed(request)
+
+    def _return_celery_result(self, res, timeout=.5):
+        import celery.exceptions
+
+        if not res.ready():
+            try:
+                res.get(timeout=timeout)
+            except celery.exceptions.TimeoutError:
+                pass
+        ready = res.ready()
+        data = {
+            'async_id': res.id,
+            'ready': ready
+        }
+        if ready:
+            if res.successful() and not isinstance(res.info, Exception):
+                smes = self.get_success_message(res.info)
+                if smes:
+                    messages.success(self.request, smes)
+                # TODO: Do not store message if the ajax client stats that it will not redirect
+                # but handle the mssage itself
+                data.update({
+                    'redirect': self.get_success_url(res.info),
+                    'message': str(self.get_success_message(res.info))
+                })
+            else:
+                messages.error(self.request, self.get_error_message(res.info))
+                # TODO: Do not store message if the ajax client stats that it will not redirect
+                # but handle the mssage itself
+                data.update({
+                    'redirect': self.get_error_url(),
+                    'message': str(self.get_error_message(res.info))
+                })
+        return data
+
+    def get_result(self, request):
+        from celery.result import AsyncResult
+
+        res = AsyncResult(request.GET.get('async_id'))
+        if 'ajax' in self.request.GET:
+            return JsonResponse(self._return_celery_result(res, timeout=0.25))
+        else:
+            if res.ready():
+                if res.successful():
+                    return self.success(res.info)
+                else:
+                    return self.error(res.info)
+            return render(request, 'pretixpresale/waiting.html')
+
+    def _do_celery(self, args):
+        res = self.task.task.apply_async(args=args)
+        if 'ajax' in self.request.GET or 'ajax' in self.request.POST:
+            data = self._return_celery_result(res)
+            data['check_url'] = self.get_check_url(res.id, True)
+            return JsonResponse(data)
+        else:
+            return redirect(self.get_check_url(res.id, False))
+
+    def _do_sync(self, args):
+        try:
+            rs = getattr(self.__class__, 'task')(*args)
+            return self.success(rs)
+        except Exception as e:
+            logger.exception('Error while executing task synchronously')
+            return self.error(e)
+
+    def success(self, value):
+        smes = self.get_success_message(value)
+        if smes:
+            messages.success(self.request, smes)
+        if "ajax" in self.request.POST or "ajax" in self.request.GET:
+            return JsonResponse({
+                'ready': True,
+                'redirect': self.get_success_url(value),
+                'message': str(self.get_success_message(value))
+            })
+        return redirect(self.get_success_url(value))
+
+    def error(self, exception):
+        messages.error(self.request, self.get_error_message(exception))
+        if "ajax" in self.request.POST or "ajax" in self.request.GET:
+            return JsonResponse({
+                'ready': True,
+                'redirect': self.get_error_url(),
+                'message': str(self.get_error_message(exception))
+            })
+        return redirect(self.get_error_url())
+
+    def get_error_message(self, exception):
+        logger.error('Unexpected exception: %r' % exception)
+        return _('An unexpected error has occured.')
+
+    def get_success_message(self, value):
+        return _('The task has been completed.')
diff --git a/src/pretix/control/templates/pretixcontrol/base.html b/src/pretix/control/templates/pretixcontrol/base.html
index 21d1fb97e3..42ba451fd1 100644
--- a/src/pretix/control/templates/pretixcontrol/base.html
+++ b/src/pretix/control/templates/pretixcontrol/base.html
@@ -13,6 +13,7 @@
 		{% compress js %}
             <script type="text/javascript" src="{% static "jquery/js/jquery-2.1.1.min.js" %}"></script>
             <script type="text/javascript" src="{% static "js/jquery.formset.js" %}"></script>
+            <script type="text/javascript" src="{% static "typeahead/typeahead.bundle.js" %}"></script>
             <script type="text/javascript" src="{% static "bootstrap/js/bootstrap.js" %}"></script>
             <script type="text/javascript" src="{% static "pretixcontrol/js/metisMenu.min.js" %}"></script>
             <script type="text/javascript" src="{% static "pretixcontrol/js/sb-admin-2.js" %}"></script>
@@ -132,5 +133,14 @@
                 </div>
             </div>
         </div>
+        <div id="ajaxerr">
+        </div>
+        <div id="loadingmodal">
+            <i class="fa fa-cog big-rotating-icon"></i>
+            <h1>{% trans "We are processing your request…" %}</h1>
+            <p>
+                {% trans "If this takes longer than a few minutes, please contact us." %}
+            </p>
+        </div>
 	</body>
 </html>
diff --git a/src/pretix/control/views/orders.py b/src/pretix/control/views/orders.py
index 13a9ddf514..9318b6d5ca 100644
--- a/src/pretix/control/views/orders.py
+++ b/src/pretix/control/views/orders.py
@@ -42,8 +42,8 @@ from pretix.multidomain.urlreverse import build_absolute_uri
 class OrderList(EventPermissionRequiredMixin, ListView):
     model = Order
     context_object_name = 'orders'
-    template_name = 'pretixcontrol/orders/index.html'
     paginate_by = 30
+    template_name = 'pretixcontrol/orders/index.html'
     permission = 'can_view_orders'
 
     def get_queryset(self):
diff --git a/src/pretix/plugins/banktransfer/__init__.py b/src/pretix/plugins/banktransfer/__init__.py
index 5ef3187d41..abb40d57b2 100644
--- a/src/pretix/plugins/banktransfer/__init__.py
+++ b/src/pretix/plugins/banktransfer/__init__.py
@@ -20,6 +20,7 @@ class BankTransferApp(AppConfig):
 
     def ready(self):
         from . import signals  # NOQA
+        from . import tasks  # NOQA
 
     @cached_property
     def compatibility_warnings(self):
@@ -28,10 +29,6 @@ class BankTransferApp(AppConfig):
             import chardet  # NOQA
         except ImportError:
             errs.append(_("Install the python package 'chardet' for better CSV import capabilities."))
-        try:
-            import defusedxml  # NOQA
-        except ImportError:
-            errs.append(_("Please install the python package 'defusedxml' for security reasons."))
         return errs
 
 
diff --git a/src/pretix/plugins/banktransfer/migrations/0001_initial.py b/src/pretix/plugins/banktransfer/migrations/0001_initial.py
new file mode 100644
index 0000000000..ae73e69b44
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/migrations/0001_initial.py
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.4 on 2016-09-07 09:35
+from __future__ import unicode_literals
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('pretixbase', '0036_auto_20160902_0755'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='BankImportJob',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('state', models.CharField(choices=[('running', 'pending'), ('running', 'running'), ('error', 'error'), ('completed', 'completed')], default='running', max_length=32)),
+                ('event', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pretixbase.Event')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='BankTransaction',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('state', models.CharField(choices=[('imported', 'imported, unchecked'), ('nomatch', 'no match'), ('invalid', 'not valid'), ('error', 'error'), ('valid', 'valid'), ('already', 'valid, already paid'), ('discarded', 'manually discarded')], default='imported', max_length=32)),
+                ('message', models.TextField()),
+                ('checksum', models.CharField(db_index=True, max_length=190)),
+                ('payer', models.TextField(blank=True)),
+                ('reference', models.TextField(blank=True)),
+                ('amount', models.DecimalField(decimal_places=2, max_digits=10)),
+                ('date', models.DateField()),
+                ('event', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pretixbase.Event')),
+                ('import_job', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='banktransfer.BankImportJob')),
+                ('order', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='pretixbase.Order')),
+            ],
+        ),
+        migrations.AlterUniqueTogether(
+            name='banktransaction',
+            unique_together=set([('event', 'checksum')]),
+        ),
+    ]
diff --git a/src/pretix/plugins/banktransfer/migrations/__init__.py b/src/pretix/plugins/banktransfer/migrations/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/pretix/plugins/banktransfer/models.py b/src/pretix/plugins/banktransfer/models.py
new file mode 100644
index 0000000000..410cd6ac83
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/models.py
@@ -0,0 +1,68 @@
+import hashlib
+import re
+
+from django.db import models
+
+
+class BankImportJob(models.Model):
+    STATE_PENDING = 'pending'
+    STATE_RUNNING = 'running'
+    STATE_ERROR = 'error'
+    STATE_COMPLETED = 'completed'
+    STATES = (
+        (STATE_PENDING, 'pending'),
+        (STATE_RUNNING, 'running'),
+        (STATE_ERROR, 'error'),
+        (STATE_COMPLETED, 'completed'),
+    )
+
+    event = models.ForeignKey('pretixbase.Event')
+    created = models.DateTimeField(auto_now_add=True)
+    state = models.CharField(max_length=32, choices=STATES, default=STATE_PENDING)
+
+
+class BankTransaction(models.Model):
+    STATE_UNCHECKED = 'imported'
+    STATE_NOMATCH = 'nomatch'
+    STATE_INVALID = 'invalid'
+    STATE_ERROR = 'error'
+    STATE_VALID = 'valid'
+    STATE_DISCARDED = 'discarded'
+    STATE_DUPLICATE = 'already'
+
+    STATES = (
+        (STATE_UNCHECKED, 'imported, unchecked'),
+        (STATE_NOMATCH, 'no match'),
+        (STATE_INVALID, 'not valid'),
+        (STATE_ERROR, 'error'),
+        (STATE_VALID, 'valid'),
+        (STATE_DUPLICATE, 'valid, already paid'),
+        (STATE_DISCARDED, 'manually discarded'),
+    )
+
+    event = models.ForeignKey('pretixbase.Event')
+    import_job = models.ForeignKey('BankImportJob', related_name='transactions')
+    state = models.CharField(max_length=32, choices=STATES, default=STATE_UNCHECKED)
+    message = models.TextField()
+    checksum = models.CharField(max_length=190, db_index=True)
+    payer = models.TextField(blank=True)
+    reference = models.TextField(blank=True)
+    amount = models.DecimalField(max_digits=10, decimal_places=2)
+    date = models.DateField()
+    order = models.ForeignKey('pretixbase.Order', null=True, blank=True)
+
+    def calculate_checksum(self):
+        clean = re.compile('[^a-zA-Z0-9.-]')
+        hasher = hashlib.sha1()
+        hasher.update(clean.sub('', self.payer.lower()).encode('utf-8'))
+        hasher.update(clean.sub('', self.reference.lower()).encode('utf-8'))
+        hasher.update(clean.sub('', str(self.amount).lower()).encode('utf-8'))
+        hasher.update(clean.sub('', str(self.date).lower()).encode('utf-8'))
+        return str(hasher.hexdigest())
+
+    def shred_private_data(self):
+        self.payer = ""
+        self.reference = ""
+
+    class Meta:
+        unique_together = ('event', 'checksum')
diff --git a/src/pretix/plugins/banktransfer/signals.py b/src/pretix/plugins/banktransfer/signals.py
index b3bef1b537..b31fc531e4 100644
--- a/src/pretix/plugins/banktransfer/signals.py
+++ b/src/pretix/plugins/banktransfer/signals.py
@@ -1,9 +1,11 @@
 from django.core.urlresolvers import resolve, reverse
 from django.dispatch import receiver
+from django.template import Context
+from django.template.loader import get_template
 from django.utils.translation import ugettext_lazy as _
 
 from pretix.base.signals import register_payment_providers
-from pretix.control.signals import nav_event
+from pretix.control.signals import html_head, nav_event
 
 from .payment import BankTransfer
 
@@ -29,3 +31,14 @@ def control_nav_import(sender, request=None, **kwargs):
             'icon': 'upload',
         }
     ]
+
+
+@receiver(html_head, dispatch_uid="banktransfer_html_head")
+def html_head_presale(sender, request=None, **kwargs):
+    url = resolve(request.path_info)
+    if url.namespace == 'plugins:banktransfer':
+        template = get_template('pretixplugins/banktransfer/control_head.html')
+        ctx = Context({})
+        return template.render(ctx)
+    else:
+        return ""
diff --git a/src/pretix/plugins/banktransfer/static/pretixplugins/banktransfer/ui.css b/src/pretix/plugins/banktransfer/static/pretixplugins/banktransfer/ui.css
new file mode 100644
index 0000000000..a7edbfb206
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/static/pretixplugins/banktransfer/ui.css
@@ -0,0 +1,10 @@
+table.transaction-list td.actions {
+    max-width: 100px;
+}
+table.transaction-list td.actions .input-group {
+    display: inline-block;
+    width: 110px;
+}
+table.transaction-list td.actions .input-group button {
+    line-height: 1.43;
+}
diff --git a/src/pretix/plugins/banktransfer/static/pretixplugins/banktransfer/ui.js b/src/pretix/plugins/banktransfer/static/pretixplugins/banktransfer/ui.js
new file mode 100644
index 0000000000..5326552953
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/static/pretixplugins/banktransfer/ui.js
@@ -0,0 +1,132 @@
+/*global $, gettext*/
+var bankimport_transactionlist = {
+
+    _btn_click: function (e) {
+        console.log(e.delegateTarget);
+        var trans_id = parseInt($(e.delegateTarget).attr("name").split("_")[1]);
+        var value = $(e.delegateTarget).val();
+        if (value === "discard") {
+            bankimport_transactionlist.discard(trans_id);
+        } else if (value === "accept") {
+            bankimport_transactionlist.accept(trans_id);
+        } else if (value === "retry") {
+            bankimport_transactionlist.retry(trans_id);
+        } else if (value === "assign") {
+            bankimport_transactionlist.assign(trans_id);
+        }
+        return false;
+    },
+
+    _action: function (id, action, success) {
+        $("tr[data-id=" + id + "] button").prop("disabled", true);
+        var data = {
+            "csrfmiddlewaretoken": $("[name=csrfmiddlewaretoken]").val()
+        };
+        data["action_" + id] = action;
+        $.ajax({
+            "method": "POST",
+            "url": $(".transaction-list").attr("data-url"),
+            "data": data,
+            "dataType": "json",
+            "success": function (data) {
+                if (data.status == "ok") {
+                    $("tr[data-id=" + id + "]").removeClass("has-error");
+                    success();
+                } else {
+                    $("tr[data-id=" + id + "] button").prop("disabled", false);
+                    $("tr[data-id=" + id + "] .help-block").remove();
+                    $("tr[data-id=" + id + "]").addClass("has-error");
+                    $("<p>").addClass("help-block").text(data.message).appendTo($("tr[data-id=" + id + "] td.actions"));
+                }
+            }
+        });
+    },
+
+    discard: function (id) {
+        bankimport_transactionlist._action(id, "discard", function () {
+            $("tr[data-id=" + id + "] td").remove();
+        });
+    },
+
+    retry: function (id) {
+        bankimport_transactionlist._action(id, "retry", function () {
+            $("tr[data-id=" + id + "] td.actions").html('').text(gettext("Marked as paid"));
+        });
+    },
+
+    accept: function (id) {
+        bankimport_transactionlist._action(id, "accept", function () {
+            $("tr[data-id=" + id + "] td.actions").html('').text(gettext("Marked as paid"));
+        });
+    },
+
+    assign: function (id) {
+        bankimport_transactionlist._action(id, "assign:" + $("tr[data-id=" + id + "] input.form-control:not(.tt-hint)").val(), function () {
+            $("tr[data-id=" + id + "] td.actions").html('').text(gettext("Marked as paid"));
+        });
+    },
+
+    typeahead_source: function () {
+        return new Bloodhound({
+            datumTokenizer: Bloodhound.tokenizers.obj.whitespace('value'),
+            queryTokenizer: Bloodhound.tokenizers.whitespace,
+            remote: {
+                url: $(".transaction-list").attr("data-url"),
+                prepare: function (query, settings) {
+                    settings.url = settings.url + '?query=' + encodeURIComponent(query);
+                    return settings;
+                },
+                transform: function (object) {
+                    var results = object.results;
+                    var suggs = [];
+                    var reslen = results.length;
+                    for (var i = 0; i < reslen; i++) {
+                        suggs.push(results[i]);
+                    }
+                    return suggs;
+                }
+            }
+        });
+    },
+
+    init: function () {
+        if ($(".transaction-list").length) {
+            $(".transaction-list button").click(bankimport_transactionlist._btn_click);
+            $(".transaction-list .form-control").typeahead(null, {
+                minLength: 2,
+                name: 'order-dataset',
+                source: bankimport_transactionlist.typeahead_source(),
+                display: function (obj) {
+                    return obj.code;
+                },
+                templates: {
+                    suggestion: function (obj) {
+                        return '<div>' + obj.code + ' (' + obj.total + ', ' + obj.status + ')</div>';
+                    }
+                }
+            }).keypress(function (e) {
+                if (e.keyCode === 13) {
+                    $(this).parent().parent().find("button[value=assign]").click();
+                }
+            });
+        }
+
+        if ($("[data-job-waiting]").length) {
+            window.setInterval(bankimport_transactionlist.check_state, 750);
+        }
+    },
+
+    check_state: function () {
+        $.getJSON(location.pathname + '?ajax=1', function (data) {
+            if (data.state == 'running' || data.state == 'pending') {
+                window.setInterval(check_state, 750);
+            } else {
+                location.reload();
+            }
+        });
+    }
+};
+
+$(function () {
+    bankimport_transactionlist.init();
+});
diff --git a/src/pretix/plugins/banktransfer/tasks.py b/src/pretix/plugins/banktransfer/tasks.py
new file mode 100644
index 0000000000..96e530255c
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/tasks.py
@@ -0,0 +1,130 @@
+import json
+import logging
+import re
+from decimal import Decimal
+
+import dateutil.parser
+from django.conf import settings
+from django.db import transaction
+from django.utils.translation import ugettext_noop
+
+from pretix.base.i18n import language
+from pretix.base.models import Event, Order, Quota
+from pretix.base.services.mail import SendMailException
+from pretix.base.services.orders import mark_order_paid
+
+from .models import BankImportJob, BankTransaction
+
+logger = logging.getLogger(__name__)
+
+
+def _handle_transaction(event: Event, trans: BankTransaction, code: str):
+    try:
+        trans.order = event.orders.get(code=code)
+    except Order.DoesNotExist:
+        normalized_code = Order.normalize_code(code)
+        try:
+            trans.order = event.orders.get(code=normalized_code)
+        except Order.DoesNotExist:
+            trans.state = BankTransaction.STATE_NOMATCH
+            trans.save()
+            return
+
+    if trans.order.status == Order.STATUS_PAID:
+        trans.state = BankTransaction.STATE_DUPLICATE
+    elif trans.order.status == Order.STATUS_REFUNDED:
+        trans.state = BankTransaction.STATE_ERROR
+        trans.message = ugettext_noop('The order has already been refunded.')
+    elif trans.order.status == Order.STATUS_CANCELLED:
+        trans.state = BankTransaction.STATE_ERROR
+        trans.message = ugettext_noop('The order has already been cancelled.')
+    elif trans.amount != trans.order.total:
+        trans.state = BankTransaction.STATE_INVALID
+        trans.message = ugettext_noop('The transaction amount is incorrect.')
+    else:
+        try:
+            mark_order_paid(trans.order, provider='banktransfer', info=json.dumps({
+                'reference': trans.reference,
+                'date': trans.date.isoformat(),
+                'payer': trans.payer,
+                'trans_id': trans.pk
+            }))
+        except Quota.QuotaExceededException as e:
+            trans.state = BankTransaction.STATE_ERROR
+            trans.message = str(e)
+        except SendMailException:
+            trans.state = BankTransaction.STATE_ERROR
+            trans.message = ugettext_noop('Problem sending email.')
+        else:
+            trans.state = BankTransaction.STATE_VALID
+    trans.save()
+
+
+def _get_unknown_transactions(event: Event, job: BankImportJob, data: list):
+    amount_pattern = re.compile("[^0-9.-]")
+    known_checksums = set(t['checksum'] for t in BankTransaction.objects.filter(event=event).values('checksum'))
+
+    transactions = []
+    for row in data:
+        amount = amount_pattern.sub("", row['amount'].replace(",", "."))
+        try:
+            amount = Decimal(amount)
+        except:
+            logger.exception('Could not parse amount of transaction: {}'.format(amount))
+            amount = Decimal("0.00")
+
+        date = dateutil.parser.parse(row['date'])
+        trans = BankTransaction(event=event, import_job=job,
+                                payer=row['payer'],
+                                reference=row['reference'],
+                                amount=amount,
+                                date=date)
+        trans.checksum = trans.calculate_checksum()
+        if trans.checksum not in known_checksums:
+            trans.state = BankTransaction.STATE_UNCHECKED
+            trans.save()
+            transactions.append(trans)
+            known_checksums.add(trans.checksum)
+
+    return transactions
+
+
+def process_banktransfers(event: int, job: int, data: list) -> None:
+    with language("en"):  # We'll translate error messages at display time
+        event = Event.objects.get(pk=event)
+        job = BankImportJob.objects.get(pk=job)
+        job.state = BankImportJob.STATE_RUNNING
+        job.save()
+
+        try:
+            transactions = _get_unknown_transactions(event, job, data)
+
+            code_len = settings.ENTROPY['order_code']
+            pattern = re.compile(event.slug.upper() + "[ -_]*([A-Z0-9]{%s})" % code_len)
+
+            for trans in transactions:
+                match = pattern.search(trans.reference.upper())
+
+                if match:
+                    code = match.group(1)
+                    with transaction.atomic():
+                        _handle_transaction(event, trans, code)
+                else:
+                    trans.state = BankTransaction.STATE_NOMATCH
+                    trans.save()
+        except Exception as e:
+            job.state = BankImportJob.STATE_ERROR
+            job.save()
+            raise e
+        else:
+            job.state = BankImportJob.STATE_COMPLETED
+            job.save()
+
+
+if settings.HAS_CELERY:
+    from pretix.celery import app
+
+    process_task = app.task(process_banktransfers)
+
+    def process_banktransfers(*args, **kwargs):
+        process_task.apply_async(args=args, kwargs=kwargs)
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/control_head.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/control_head.html
new file mode 100644
index 0000000000..2c7c881271
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/control_head.html
@@ -0,0 +1,6 @@
+{% load staticfiles %}
+{% load compress %}
+
+{% compress css %}
+    <link type="text/css" rel="stylesheet" href="{% static "pretixplugins/banktransfer/ui.css" %}">
+{% endcompress %}
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/hbci_log.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/hbci_log.html
deleted file mode 100644
index a4311e7c7e..0000000000
--- a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/hbci_log.html
+++ /dev/null
@@ -1,9 +0,0 @@
-{% extends "pretixplugins/banktransfer/import_base.html" %}
-{% load i18n %}
-{% load bootstrap3 %}
-{% block inner %}
-    <div class="alert alert-danger">
-        {% trans "An error occured during the HBCI transaction." %}
-    </div>
-    <pre>{{ log }}</pre>
-{% endblock %}
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_base.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_base.html
index c0e6a5b42e..b391089e7d 100644
--- a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_base.html
+++ b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_base.html
@@ -1,8 +1,10 @@
 {% extends "pretixcontrol/event/base.html" %}
 {% load i18n %}
+{% load static %}
 {% block title %}{% trans "Import bank data" %}{% endblock %}
 {% block content %}
     <h1>{% trans "Import bank data" %}</h1>
     {% block inner %}
     {% endblock %}
+    <script type="application/javascript" src="{% static "pretixplugins/banktransfer/ui.js" %}"></script>
 {% endblock %}
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_confirm.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_confirm.html
deleted file mode 100644
index 3bf63b9fd2..0000000000
--- a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_confirm.html
+++ /dev/null
@@ -1,54 +0,0 @@
-{% extends "pretixplugins/banktransfer/import_base.html" %}
-{% load i18n %}
-{% block inner %}
-    <p>{% blocktrans trimmed %}
-        We detected the following payments. Please review them and click the 'Confirm' button below.
-    {% endblocktrans %}</p>
-    <form method="post" action="">
-        {% csrf_token %}
-        <table class="table table-condensed">
-            <thead>
-                <tr>
-                    <th></th>
-                    <th>{% trans "Date" %}</th>
-                    <th>{% trans "Reference" %}</th>
-                    <th>{% trans "Amount" %}</th>
-                    <th>{% trans "Payer" %}</th>
-                    <th>{% trans "Order" %}</th>
-                    <th>{% trans "Status" %}</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for row in rows %}
-                    <tr class="{{ row.class }}">
-                        <th>{% if row.ok %}
-                            <input type="checkbox" name="mark_paid" value="{{ row.order.code }}"
-                                checked="checked" />
-                            <input type="hidden" name="date_{{ row.order.code }}" value="{{ row.date }}" />
-                            <input type="hidden" name="payer_{{ row.order.code }}" value="{{ row.payer }}" />
-                            <input type="hidden" name="reference_{{ row.order.code }}" value="{{ row.reference }}" />
-                        {% endif %}</th>
-                        <td>{{ row.date }}</td>
-                        <td>{{ row.reference }}</td>
-                        <td>{{ row.amount }}</td>
-                        <td>{{ row.payer }}</td>
-                        <td>{% if row.order %}
-                            <a href="{% url "control:event.order" event=request.event.slug organizer=request.event.organizer.slug code=row.order.code %}"
-                                    target="_blank">
-                                {{ row.order.code }}
-                            </a>
-                            {% endif %}
-                        </td>
-                        <td>{{ row.message }}</td>
-                    </tr>
-                {% endfor %}
-            </tbody>
-            <input type="hidden" name="confirm" value="true" />
-
-        </table>
-        <button class="btn btn-primary btn-lg pull-right helper-space-below" type="submit">
-            <span class="icon icon-upload"></span> {% trans "Confirm" %}
-        </button>
-        <div class="clearfix"></div>
-    </form>
-{% endblock %}
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_form.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_form.html
index 67561965d0..4575160f53 100644
--- a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_form.html
+++ b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/import_form.html
@@ -16,7 +16,7 @@
             <form action="" method="post" enctype="multipart/form-data" class="form-inline">
                 {% csrf_token %}
                 <div class="form-group">
-                    <label for="file">{% trans "Import file" %}: </label> <input id="file" type="file" name="file" />
+                    <label for="file">{% trans "Import file" %}: </label> <input id="file" type="file" name="file"/>
                 </div>
                 <div class="clearfix"></div>
                 <button class="btn btn-primary pull-right" type="submit">
@@ -25,38 +25,32 @@
             </form>
         </div>
     </div>
-    <!--
-    <div class="panel panel-default">
-        <div class="panel-heading">
-            <h3 class="panel-title">{% trans "HBCI import" %}</h3>
-        </div>
-        <div class="panel-body">
-            {% if hbci_available %}
-            <form action="" method="post" class="form-horizontal">
-                {% csrf_token %}
-                {% bootstrap_form hbci_form layout='horizontal' %}
-                <div class="clearfix"></div>
+    {% if transactions_unhandled|length > 0 %}
+        <div class="panel panel-default">
+            <div class="panel-heading">
+                <h3 class="panel-title">{% trans "Unresolved transactions" %}</h3>
+            </div>
+            <div class="panel-body">
                 <p>
-                    {% trans "Please note that this step might take a few minutes." %}
+                    <form class="form-inline helper-display-inline" action="" method="get">
+                        <input type="text" name="search" class="form-control" placeholder="{% trans "Search" %}" value="{{ request.GET.search }}">
+                    </form>
+                    <button class="btn btn-primary" type="submit">{% trans "Filter" %}</button>
+                    {% if not request.GET.search %}
+                        <form action="" method="post" class="helper-display-inline pull-right">
+                            {% csrf_token %}
+                            <button class="btn btn-danger" type="submit" name="discard" value="all">
+                                <span class="fa fa-trash"></span>
+                                {% trans "Discard all" %}
+                            </button>
+                        </form>
+                    {% endif %}
                 </p>
-                <div class="alert alert-warning">
-                    {% blocktrans trimmed %}
-                        Your HBCI PIN code is only stored on the server for a very short time and
-                        immediately deleted after the communication with the bank is over. However,
-                        we <strong>strongly advise</strong> you to ask your bank for HBCI credentials
-                        that have <strong>read-only</strong> access to your bank account.
-                    {% endblocktrans %}
-                </div>
-                <button class="btn btn-primary pull-right" type="submit">
-                    <span class="icon icon-upload"></span> {% trans "Import" %}
-                </button>
-            </form>
-            {% else %}
-                <div class="alert alert-error">
-                    {% trans "HBCI is only available with aqbanking-cli and aqhbci-tool4 installed." %}
-                </div>
-            {% endif %}
+
+                {% include "pretixcontrol/pagination.html" %}
+                {% include "pretixplugins/banktransfer/transaction_list.html" with list=transactions_unhandled %}
+                {% include "pretixcontrol/pagination.html" %}
+            </div>
         </div>
-    </div>
-    -->
+    {% endif %}
 {% endblock %}
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/job_detail.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/job_detail.html
new file mode 100644
index 0000000000..03916fe2e4
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/job_detail.html
@@ -0,0 +1,47 @@
+{% extends "pretixplugins/banktransfer/import_base.html" %}
+{% load i18n %}
+{% block inner %}
+    <h2>{% trans "Import result" %}</h2>
+    {% if job.state == "running" or job.state == "pending" %}
+        <div class="empty-collection" data-job-waiting>
+            <p>
+                <span class="fa big-grey-icon fa-cog fa big-rotating-icon"></span>
+            </p>
+            <p>
+                {% trans "The result of your import is in progress. Please be patient while we process the data..." %}
+            </p>
+        </div>
+    {% else %}
+        {% if job.state == "error" %}
+            <div class="alert alert-danger">
+                {% trans "An internal error occured during processing your data." %}
+            </div>
+        {% elif transactions_ignored == 0 and transactions_invalid == 0 and transactions_valid == 0 %}
+            <div class="alert alert-info">
+                {% trans "Your import did not contain any transactions that you did not import before." %}
+            </div>
+        {% endif %}
+
+        <table class="table table-condensed">
+            <tr class="success">
+                <td>{{ transactions_valid }}</td>
+                <td>{% trans "Orders marked as paid" %}</td>
+            </tr>
+            <tr class="warning">
+                <td>{{ transactions_invalid }}</td>
+                <td>{% trans "Invalid payments" %}</td>
+            </tr>
+            <tr class="info">
+                <td>{{ transactions_ignored }}</td>
+                <td>{% trans "Ignored payments" %}</td>
+            </tr>
+        </table>
+        {% if transactions_ignored or transactions_invalid %}
+            <a href="{% url "plugins:banktransfer:import" event=request.event.slug organizer=request.organizer.slug %}"
+                class="btn btn-primary">
+                {% trans "Review invalid and ignored payments" %} &raquo;
+            </a>
+        {% endif %}
+
+    {% endif %}
+{% endblock %}
diff --git a/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/transaction_list.html b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/transaction_list.html
new file mode 100644
index 0000000000..b86a1ac041
--- /dev/null
+++ b/src/pretix/plugins/banktransfer/templates/pretixplugins/banktransfer/transaction_list.html
@@ -0,0 +1,86 @@
+{% load i18n %}
+{% load staticfiles %}
+<div class="table-responsive">
+    {% csrf_token %}
+    <table class="table table-condensed transaction-list" data-url="{% url "plugins:banktransfer:import.action" event=request.event.slug organizer=request.event.organizer.slug %}">
+        <thead>
+        <tr>
+            <th></th>
+            <th>{% trans "Date" %}</th>
+            <th>{% trans "Payer and reference" %}</th>
+            <th>{% trans "Amount" %}</th>
+            <th>{% trans "Result" %}</th>
+            <th>{% trans "Order" %}</th>
+        </tr>
+        </thead>
+        <tbody>
+        {% for trans in list %}
+            <tr data-id="{{ trans.id }}">
+                <td class="actions">
+                    {% if trans.order and trans.state == 'invalid' %}
+                        <div class="btn-group" role="group">
+                            <button type="button" class="btn btn-default" name="action_{{ trans.id }}" value="accept"
+                                data-toggle="tooltip" title="{% trans "Accept anyway" %}" data-placement="right">
+                                <span class="fa fa-check"></span>
+                            </button>
+                            <button type="button" class="btn btn-default" name="action_{{ trans.id }}" value="discard"
+                                data-toggle="tooltip" title="{% trans "Discard" %}">
+                                <span class="fa fa-trash"></span>
+                            </button>
+                        </div>
+                    {% elif trans.state == 'nomatch' %}
+                        <input type="text" class="form-control" placeholder="{% trans "Order code" %}">
+                        <div class="btn-group" role="group">
+                            <button class="btn btn-default" type="button" name="action_{{ trans.id }}"
+                                    value="assign" data-toggle="tooltip" title="{% trans "Assign to order" %}" data-placement="right">
+                                <span class="fa fa-check"></span>
+                            </button>
+                            <button type="button" class="btn btn-default" name="action_{{ trans.id }}" value="discard"
+                                data-toggle="tooltip" title="{% trans "Discard" %}">
+                                <span class="fa fa-trash"></span>
+                            </button>
+                        </div>
+                    {% elif trans.state == 'error' %}
+                        <div class="btn-group" role="group">
+                            <button type="button" class="btn btn-default" name="action_{{ trans.id }}" value="retry"
+                                data-toggle="tooltip" title="{% trans "Retry" %}" data-placement="right">
+                                <span class="fa fa-refresh"></span>
+                            </button>
+                            <button type="button" class="btn btn-default" name="action_{{ trans.id }}" value="discard"
+                                data-toggle="tooltip" title="{% trans "Discard" %}">
+                                <span class="fa fa-trash"></span>
+                            </button>
+                        </div>
+                    {% endif %}
+                </td>
+                <td>{{ trans.date|date:"SHORT_DATE_FORMAT" }}</td>
+                <td>{{ trans.payer }}<br/>{{ trans.reference }}</td>
+                <td>{{ trans.amount|floatformat:2 }}</td>
+                <td>
+                    {% if trans.message %}
+                        {% trans trans.message %}
+                    {% elif trans.state == 'nomatch' %}
+                        {% trans "No order code detected" %}
+                    {% elif trans.state == 'invalid' %}
+                        {% trans "Invalid for this order" %}
+                    {% elif trans.state == 'error' %}
+                        {% trans "Error while processing" %}
+                    {% elif trans.state == 'valid' %}
+                        {% trans "The order is already marked as paid" %}
+                    {% elif trans.state == 'already' %}
+                        {% trans "Order already paid" %}
+                    {% endif %}
+                </td>
+                <td>
+                    {% if trans.order %}
+                        <a href="{% url "control:event.order" event=request.event.slug organizer=request.event.organizer.slug code=trans.order.code %}"
+                            data-toggle="tooltip" title="{{ trans.order.total|floatformat:2 }} {{ request.event.currency }}">
+                            {{ trans.order.code }}
+                        </a>
+                    {% endif %}
+                </td>
+            </tr>
+        {% endfor %}
+        </tbody>
+    </table>
+</div>
diff --git a/src/pretix/plugins/banktransfer/urls.py b/src/pretix/plugins/banktransfer/urls.py
index 5b8ecf9713..3bc5b580c7 100644
--- a/src/pretix/plugins/banktransfer/urls.py
+++ b/src/pretix/plugins/banktransfer/urls.py
@@ -5,4 +5,8 @@ from . import views
 urlpatterns = [
     url(r'^control/event/(?P<organizer>[^/]+)/(?P<event>[^/]+)/banktransfer/import/', views.ImportView.as_view(),
         name='import'),
+    url(r'^control/event/(?P<organizer>[^/]+)/(?P<event>[^/]+)/banktransfer/job/(?P<job>\d+)/',
+        views.JobDetailView.as_view(), name='import.job'),
+    url(r'^control/event/(?P<organizer>[^/]+)/(?P<event>[^/]+)/banktransfer/action/',
+        views.ActionView.as_view(), name='import.action'),
 ]
diff --git a/src/pretix/plugins/banktransfer/views.py b/src/pretix/plugins/banktransfer/views.py
index ecca17cd64..f41fdbb9e2 100644
--- a/src/pretix/plugins/banktransfer/views.py
+++ b/src/pretix/plugins/banktransfer/views.py
@@ -1,18 +1,16 @@
 import csv
 import json
 import logging
-import re
-import shutil
-from decimal import Decimal
+from locale import format as lformat
 
-from django import forms
-from django.conf import settings
 from django.contrib import messages
-from django.shortcuts import redirect, render
+from django.core.urlresolvers import reverse
+from django.db.models import Q
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404, redirect, render
 from django.utils.functional import cached_property
-from django.utils.timezone import now
-from django.utils.translation import ugettext_lazy as _
-from django.views.generic import TemplateView
+from django.utils.translation import ugettext as _
+from django.views.generic import DetailView, ListView, TemplateView, View
 
 from pretix.base.models import Order, Quota
 from pretix.base.services.mail import SendMailException
@@ -20,15 +18,204 @@ from pretix.base.services.orders import mark_order_paid
 from pretix.base.settings import SettingsSandbox
 from pretix.control.permissions import EventPermissionRequiredMixin
 from pretix.plugins.banktransfer import csvimport, mt940import
+from pretix.plugins.banktransfer.models import BankImportJob, BankTransaction
+from pretix.plugins.banktransfer.tasks import process_banktransfers
 
 logger = logging.getLogger('pretix.plugins.banktransfer')
 
 
-class ImportView(EventPermissionRequiredMixin, TemplateView):
-    template_name = 'pretixplugins/banktransfer/import_form.html'
+class ActionView(EventPermissionRequiredMixin, View):
     permission = 'can_change_orders'
 
+    def _discard(self, trans):
+        trans.state = BankTransaction.STATE_DISCARDED
+        trans.shred_private_data()
+        trans.save()
+        return JsonResponse({
+            'status': 'ok'
+        })
+
+    def _retry(self, trans):
+        if trans.amount != trans.order.total:
+            return JsonResponse({
+                'status': 'error',
+                'message': _('The transaction amount is incorrect.')
+            })
+        return self._accept_ignore_amount(trans)
+
+    def _accept_ignore_amount(self, trans):
+        if trans.order.status == Order.STATUS_PAID:
+            return JsonResponse({
+                'status': 'error',
+                'message': _('The order is already marked as paid.')
+            })
+        elif trans.order.status == Order.STATUS_REFUNDED:
+            return JsonResponse({
+                'status': 'error',
+                'message': _('The order has already been refunded.')
+            })
+        elif trans.order.status == Order.STATUS_CANCELLED:
+            return JsonResponse({
+                'status': 'error',
+                'message': _('The order has already been cancelled.')
+            })
+
+        try:
+            mark_order_paid(trans.order, provider='banktransfer', info=json.dumps({
+                'reference': trans.reference,
+                'date': trans.date.isoformat(),
+                'payer': trans.payer,
+                'trans_id': trans.pk
+            }))
+            trans.state = BankTransaction.STATE_VALID
+            trans.save()
+        except Quota.QuotaExceededException as e:
+            return JsonResponse({
+                'status': 'error',
+                'message': str(e)
+            })
+        except SendMailException:
+            return JsonResponse({
+                'status': 'error',
+                'message': _('Problem sending email.')
+            })
+        else:
+            trans.state = BankTransaction.STATE_VALID
+            trans.save()
+            return JsonResponse({
+                'status': 'ok'
+            })
+
+    def _assign(self, trans, code):
+        try:
+            trans.order = self.request.event.orders.get(code=code)
+        except Order.DoesNotExist:
+            return JsonResponse({
+                'status': 'error',
+                'message': _('Unknown order code.')
+            })
+        else:
+            return self._retry(trans)
+
+    def post(self, request, *args, **kwargs):
+        for k, v in request.POST.items():
+            if not k.startswith('action_'):
+                continue
+            trans = get_object_or_404(BankTransaction, id=k.split('_')[1], event=self.request.event)
+
+            if v == 'discard' and trans.state in (BankTransaction.STATE_INVALID, BankTransaction.STATE_ERROR,
+                                                  BankTransaction.STATE_NOMATCH):
+                return self._discard(trans)
+
+            elif v == 'accept' and trans.state == BankTransaction.STATE_INVALID:
+                # Accept anyway even with wrong amount
+                return self._accept_ignore_amount(trans)
+
+            elif v.startswith('assign:') and trans.state == BankTransaction.STATE_NOMATCH:
+                return self._assign(trans, v[7:])
+
+            elif v == 'retry' and trans.state == BankTransaction.STATE_ERROR:
+                return self._retry(trans)
+
+            return JsonResponse({
+                'status': 'error',
+                'message': 'Unknown action'
+            })
+
+    def get(self, request, *args, **kwargs):
+        query = request.GET.get('query', '')
+        if len(query) < 2:
+            return JsonResponse({'results': []})
+
+        qs = self.request.event.orders.filter(Q(code__icontains=query) | Q(code__icontains=Order.normalize_code(query)))
+        return JsonResponse({
+            'results': [
+                {
+                    'code': o.code,
+                    'status': o.get_status_display(),
+                    'total': lformat("%.2f", o.total) + ' ' + self.request.event.currency
+                } for o in qs
+            ]
+        })
+
+
+class JobDetailView(EventPermissionRequiredMixin, DetailView):
+    template_name = 'pretixplugins/banktransfer/job_detail.html'
+    permission = 'can_change_orders'
+    context_objectname = 'job'
+
+    def redirect_form(self):
+        return redirect(reverse('plugins:banktransfer:import', kwargs={
+            'event': self.request.event.slug,
+            'organizer': self.request.event.organizer.slug,
+        }))
+
+    def redirect_back(self):
+        return redirect(reverse('plugins:banktransfer:import.job', kwargs={
+            'event': self.request.event.slug,
+            'organizer': self.request.event.organizer.slug,
+            'job': self.kwargs['job']
+        }))
+
+    def get_object(self, queryset=None):
+        return get_object_or_404(BankImportJob, id=self.kwargs['job'], event=self.request.event)
+
+    def get(self, request, *args, **kwargs):
+        if 'ajax' in request.GET:
+            self.object = self.get_object()
+            return JsonResponse({
+                'state': self.object.state
+            })
+
+        return super().get(request, *args, **kwargs)
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data()
+
+        qs = self.object.transactions.select_related('order')
+
+        ctx['transactions_valid'] = qs.filter(state=BankTransaction.STATE_VALID).count()
+        ctx['transactions_invalid'] = qs.filter(state__in=[
+            BankTransaction.STATE_INVALID, BankTransaction.STATE_ERROR
+        ]).count()
+        ctx['transactions_ignored'] = qs.filter(state__in=[
+            BankTransaction.STATE_DUPLICATE, BankTransaction.STATE_NOMATCH
+        ]).count()
+        ctx['job'] = self.object
+
+        return ctx
+
+
+class ImportView(EventPermissionRequiredMixin, ListView):
+    template_name = 'pretixplugins/banktransfer/import_form.html'
+    permission = 'can_change_orders'
+    context_object_name = 'transactions_unhandled'
+    paginate_by = 30
+
+    def get_queryset(self):
+        qs = BankTransaction.objects.filter(
+            event=self.request.event
+        ).select_related('order').filter(state__in=[
+            BankTransaction.STATE_INVALID, BankTransaction.STATE_ERROR,
+            BankTransaction.STATE_DUPLICATE, BankTransaction.STATE_NOMATCH
+        ])
+        if 'search' in self.request.GET:
+            q = self.request.GET.get('search')
+            qs = qs.filter(
+                Q(payer__icontains=q) | Q(reference__icontains=q)
+            )
+
+        return qs
+
+    def discard_all(self):
+        self.get_queryset().update(payer='', reference='', state=BankTransaction.STATE_DISCARDED)
+        messages.success(self.request, _('All unresolved transactions have been discarded.'))
+
     def post(self, *args, **kwargs):
+        if self.request.POST.get('discard', '') == 'all':
+            self.discard_all()
+            return self.redirect_back()
+
         if ('file' in self.request.FILES and 'csv' in self.request.FILES.get('file').name.lower()) \
                 or 'amount' in self.request.POST:
             # Process CSV
@@ -37,35 +224,6 @@ class ImportView(EventPermissionRequiredMixin, TemplateView):
         if 'file' in self.request.FILES and 'txt' in self.request.FILES.get('file').name.lower():
             return self.process_mt940()
 
-        if 'confirm' in self.request.POST:
-            orders = Order.objects.filter(event=self.request.event,
-                                          code__in=self.request.POST.getlist('mark_paid'))
-            some_failed = False
-            mail_failures = False
-            for order in orders:
-                try:
-                    mark_order_paid(order, provider='banktransfer', info=json.dumps({
-                        'reference': self.request.POST.get('reference_%s' % order.code),
-                        'date': self.request.POST.get('date_%s' % order.code),
-                        'payer': self.request.POST.get('payer_%s' % order.code),
-                        'import': now().isoformat(),
-                    }))
-                except Quota.QuotaExceededException:
-                    some_failed = True
-                except SendMailException:
-                    mail_failures = True
-
-            if some_failed:
-                messages.warning(self.request, _('Not all of the selected orders could be marked as '
-                                                 'paid as some of them have expired and the selected '
-                                                 'items are sold out.'))
-            else:
-                messages.success(self.request, _('The selected orders have been marked as paid.'))
-                # TODO: Display a list of them!
-            if mail_failures:
-                messages.warning(self.request, _('Some confirmation mails could not be sent.'))
-            return self.redirect_back()
-
         messages.error(self.request, _('We were unable to detect the file type of this import. Please '
                                        'contact support for help.'))
         return self.redirect_back()
@@ -76,7 +234,7 @@ class ImportView(EventPermissionRequiredMixin, TemplateView):
 
     def process_mt940(self):
         try:
-            return self.confirm_view(mt940import.parse(self.request.FILES.get('file')))
+            return self.start_processing(mt940import.parse(self.request.FILES.get('file')))
         except:
             logger.exception('Failed to import MT940 file')
             messages.error(self.request, _('We were unable to process your input.'))
@@ -102,7 +260,7 @@ class ImportView(EventPermissionRequiredMixin, TemplateView):
             except csvimport.HintMismatchError:  # TODO: narrow down
                 logger.exception('Import using stored hint failed')
             else:
-                return self.confirm_view(parsed)
+                return self.start_processing(parsed)
 
         return self.assign_view(data)
 
@@ -113,7 +271,7 @@ class ImportView(EventPermissionRequiredMixin, TemplateView):
                 [
                     self.request.POST.get('col[%d][%d]' % (i, j))
                     for j in range(int(self.request.POST.get('cols')))
-                ]
+                    ]
             )
         if 'reference' not in self.request.POST:
             messages.error(self.request, _('You need to select the column containing the payment reference.'))
@@ -131,7 +289,7 @@ class ImportView(EventPermissionRequiredMixin, TemplateView):
             pass
         else:
             parsed = csvimport.parse(data, hint)
-            return self.confirm_view(parsed)
+            return self.start_processing(parsed)
 
     def process_csv(self):
         if 'file' in self.request.FILES:
@@ -140,81 +298,22 @@ class ImportView(EventPermissionRequiredMixin, TemplateView):
             return self.process_csv_hint()
         return super().get(self.request)
 
-    def confirm_view(self, parsed):
-        parsed = self.annotate_data(parsed)
-        return render(self.request, 'pretixplugins/banktransfer/import_confirm.html', {
-            'rows': parsed
-        })
-
     def assign_view(self, parsed):
         return render(self.request, 'pretixplugins/banktransfer/import_assign.html', {
             'rows': parsed
         })
 
     def redirect_back(self):
-        return redirect('plugins:banktransfer:import',
-                        event=self.request.event.slug,
-                        organizer=self.request.event.organizer.slug)
+        return redirect(reverse('plugins:banktransfer:import', kwargs={
+            'event': self.request.event.slug,
+            'organizer': self.request.event.organizer.slug,
+        }))
 
-    def annotate_data(self, data):
-        code_len = settings.ENTROPY['order_code']
-        pattern = re.compile(self.request.event.slug.upper() + "[ -_]*([A-Z0-9]{%s})" % code_len)
-        amount_pattern = re.compile("[^0-9.-]")
-        order_codes = []
-        for row in data:
-            row['ok'] = False
-            try:
-                amount = Decimal(amount_pattern.sub("", row['amount'].replace(",", ".")))
-                row['amount'] = str(amount)
-            except:
-                logger.exception('Could not parse amount of transaction')
-                amount = 0
-            match = pattern.search(row['reference'].upper())
-            if not match:
-                row['class'] = 'warning' if amount > 0 else ''
-                row['message'] = _('No order code detected')
-                continue
-
-            code = match.group(1)
-            row['code'] = code
-            order_codes.append(code)
-            normalized_code = Order.normalize_code(code)
-            if normalized_code != code:
-                order_codes.append(normalized_code)
-
-        orders = {}
-        # Perform query in bulks because of SQLite's default of SQLITE_MAX_VARIABLE_NUMBER = 999
-        for i in range(0, len(order_codes), 500):
-            orders.update({
-                o.code: o for o in self.request.event.orders.filter(code__in=order_codes[i:500])
-            })
-
-        for row in data:
-            if 'code' not in row:
-                continue
-            normalized_code = Order.normalize_code(row['code'])
-            if row['code'] in orders or normalized_code in orders:
-                order = orders[row['code']] if row['code'] in orders else orders[normalized_code]
-                row['order'] = order
-                if order.status == Order.STATUS_PENDING:
-                    amount = Decimal(row['amount'])
-                    if amount != order.total:
-                        row['class'] = 'danger'
-                        row['message'] = _('Found wrong amount. Expected: %s' % str(order.total))
-                    else:
-                        row['class'] = 'success'
-                        row['message'] = _('Valid payment')
-                        row['ok'] = True
-                elif order.status == Order.STATUS_CANCELLED:
-                    row['class'] = 'danger'
-                    row['message'] = _('Order has been cancelled')
-                elif order.status == Order.STATUS_PAID:
-                    row['class'] = ''
-                    row['message'] = _('Order already has been paid')
-                elif order.status == Order.STATUS_REFUNDED:
-                    row['class'] = 'warning'
-                    row['message'] = _('Order has been refunded')
-            else:
-                row['class'] = 'danger'
-                row['message'] = _('Unknown order code detected')
-        return data
+    def start_processing(self, parsed):
+        job = BankImportJob.objects.create(event=self.request.event)
+        process_banktransfers(event=self.request.event.pk, job=job.pk, data=parsed)
+        return redirect(reverse('plugins:banktransfer:import.job', kwargs={
+            'event': self.request.event.slug,
+            'organizer': self.request.event.organizer.slug,
+            'job': job.pk
+        }))
diff --git a/src/pretix/presale/views/async.py b/src/pretix/presale/views/async.py
index b74125170e..359678a338 100644
--- a/src/pretix/presale/views/async.py
+++ b/src/pretix/presale/views/async.py
@@ -1,134 +1,3 @@
-import logging
+from pretix.base.views.async import *  # noqa
 
-from django.conf import settings
-from django.contrib import messages
-from django.http import JsonResponse
-from django.shortcuts import redirect, render
-from django.utils.translation import ugettext as _
-
-logger = logging.getLogger('pretix.presale.async')
-
-
-class AsyncAction:
-    task = None
-    success_url = None
-    error_url = None
-
-    def do(self, *args):
-        if settings.HAS_CELERY:
-            from pretix.celery import app
-
-            if hasattr(self.task, 'task') and isinstance(self.task.task, app.Task):
-                return self._do_celery(args)
-            else:
-                raise TypeError('Method has no task attached')
-        else:
-            return self._do_sync(args)
-
-    def get_success_url(self, value):
-        return self.success_url
-
-    def get_error_url(self):
-        return self.error_url
-
-    def get_check_url(self, task_id, ajax):
-        return self.request.path + '?async_id=%s' % task_id + ('&ajax=1' if ajax else '')
-
-    def get(self, request, *args, **kwargs):
-        if 'async_id' in request.GET and settings.HAS_CELERY:
-            return self.get_result(request)
-        return self.http_method_not_allowed(request)
-
-    def _return_celery_result(self, res, timeout=.5):
-        import celery.exceptions
-
-        if not res.ready():
-            try:
-                res.get(timeout=timeout)
-            except celery.exceptions.TimeoutError:
-                pass
-        ready = res.ready()
-        data = {
-            'async_id': res.id,
-            'ready': ready
-        }
-        if ready:
-            if res.successful() and not isinstance(res.info, Exception):
-                smes = self.get_success_message(res.info)
-                if smes:
-                    messages.success(self.request, smes)
-                # TODO: Do not store message if the ajax client stats that it will not redirect
-                # but handle the mssage itself
-                data.update({
-                    'redirect': self.get_success_url(res.info),
-                    'message': str(self.get_success_message(res.info))
-                })
-            else:
-                messages.error(self.request, self.get_error_message(res.info))
-                # TODO: Do not store message if the ajax client stats that it will not redirect
-                # but handle the mssage itself
-                data.update({
-                    'redirect': self.get_error_url(),
-                    'message': str(self.get_error_message(res.info))
-                })
-        return data
-
-    def get_result(self, request):
-        from celery.result import AsyncResult
-
-        res = AsyncResult(request.GET.get('async_id'))
-        if 'ajax' in self.request.GET:
-            return JsonResponse(self._return_celery_result(res, timeout=0.25))
-        else:
-            if res.ready():
-                if res.successful():
-                    return self.success(res.info)
-                else:
-                    return self.error(res.info)
-            return render(request, 'pretixpresale/waiting.html')
-
-    def _do_celery(self, args):
-        res = self.task.task.apply_async(args=args)
-        if 'ajax' in self.request.GET or 'ajax' in self.request.POST:
-            data = self._return_celery_result(res)
-            data['check_url'] = self.get_check_url(res.id, True)
-            return JsonResponse(data)
-        else:
-            return redirect(self.get_check_url(res.id, False))
-
-    def _do_sync(self, args):
-        try:
-            rs = getattr(self.__class__, 'task')(*args)
-            return self.success(rs)
-        except Exception as e:
-            logger.exception('Error while executing task synchronously')
-            return self.error(e)
-
-    def success(self, value):
-        smes = self.get_success_message(value)
-        if smes:
-            messages.success(self.request, smes)
-        if "ajax" in self.request.POST or "ajax" in self.request.GET:
-            return JsonResponse({
-                'ready': True,
-                'redirect': self.get_success_url(value),
-                'message': str(self.get_success_message(value))
-            })
-        return redirect(self.get_success_url(value))
-
-    def error(self, exception):
-        messages.error(self.request, self.get_error_message(exception))
-        if "ajax" in self.request.POST or "ajax" in self.request.GET:
-            return JsonResponse({
-                'ready': True,
-                'redirect': self.get_error_url(),
-                'message': str(self.get_error_message(exception))
-            })
-        return redirect(self.get_error_url())
-
-    def get_error_message(self, exception):
-        logger.error('Unexpected exception: %r' % exception)
-        return _('An unexpected error has occured.')
-
-    def get_success_message(self, value):
-        return _('The task has been completed.')
+# file kept for backwards compatibility
diff --git a/src/requirements/banktransfer.txt b/src/requirements/banktransfer.txt
index f388c86b35..bb1275fd84 100644
--- a/src/requirements/banktransfer.txt
+++ b/src/requirements/banktransfer.txt
@@ -1,4 +1,3 @@
 chardet>=2.3,<3
-defusedxml
 mt-940==3.2
 
diff --git a/src/setup.py b/src/setup.py
index debb15436f..3c0522ed29 100644
--- a/src/setup.py
+++ b/src/setup.py
@@ -61,7 +61,7 @@ setup(
         'easy-thumbnails>=2.2,<3'
         'PyPDF2', 'BeautifulSoup4', 'html5lib',
         'slimit', 'lxml', 'static3==0.6.1', 'dj-static', 'chardet',
-        'csscompressor', 'defusedxml', 'mt-940', 'django-markup', 'markdown'
+        'csscompressor', 'mt-940', 'django-markup', 'markdown'
     ],
     extras_require={
         'dev': ['django-debug-toolbar>=1.3.0,<2.0'],
diff --git a/src/static/pretixcontrol/js/ui/main.js b/src/static/pretixcontrol/js/ui/main.js
index 01f45f5201..f51ab8d09f 100644
--- a/src/static/pretixcontrol/js/ui/main.js
+++ b/src/static/pretixcontrol/js/ui/main.js
@@ -1,4 +1,4 @@
-/*global $*/
+/*global $,gettext*/
 
 function question_page_toggle_view() {
     var show = $("#id_type").val() == "C" || $("#id_type").val() == "M";
@@ -8,6 +8,42 @@ function question_page_toggle_view() {
     $(".alert-required-boolean").toggle(show);
 }
 
+var waitingDialog = {
+    show: function (message) {
+        "use strict";
+        $("#loadingmodal").find("h1").html(message);
+        $("body").addClass("loading");
+    },
+    hide: function () {
+        "use strict";
+        $("body").removeClass("loading");
+    }
+};
+
+var ajaxErrDialog = {
+    show: function (c) {
+        "use strict";
+        $("#ajaxerr").html(c);
+        $("#ajaxerr .links").html("<a class='btn btn-default ajaxerr-close'>"
+                                  + gettext("Close message") + "</a>");
+        $("body").addClass("ajaxerr");
+    },
+    hide: function () {
+        "use strict";
+        $("body").removeClass("ajaxerr");
+    }
+};
+
+$(document).ajaxError(function (event, jqXHR, settings, thrownError) {
+    waitingDialog.hide();
+    var c = $(jqXHR.responseText).filter('.container');
+    if (c.length > 0) {
+        ajaxErrDialog.show(c.first().html());
+    } else {
+        alert(gettext('Unknown error.'));
+    }
+});
+
 $(function () {
     "use strict";
 
@@ -45,6 +81,8 @@ $(function () {
     });
 
     $('.collapsible').collapse();
+    
+    $('[data-toggle="tooltip"]').tooltip()
 
     // Question editor
     if ($("#answer-options").length) {
@@ -63,4 +101,6 @@ $(function () {
             $("#id_codes").text(data.codes.join("\n"));
         });
     });
+
+    $("#ajaxerr").on("click", ".ajaxerr-close", ajaxErrDialog.hide);
 });
diff --git a/src/static/pretixcontrol/scss/main.scss b/src/static/pretixcontrol/scss/main.scss
index 57814a793b..0c40de4167 100644
--- a/src/static/pretixcontrol/scss/main.scss
+++ b/src/static/pretixcontrol/scss/main.scss
@@ -2,6 +2,7 @@
 @import "../../bootstrap/scss/_bootstrap.scss";
 $fa-font-path: static("fontawesome/fonts");
 @import "../../fontawesome/scss/font-awesome.scss";
+@import "../../typeahead/typeahead.css";
 @import "../css/metisMenu.min.css";
 @import "_sb-admin-2.scss";
 @import "_forms.scss";
@@ -129,3 +130,49 @@ h1 .btn-sm {
 .form-order-change .form-group {
     margin: 0;
 }
+
+#loadingmodal, #ajaxerr {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100vw;
+    height: 100vh;
+    background: rgba(255, 255, 255, .7);
+    opacity: 0;
+    text-align: center;
+    z-index: 900000;
+    visibility: hidden;
+
+    .big-icon {
+        margin-top: 50px;
+        font-size: 200px;
+        color: $brand-primary;
+    }
+
+    .big-rotating-icon {
+        -webkit-animation: fa-spin 8s infinite linear;
+        animation: fa-spin 8s infinite linear;
+        margin-top: 50px;
+        font-size: 200px;
+        color: $brand-primary;
+    }
+}
+#ajaxerr {
+    background: rgba(236, 236, 236, .9);
+}
+
+.loading #loadingmodal, .ajaxerr #ajaxerr {
+    opacity: 1;
+    visibility: visible;
+    transition: opacity .5s ease-in-out;
+    -moz-transition: opacity .5s ease-in-out;
+    -webkit-transition: opacity .5s ease-in-out;
+}
+
+.big-rotating-icon {
+    margin-top: 50px;
+    -webkit-animation: fa-spin 8s infinite linear;
+    animation: fa-spin 8s infinite linear;
+    font-size: 200px;
+    color: $brand-primary;
+}
diff --git a/src/static/pretixpresale/scss/main.scss b/src/static/pretixpresale/scss/main.scss
index b581a1e39c..547f2bb107 100644
--- a/src/static/pretixpresale/scss/main.scss
+++ b/src/static/pretixpresale/scss/main.scss
@@ -135,4 +135,4 @@ body.loading .container {
     h2 {
         margin-top: 0;
     }
-}
\ No newline at end of file
+}
diff --git a/src/static/typeahead/typeahead.bundle.js b/src/static/typeahead/typeahead.bundle.js
new file mode 100644
index 0000000000..bb0c8aeda6
--- /dev/null
+++ b/src/static/typeahead/typeahead.bundle.js
@@ -0,0 +1,2451 @@
+/*!
+ * typeahead.js 0.11.1
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2015 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+(function(root, factory) {
+    if (typeof define === "function" && define.amd) {
+        define("bloodhound", [ "jquery" ], function(a0) {
+            return root["Bloodhound"] = factory(a0);
+        });
+    } else if (typeof exports === "object") {
+        module.exports = factory(require("jquery"));
+    } else {
+        root["Bloodhound"] = factory(jQuery);
+    }
+})(this, function($) {
+    var _ = function() {
+        "use strict";
+        return {
+            isMsie: function() {
+                return /(msie|trident)/i.test(navigator.userAgent) ? navigator.userAgent.match(/(msie |rv:)(\d+(.\d+)?)/i)[2] : false;
+            },
+            isBlankString: function(str) {
+                return !str || /^\s*$/.test(str);
+            },
+            escapeRegExChars: function(str) {
+                return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+            },
+            isString: function(obj) {
+                return typeof obj === "string";
+            },
+            isNumber: function(obj) {
+                return typeof obj === "number";
+            },
+            isArray: $.isArray,
+            isFunction: $.isFunction,
+            isObject: $.isPlainObject,
+            isUndefined: function(obj) {
+                return typeof obj === "undefined";
+            },
+            isElement: function(obj) {
+                return !!(obj && obj.nodeType === 1);
+            },
+            isJQuery: function(obj) {
+                return obj instanceof $;
+            },
+            toStr: function toStr(s) {
+                return _.isUndefined(s) || s === null ? "" : s + "";
+            },
+            bind: $.proxy,
+            each: function(collection, cb) {
+                $.each(collection, reverseArgs);
+                function reverseArgs(index, value) {
+                    return cb(value, index);
+                }
+            },
+            map: $.map,
+            filter: $.grep,
+            every: function(obj, test) {
+                var result = true;
+                if (!obj) {
+                    return result;
+                }
+                $.each(obj, function(key, val) {
+                    if (!(result = test.call(null, val, key, obj))) {
+                        return false;
+                    }
+                });
+                return !!result;
+            },
+            some: function(obj, test) {
+                var result = false;
+                if (!obj) {
+                    return result;
+                }
+                $.each(obj, function(key, val) {
+                    if (result = test.call(null, val, key, obj)) {
+                        return false;
+                    }
+                });
+                return !!result;
+            },
+            mixin: $.extend,
+            identity: function(x) {
+                return x;
+            },
+            clone: function(obj) {
+                return $.extend(true, {}, obj);
+            },
+            getIdGenerator: function() {
+                var counter = 0;
+                return function() {
+                    return counter++;
+                };
+            },
+            templatify: function templatify(obj) {
+                return $.isFunction(obj) ? obj : template;
+                function template() {
+                    return String(obj);
+                }
+            },
+            defer: function(fn) {
+                setTimeout(fn, 0);
+            },
+            debounce: function(func, wait, immediate) {
+                var timeout, result;
+                return function() {
+                    var context = this, args = arguments, later, callNow;
+                    later = function() {
+                        timeout = null;
+                        if (!immediate) {
+                            result = func.apply(context, args);
+                        }
+                    };
+                    callNow = immediate && !timeout;
+                    clearTimeout(timeout);
+                    timeout = setTimeout(later, wait);
+                    if (callNow) {
+                        result = func.apply(context, args);
+                    }
+                    return result;
+                };
+            },
+            throttle: function(func, wait) {
+                var context, args, timeout, result, previous, later;
+                previous = 0;
+                later = function() {
+                    previous = new Date();
+                    timeout = null;
+                    result = func.apply(context, args);
+                };
+                return function() {
+                    var now = new Date(), remaining = wait - (now - previous);
+                    context = this;
+                    args = arguments;
+                    if (remaining <= 0) {
+                        clearTimeout(timeout);
+                        timeout = null;
+                        previous = now;
+                        result = func.apply(context, args);
+                    } else if (!timeout) {
+                        timeout = setTimeout(later, remaining);
+                    }
+                    return result;
+                };
+            },
+            stringify: function(val) {
+                return _.isString(val) ? val : JSON.stringify(val);
+            },
+            noop: function() {}
+        };
+    }();
+    var VERSION = "0.11.1";
+    var tokenizers = function() {
+        "use strict";
+        return {
+            nonword: nonword,
+            whitespace: whitespace,
+            obj: {
+                nonword: getObjTokenizer(nonword),
+                whitespace: getObjTokenizer(whitespace)
+            }
+        };
+        function whitespace(str) {
+            str = _.toStr(str);
+            return str ? str.split(/\s+/) : [];
+        }
+        function nonword(str) {
+            str = _.toStr(str);
+            return str ? str.split(/\W+/) : [];
+        }
+        function getObjTokenizer(tokenizer) {
+            return function setKey(keys) {
+                keys = _.isArray(keys) ? keys : [].slice.call(arguments, 0);
+                return function tokenize(o) {
+                    var tokens = [];
+                    _.each(keys, function(k) {
+                        tokens = tokens.concat(tokenizer(_.toStr(o[k])));
+                    });
+                    return tokens;
+                };
+            };
+        }
+    }();
+    var LruCache = function() {
+        "use strict";
+        function LruCache(maxSize) {
+            this.maxSize = _.isNumber(maxSize) ? maxSize : 100;
+            this.reset();
+            if (this.maxSize <= 0) {
+                this.set = this.get = $.noop;
+            }
+        }
+        _.mixin(LruCache.prototype, {
+            set: function set(key, val) {
+                var tailItem = this.list.tail, node;
+                if (this.size >= this.maxSize) {
+                    this.list.remove(tailItem);
+                    delete this.hash[tailItem.key];
+                    this.size--;
+                }
+                if (node = this.hash[key]) {
+                    node.val = val;
+                    this.list.moveToFront(node);
+                } else {
+                    node = new Node(key, val);
+                    this.list.add(node);
+                    this.hash[key] = node;
+                    this.size++;
+                }
+            },
+            get: function get(key) {
+                var node = this.hash[key];
+                if (node) {
+                    this.list.moveToFront(node);
+                    return node.val;
+                }
+            },
+            reset: function reset() {
+                this.size = 0;
+                this.hash = {};
+                this.list = new List();
+            }
+        });
+        function List() {
+            this.head = this.tail = null;
+        }
+        _.mixin(List.prototype, {
+            add: function add(node) {
+                if (this.head) {
+                    node.next = this.head;
+                    this.head.prev = node;
+                }
+                this.head = node;
+                this.tail = this.tail || node;
+            },
+            remove: function remove(node) {
+                node.prev ? node.prev.next = node.next : this.head = node.next;
+                node.next ? node.next.prev = node.prev : this.tail = node.prev;
+            },
+            moveToFront: function(node) {
+                this.remove(node);
+                this.add(node);
+            }
+        });
+        function Node(key, val) {
+            this.key = key;
+            this.val = val;
+            this.prev = this.next = null;
+        }
+        return LruCache;
+    }();
+    var PersistentStorage = function() {
+        "use strict";
+        var LOCAL_STORAGE;
+        try {
+            LOCAL_STORAGE = window.localStorage;
+            LOCAL_STORAGE.setItem("~~~", "!");
+            LOCAL_STORAGE.removeItem("~~~");
+        } catch (err) {
+            LOCAL_STORAGE = null;
+        }
+        function PersistentStorage(namespace, override) {
+            this.prefix = [ "__", namespace, "__" ].join("");
+            this.ttlKey = "__ttl__";
+            this.keyMatcher = new RegExp("^" + _.escapeRegExChars(this.prefix));
+            this.ls = override || LOCAL_STORAGE;
+            !this.ls && this._noop();
+        }
+        _.mixin(PersistentStorage.prototype, {
+            _prefix: function(key) {
+                return this.prefix + key;
+            },
+            _ttlKey: function(key) {
+                return this._prefix(key) + this.ttlKey;
+            },
+            _noop: function() {
+                this.get = this.set = this.remove = this.clear = this.isExpired = _.noop;
+            },
+            _safeSet: function(key, val) {
+                try {
+                    this.ls.setItem(key, val);
+                } catch (err) {
+                    if (err.name === "QuotaExceededError") {
+                        this.clear();
+                        this._noop();
+                    }
+                }
+            },
+            get: function(key) {
+                if (this.isExpired(key)) {
+                    this.remove(key);
+                }
+                return decode(this.ls.getItem(this._prefix(key)));
+            },
+            set: function(key, val, ttl) {
+                if (_.isNumber(ttl)) {
+                    this._safeSet(this._ttlKey(key), encode(now() + ttl));
+                } else {
+                    this.ls.removeItem(this._ttlKey(key));
+                }
+                return this._safeSet(this._prefix(key), encode(val));
+            },
+            remove: function(key) {
+                this.ls.removeItem(this._ttlKey(key));
+                this.ls.removeItem(this._prefix(key));
+                return this;
+            },
+            clear: function() {
+                var i, keys = gatherMatchingKeys(this.keyMatcher);
+                for (i = keys.length; i--; ) {
+                    this.remove(keys[i]);
+                }
+                return this;
+            },
+            isExpired: function(key) {
+                var ttl = decode(this.ls.getItem(this._ttlKey(key)));
+                return _.isNumber(ttl) && now() > ttl ? true : false;
+            }
+        });
+        return PersistentStorage;
+        function now() {
+            return new Date().getTime();
+        }
+        function encode(val) {
+            return JSON.stringify(_.isUndefined(val) ? null : val);
+        }
+        function decode(val) {
+            return $.parseJSON(val);
+        }
+        function gatherMatchingKeys(keyMatcher) {
+            var i, key, keys = [], len = LOCAL_STORAGE.length;
+            for (i = 0; i < len; i++) {
+                if ((key = LOCAL_STORAGE.key(i)).match(keyMatcher)) {
+                    keys.push(key.replace(keyMatcher, ""));
+                }
+            }
+            return keys;
+        }
+    }();
+    var Transport = function() {
+        "use strict";
+        var pendingRequestsCount = 0, pendingRequests = {}, maxPendingRequests = 6, sharedCache = new LruCache(10);
+        function Transport(o) {
+            o = o || {};
+            this.cancelled = false;
+            this.lastReq = null;
+            this._send = o.transport;
+            this._get = o.limiter ? o.limiter(this._get) : this._get;
+            this._cache = o.cache === false ? new LruCache(0) : sharedCache;
+        }
+        Transport.setMaxPendingRequests = function setMaxPendingRequests(num) {
+            maxPendingRequests = num;
+        };
+        Transport.resetCache = function resetCache() {
+            sharedCache.reset();
+        };
+        _.mixin(Transport.prototype, {
+            _fingerprint: function fingerprint(o) {
+                o = o || {};
+                return o.url + o.type + $.param(o.data || {});
+            },
+            _get: function(o, cb) {
+                var that = this, fingerprint, jqXhr;
+                fingerprint = this._fingerprint(o);
+                if (this.cancelled || fingerprint !== this.lastReq) {
+                    return;
+                }
+                if (jqXhr = pendingRequests[fingerprint]) {
+                    jqXhr.done(done).fail(fail);
+                } else if (pendingRequestsCount < maxPendingRequests) {
+                    pendingRequestsCount++;
+                    pendingRequests[fingerprint] = this._send(o).done(done).fail(fail).always(always);
+                } else {
+                    this.onDeckRequestArgs = [].slice.call(arguments, 0);
+                }
+                function done(resp) {
+                    cb(null, resp);
+                    that._cache.set(fingerprint, resp);
+                }
+                function fail() {
+                    cb(true);
+                }
+                function always() {
+                    pendingRequestsCount--;
+                    delete pendingRequests[fingerprint];
+                    if (that.onDeckRequestArgs) {
+                        that._get.apply(that, that.onDeckRequestArgs);
+                        that.onDeckRequestArgs = null;
+                    }
+                }
+            },
+            get: function(o, cb) {
+                var resp, fingerprint;
+                cb = cb || $.noop;
+                o = _.isString(o) ? {
+                    url: o
+                } : o || {};
+                fingerprint = this._fingerprint(o);
+                this.cancelled = false;
+                this.lastReq = fingerprint;
+                if (resp = this._cache.get(fingerprint)) {
+                    cb(null, resp);
+                } else {
+                    this._get(o, cb);
+                }
+            },
+            cancel: function() {
+                this.cancelled = true;
+            }
+        });
+        return Transport;
+    }();
+    var SearchIndex = window.SearchIndex = function() {
+        "use strict";
+        var CHILDREN = "c", IDS = "i";
+        function SearchIndex(o) {
+            o = o || {};
+            if (!o.datumTokenizer || !o.queryTokenizer) {
+                $.error("datumTokenizer and queryTokenizer are both required");
+            }
+            this.identify = o.identify || _.stringify;
+            this.datumTokenizer = o.datumTokenizer;
+            this.queryTokenizer = o.queryTokenizer;
+            this.reset();
+        }
+        _.mixin(SearchIndex.prototype, {
+            bootstrap: function bootstrap(o) {
+                this.datums = o.datums;
+                this.trie = o.trie;
+            },
+            add: function(data) {
+                var that = this;
+                data = _.isArray(data) ? data : [ data ];
+                _.each(data, function(datum) {
+                    var id, tokens;
+                    that.datums[id = that.identify(datum)] = datum;
+                    tokens = normalizeTokens(that.datumTokenizer(datum));
+                    _.each(tokens, function(token) {
+                        var node, chars, ch;
+                        node = that.trie;
+                        chars = token.split("");
+                        while (ch = chars.shift()) {
+                            node = node[CHILDREN][ch] || (node[CHILDREN][ch] = newNode());
+                            node[IDS].push(id);
+                        }
+                    });
+                });
+            },
+            get: function get(ids) {
+                var that = this;
+                return _.map(ids, function(id) {
+                    return that.datums[id];
+                });
+            },
+            search: function search(query) {
+                var that = this, tokens, matches;
+                tokens = normalizeTokens(this.queryTokenizer(query));
+                _.each(tokens, function(token) {
+                    var node, chars, ch, ids;
+                    if (matches && matches.length === 0) {
+                        return false;
+                    }
+                    node = that.trie;
+                    chars = token.split("");
+                    while (node && (ch = chars.shift())) {
+                        node = node[CHILDREN][ch];
+                    }
+                    if (node && chars.length === 0) {
+                        ids = node[IDS].slice(0);
+                        matches = matches ? getIntersection(matches, ids) : ids;
+                    } else {
+                        matches = [];
+                        return false;
+                    }
+                });
+                return matches ? _.map(unique(matches), function(id) {
+                    return that.datums[id];
+                }) : [];
+            },
+            all: function all() {
+                var values = [];
+                for (var key in this.datums) {
+                    values.push(this.datums[key]);
+                }
+                return values;
+            },
+            reset: function reset() {
+                this.datums = {};
+                this.trie = newNode();
+            },
+            serialize: function serialize() {
+                return {
+                    datums: this.datums,
+                    trie: this.trie
+                };
+            }
+        });
+        return SearchIndex;
+        function normalizeTokens(tokens) {
+            tokens = _.filter(tokens, function(token) {
+                return !!token;
+            });
+            tokens = _.map(tokens, function(token) {
+                return token.toLowerCase();
+            });
+            return tokens;
+        }
+        function newNode() {
+            var node = {};
+            node[IDS] = [];
+            node[CHILDREN] = {};
+            return node;
+        }
+        function unique(array) {
+            var seen = {}, uniques = [];
+            for (var i = 0, len = array.length; i < len; i++) {
+                if (!seen[array[i]]) {
+                    seen[array[i]] = true;
+                    uniques.push(array[i]);
+                }
+            }
+            return uniques;
+        }
+        function getIntersection(arrayA, arrayB) {
+            var ai = 0, bi = 0, intersection = [];
+            arrayA = arrayA.sort();
+            arrayB = arrayB.sort();
+            var lenArrayA = arrayA.length, lenArrayB = arrayB.length;
+            while (ai < lenArrayA && bi < lenArrayB) {
+                if (arrayA[ai] < arrayB[bi]) {
+                    ai++;
+                } else if (arrayA[ai] > arrayB[bi]) {
+                    bi++;
+                } else {
+                    intersection.push(arrayA[ai]);
+                    ai++;
+                    bi++;
+                }
+            }
+            return intersection;
+        }
+    }();
+    var Prefetch = function() {
+        "use strict";
+        var keys;
+        keys = {
+            data: "data",
+            protocol: "protocol",
+            thumbprint: "thumbprint"
+        };
+        function Prefetch(o) {
+            this.url = o.url;
+            this.ttl = o.ttl;
+            this.cache = o.cache;
+            this.prepare = o.prepare;
+            this.transform = o.transform;
+            this.transport = o.transport;
+            this.thumbprint = o.thumbprint;
+            this.storage = new PersistentStorage(o.cacheKey);
+        }
+        _.mixin(Prefetch.prototype, {
+            _settings: function settings() {
+                return {
+                    url: this.url,
+                    type: "GET",
+                    dataType: "json"
+                };
+            },
+            store: function store(data) {
+                if (!this.cache) {
+                    return;
+                }
+                this.storage.set(keys.data, data, this.ttl);
+                this.storage.set(keys.protocol, location.protocol, this.ttl);
+                this.storage.set(keys.thumbprint, this.thumbprint, this.ttl);
+            },
+            fromCache: function fromCache() {
+                var stored = {}, isExpired;
+                if (!this.cache) {
+                    return null;
+                }
+                stored.data = this.storage.get(keys.data);
+                stored.protocol = this.storage.get(keys.protocol);
+                stored.thumbprint = this.storage.get(keys.thumbprint);
+                isExpired = stored.thumbprint !== this.thumbprint || stored.protocol !== location.protocol;
+                return stored.data && !isExpired ? stored.data : null;
+            },
+            fromNetwork: function(cb) {
+                var that = this, settings;
+                if (!cb) {
+                    return;
+                }
+                settings = this.prepare(this._settings());
+                this.transport(settings).fail(onError).done(onResponse);
+                function onError() {
+                    cb(true);
+                }
+                function onResponse(resp) {
+                    cb(null, that.transform(resp));
+                }
+            },
+            clear: function clear() {
+                this.storage.clear();
+                return this;
+            }
+        });
+        return Prefetch;
+    }();
+    var Remote = function() {
+        "use strict";
+        function Remote(o) {
+            this.url = o.url;
+            this.prepare = o.prepare;
+            this.transform = o.transform;
+            this.transport = new Transport({
+                cache: o.cache,
+                limiter: o.limiter,
+                transport: o.transport
+            });
+        }
+        _.mixin(Remote.prototype, {
+            _settings: function settings() {
+                return {
+                    url: this.url,
+                    type: "GET",
+                    dataType: "json"
+                };
+            },
+            get: function get(query, cb) {
+                var that = this, settings;
+                if (!cb) {
+                    return;
+                }
+                query = query || "";
+                settings = this.prepare(query, this._settings());
+                return this.transport.get(settings, onResponse);
+                function onResponse(err, resp) {
+                    err ? cb([]) : cb(that.transform(resp));
+                }
+            },
+            cancelLastRequest: function cancelLastRequest() {
+                this.transport.cancel();
+            }
+        });
+        return Remote;
+    }();
+    var oParser = function() {
+        "use strict";
+        return function parse(o) {
+            var defaults, sorter;
+            defaults = {
+                initialize: true,
+                identify: _.stringify,
+                datumTokenizer: null,
+                queryTokenizer: null,
+                sufficient: 5,
+                sorter: null,
+                local: [],
+                prefetch: null,
+                remote: null
+            };
+            o = _.mixin(defaults, o || {});
+            !o.datumTokenizer && $.error("datumTokenizer is required");
+            !o.queryTokenizer && $.error("queryTokenizer is required");
+            sorter = o.sorter;
+            o.sorter = sorter ? function(x) {
+                return x.sort(sorter);
+            } : _.identity;
+            o.local = _.isFunction(o.local) ? o.local() : o.local;
+            o.prefetch = parsePrefetch(o.prefetch);
+            o.remote = parseRemote(o.remote);
+            return o;
+        };
+        function parsePrefetch(o) {
+            var defaults;
+            if (!o) {
+                return null;
+            }
+            defaults = {
+                url: null,
+                ttl: 24 * 60 * 60 * 1e3,
+                cache: true,
+                cacheKey: null,
+                thumbprint: "",
+                prepare: _.identity,
+                transform: _.identity,
+                transport: null
+            };
+            o = _.isString(o) ? {
+                url: o
+            } : o;
+            o = _.mixin(defaults, o);
+            !o.url && $.error("prefetch requires url to be set");
+            o.transform = o.filter || o.transform;
+            o.cacheKey = o.cacheKey || o.url;
+            o.thumbprint = VERSION + o.thumbprint;
+            o.transport = o.transport ? callbackToDeferred(o.transport) : $.ajax;
+            return o;
+        }
+        function parseRemote(o) {
+            var defaults;
+            if (!o) {
+                return;
+            }
+            defaults = {
+                url: null,
+                cache: true,
+                prepare: null,
+                replace: null,
+                wildcard: null,
+                limiter: null,
+                rateLimitBy: "debounce",
+                rateLimitWait: 300,
+                transform: _.identity,
+                transport: null
+            };
+            o = _.isString(o) ? {
+                url: o
+            } : o;
+            o = _.mixin(defaults, o);
+            !o.url && $.error("remote requires url to be set");
+            o.transform = o.filter || o.transform;
+            o.prepare = toRemotePrepare(o);
+            o.limiter = toLimiter(o);
+            o.transport = o.transport ? callbackToDeferred(o.transport) : $.ajax;
+            delete o.replace;
+            delete o.wildcard;
+            delete o.rateLimitBy;
+            delete o.rateLimitWait;
+            return o;
+        }
+        function toRemotePrepare(o) {
+            var prepare, replace, wildcard;
+            prepare = o.prepare;
+            replace = o.replace;
+            wildcard = o.wildcard;
+            if (prepare) {
+                return prepare;
+            }
+            if (replace) {
+                prepare = prepareByReplace;
+            } else if (o.wildcard) {
+                prepare = prepareByWildcard;
+            } else {
+                prepare = idenityPrepare;
+            }
+            return prepare;
+            function prepareByReplace(query, settings) {
+                settings.url = replace(settings.url, query);
+                return settings;
+            }
+            function prepareByWildcard(query, settings) {
+                settings.url = settings.url.replace(wildcard, encodeURIComponent(query));
+                return settings;
+            }
+            function idenityPrepare(query, settings) {
+                return settings;
+            }
+        }
+        function toLimiter(o) {
+            var limiter, method, wait;
+            limiter = o.limiter;
+            method = o.rateLimitBy;
+            wait = o.rateLimitWait;
+            if (!limiter) {
+                limiter = /^throttle$/i.test(method) ? throttle(wait) : debounce(wait);
+            }
+            return limiter;
+            function debounce(wait) {
+                return function debounce(fn) {
+                    return _.debounce(fn, wait);
+                };
+            }
+            function throttle(wait) {
+                return function throttle(fn) {
+                    return _.throttle(fn, wait);
+                };
+            }
+        }
+        function callbackToDeferred(fn) {
+            return function wrapper(o) {
+                var deferred = $.Deferred();
+                fn(o, onSuccess, onError);
+                return deferred;
+                function onSuccess(resp) {
+                    _.defer(function() {
+                        deferred.resolve(resp);
+                    });
+                }
+                function onError(err) {
+                    _.defer(function() {
+                        deferred.reject(err);
+                    });
+                }
+            };
+        }
+    }();
+    var Bloodhound = function() {
+        "use strict";
+        var old;
+        old = window && window.Bloodhound;
+        function Bloodhound(o) {
+            o = oParser(o);
+            this.sorter = o.sorter;
+            this.identify = o.identify;
+            this.sufficient = o.sufficient;
+            this.local = o.local;
+            this.remote = o.remote ? new Remote(o.remote) : null;
+            this.prefetch = o.prefetch ? new Prefetch(o.prefetch) : null;
+            this.index = new SearchIndex({
+                identify: this.identify,
+                datumTokenizer: o.datumTokenizer,
+                queryTokenizer: o.queryTokenizer
+            });
+            o.initialize !== false && this.initialize();
+        }
+        Bloodhound.noConflict = function noConflict() {
+            window && (window.Bloodhound = old);
+            return Bloodhound;
+        };
+        Bloodhound.tokenizers = tokenizers;
+        _.mixin(Bloodhound.prototype, {
+            __ttAdapter: function ttAdapter() {
+                var that = this;
+                return this.remote ? withAsync : withoutAsync;
+                function withAsync(query, sync, async) {
+                    return that.search(query, sync, async);
+                }
+                function withoutAsync(query, sync) {
+                    return that.search(query, sync);
+                }
+            },
+            _loadPrefetch: function loadPrefetch() {
+                var that = this, deferred, serialized;
+                deferred = $.Deferred();
+                if (!this.prefetch) {
+                    deferred.resolve();
+                } else if (serialized = this.prefetch.fromCache()) {
+                    this.index.bootstrap(serialized);
+                    deferred.resolve();
+                } else {
+                    this.prefetch.fromNetwork(done);
+                }
+                return deferred.promise();
+                function done(err, data) {
+                    if (err) {
+                        return deferred.reject();
+                    }
+                    that.add(data);
+                    that.prefetch.store(that.index.serialize());
+                    deferred.resolve();
+                }
+            },
+            _initialize: function initialize() {
+                var that = this, deferred;
+                this.clear();
+                (this.initPromise = this._loadPrefetch()).done(addLocalToIndex);
+                return this.initPromise;
+                function addLocalToIndex() {
+                    that.add(that.local);
+                }
+            },
+            initialize: function initialize(force) {
+                return !this.initPromise || force ? this._initialize() : this.initPromise;
+            },
+            add: function add(data) {
+                this.index.add(data);
+                return this;
+            },
+            get: function get(ids) {
+                ids = _.isArray(ids) ? ids : [].slice.call(arguments);
+                return this.index.get(ids);
+            },
+            search: function search(query, sync, async) {
+                var that = this, local;
+                local = this.sorter(this.index.search(query));
+                sync(this.remote ? local.slice() : local);
+                if (this.remote && local.length < this.sufficient) {
+                    this.remote.get(query, processRemote);
+                } else if (this.remote) {
+                    this.remote.cancelLastRequest();
+                }
+                return this;
+                function processRemote(remote) {
+                    var nonDuplicates = [];
+                    _.each(remote, function(r) {
+                        !_.some(local, function(l) {
+                            return that.identify(r) === that.identify(l);
+                        }) && nonDuplicates.push(r);
+                    });
+                    async && async(nonDuplicates);
+                }
+            },
+            all: function all() {
+                return this.index.all();
+            },
+            clear: function clear() {
+                this.index.reset();
+                return this;
+            },
+            clearPrefetchCache: function clearPrefetchCache() {
+                this.prefetch && this.prefetch.clear();
+                return this;
+            },
+            clearRemoteCache: function clearRemoteCache() {
+                Transport.resetCache();
+                return this;
+            },
+            ttAdapter: function ttAdapter() {
+                return this.__ttAdapter();
+            }
+        });
+        return Bloodhound;
+    }();
+    return Bloodhound;
+});
+
+(function(root, factory) {
+    if (typeof define === "function" && define.amd) {
+        define("typeahead.js", [ "jquery" ], function(a0) {
+            return factory(a0);
+        });
+    } else if (typeof exports === "object") {
+        module.exports = factory(require("jquery"));
+    } else {
+        factory(jQuery);
+    }
+})(this, function($) {
+    var _ = function() {
+        "use strict";
+        return {
+            isMsie: function() {
+                return /(msie|trident)/i.test(navigator.userAgent) ? navigator.userAgent.match(/(msie |rv:)(\d+(.\d+)?)/i)[2] : false;
+            },
+            isBlankString: function(str) {
+                return !str || /^\s*$/.test(str);
+            },
+            escapeRegExChars: function(str) {
+                return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+            },
+            isString: function(obj) {
+                return typeof obj === "string";
+            },
+            isNumber: function(obj) {
+                return typeof obj === "number";
+            },
+            isArray: $.isArray,
+            isFunction: $.isFunction,
+            isObject: $.isPlainObject,
+            isUndefined: function(obj) {
+                return typeof obj === "undefined";
+            },
+            isElement: function(obj) {
+                return !!(obj && obj.nodeType === 1);
+            },
+            isJQuery: function(obj) {
+                return obj instanceof $;
+            },
+            toStr: function toStr(s) {
+                return _.isUndefined(s) || s === null ? "" : s + "";
+            },
+            bind: $.proxy,
+            each: function(collection, cb) {
+                $.each(collection, reverseArgs);
+                function reverseArgs(index, value) {
+                    return cb(value, index);
+                }
+            },
+            map: $.map,
+            filter: $.grep,
+            every: function(obj, test) {
+                var result = true;
+                if (!obj) {
+                    return result;
+                }
+                $.each(obj, function(key, val) {
+                    if (!(result = test.call(null, val, key, obj))) {
+                        return false;
+                    }
+                });
+                return !!result;
+            },
+            some: function(obj, test) {
+                var result = false;
+                if (!obj) {
+                    return result;
+                }
+                $.each(obj, function(key, val) {
+                    if (result = test.call(null, val, key, obj)) {
+                        return false;
+                    }
+                });
+                return !!result;
+            },
+            mixin: $.extend,
+            identity: function(x) {
+                return x;
+            },
+            clone: function(obj) {
+                return $.extend(true, {}, obj);
+            },
+            getIdGenerator: function() {
+                var counter = 0;
+                return function() {
+                    return counter++;
+                };
+            },
+            templatify: function templatify(obj) {
+                return $.isFunction(obj) ? obj : template;
+                function template() {
+                    return String(obj);
+                }
+            },
+            defer: function(fn) {
+                setTimeout(fn, 0);
+            },
+            debounce: function(func, wait, immediate) {
+                var timeout, result;
+                return function() {
+                    var context = this, args = arguments, later, callNow;
+                    later = function() {
+                        timeout = null;
+                        if (!immediate) {
+                            result = func.apply(context, args);
+                        }
+                    };
+                    callNow = immediate && !timeout;
+                    clearTimeout(timeout);
+                    timeout = setTimeout(later, wait);
+                    if (callNow) {
+                        result = func.apply(context, args);
+                    }
+                    return result;
+                };
+            },
+            throttle: function(func, wait) {
+                var context, args, timeout, result, previous, later;
+                previous = 0;
+                later = function() {
+                    previous = new Date();
+                    timeout = null;
+                    result = func.apply(context, args);
+                };
+                return function() {
+                    var now = new Date(), remaining = wait - (now - previous);
+                    context = this;
+                    args = arguments;
+                    if (remaining <= 0) {
+                        clearTimeout(timeout);
+                        timeout = null;
+                        previous = now;
+                        result = func.apply(context, args);
+                    } else if (!timeout) {
+                        timeout = setTimeout(later, remaining);
+                    }
+                    return result;
+                };
+            },
+            stringify: function(val) {
+                return _.isString(val) ? val : JSON.stringify(val);
+            },
+            noop: function() {}
+        };
+    }();
+    var WWW = function() {
+        "use strict";
+        var defaultClassNames = {
+            wrapper: "twitter-typeahead",
+            input: "tt-input",
+            hint: "tt-hint",
+            menu: "tt-menu",
+            dataset: "tt-dataset",
+            suggestion: "tt-suggestion",
+            selectable: "tt-selectable",
+            empty: "tt-empty",
+            open: "tt-open",
+            cursor: "tt-cursor",
+            highlight: "tt-highlight"
+        };
+        return build;
+        function build(o) {
+            var www, classes;
+            classes = _.mixin({}, defaultClassNames, o);
+            www = {
+                css: buildCss(),
+                classes: classes,
+                html: buildHtml(classes),
+                selectors: buildSelectors(classes)
+            };
+            return {
+                css: www.css,
+                html: www.html,
+                classes: www.classes,
+                selectors: www.selectors,
+                mixin: function(o) {
+                    _.mixin(o, www);
+                }
+            };
+        }
+        function buildHtml(c) {
+            return {
+                wrapper: '<span class="' + c.wrapper + '"></span>',
+                menu: '<div class="' + c.menu + '"></div>'
+            };
+        }
+        function buildSelectors(classes) {
+            var selectors = {};
+            _.each(classes, function(v, k) {
+                selectors[k] = "." + v;
+            });
+            return selectors;
+        }
+        function buildCss() {
+            var css = {
+                wrapper: {
+                    position: "relative",
+                    display: "inline-block"
+                },
+                hint: {
+                    position: "absolute",
+                    top: "0",
+                    left: "0",
+                    borderColor: "transparent",
+                    boxShadow: "none",
+                    opacity: "1"
+                },
+                input: {
+                    position: "relative",
+                    verticalAlign: "top",
+                    backgroundColor: "transparent"
+                },
+                inputWithNoHint: {
+                    position: "relative",
+                    verticalAlign: "top"
+                },
+                menu: {
+                    position: "absolute",
+                    top: "100%",
+                    left: "0",
+                    zIndex: "100",
+                    display: "none"
+                },
+                ltr: {
+                    left: "0",
+                    right: "auto"
+                },
+                rtl: {
+                    left: "auto",
+                    right: " 0"
+                }
+            };
+            if (_.isMsie()) {
+                _.mixin(css.input, {
+                    backgroundImage: "url(data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)"
+                });
+            }
+            return css;
+        }
+    }();
+    var EventBus = function() {
+        "use strict";
+        var namespace, deprecationMap;
+        namespace = "typeahead:";
+        deprecationMap = {
+            render: "rendered",
+            cursorchange: "cursorchanged",
+            select: "selected",
+            autocomplete: "autocompleted"
+        };
+        function EventBus(o) {
+            if (!o || !o.el) {
+                $.error("EventBus initialized without el");
+            }
+            this.$el = $(o.el);
+        }
+        _.mixin(EventBus.prototype, {
+            _trigger: function(type, args) {
+                var $e;
+                $e = $.Event(namespace + type);
+                (args = args || []).unshift($e);
+                this.$el.trigger.apply(this.$el, args);
+                return $e;
+            },
+            before: function(type) {
+                var args, $e;
+                args = [].slice.call(arguments, 1);
+                $e = this._trigger("before" + type, args);
+                return $e.isDefaultPrevented();
+            },
+            trigger: function(type) {
+                var deprecatedType;
+                this._trigger(type, [].slice.call(arguments, 1));
+                if (deprecatedType = deprecationMap[type]) {
+                    this._trigger(deprecatedType, [].slice.call(arguments, 1));
+                }
+            }
+        });
+        return EventBus;
+    }();
+    var EventEmitter = function() {
+        "use strict";
+        var splitter = /\s+/, nextTick = getNextTick();
+        return {
+            onSync: onSync,
+            onAsync: onAsync,
+            off: off,
+            trigger: trigger
+        };
+        function on(method, types, cb, context) {
+            var type;
+            if (!cb) {
+                return this;
+            }
+            types = types.split(splitter);
+            cb = context ? bindContext(cb, context) : cb;
+            this._callbacks = this._callbacks || {};
+            while (type = types.shift()) {
+                this._callbacks[type] = this._callbacks[type] || {
+                    sync: [],
+                    async: []
+                };
+                this._callbacks[type][method].push(cb);
+            }
+            return this;
+        }
+        function onAsync(types, cb, context) {
+            return on.call(this, "async", types, cb, context);
+        }
+        function onSync(types, cb, context) {
+            return on.call(this, "sync", types, cb, context);
+        }
+        function off(types) {
+            var type;
+            if (!this._callbacks) {
+                return this;
+            }
+            types = types.split(splitter);
+            while (type = types.shift()) {
+                delete this._callbacks[type];
+            }
+            return this;
+        }
+        function trigger(types) {
+            var type, callbacks, args, syncFlush, asyncFlush;
+            if (!this._callbacks) {
+                return this;
+            }
+            types = types.split(splitter);
+            args = [].slice.call(arguments, 1);
+            while ((type = types.shift()) && (callbacks = this._callbacks[type])) {
+                syncFlush = getFlush(callbacks.sync, this, [ type ].concat(args));
+                asyncFlush = getFlush(callbacks.async, this, [ type ].concat(args));
+                syncFlush() && nextTick(asyncFlush);
+            }
+            return this;
+        }
+        function getFlush(callbacks, context, args) {
+            return flush;
+            function flush() {
+                var cancelled;
+                for (var i = 0, len = callbacks.length; !cancelled && i < len; i += 1) {
+                    cancelled = callbacks[i].apply(context, args) === false;
+                }
+                return !cancelled;
+            }
+        }
+        function getNextTick() {
+            var nextTickFn;
+            if (window.setImmediate) {
+                nextTickFn = function nextTickSetImmediate(fn) {
+                    setImmediate(function() {
+                        fn();
+                    });
+                };
+            } else {
+                nextTickFn = function nextTickSetTimeout(fn) {
+                    setTimeout(function() {
+                        fn();
+                    }, 0);
+                };
+            }
+            return nextTickFn;
+        }
+        function bindContext(fn, context) {
+            return fn.bind ? fn.bind(context) : function() {
+                fn.apply(context, [].slice.call(arguments, 0));
+            };
+        }
+    }();
+    var highlight = function(doc) {
+        "use strict";
+        var defaults = {
+            node: null,
+            pattern: null,
+            tagName: "strong",
+            className: null,
+            wordsOnly: false,
+            caseSensitive: false
+        };
+        return function hightlight(o) {
+            var regex;
+            o = _.mixin({}, defaults, o);
+            if (!o.node || !o.pattern) {
+                return;
+            }
+            o.pattern = _.isArray(o.pattern) ? o.pattern : [ o.pattern ];
+            regex = getRegex(o.pattern, o.caseSensitive, o.wordsOnly);
+            traverse(o.node, hightlightTextNode);
+            function hightlightTextNode(textNode) {
+                var match, patternNode, wrapperNode;
+                if (match = regex.exec(textNode.data)) {
+                    wrapperNode = doc.createElement(o.tagName);
+                    o.className && (wrapperNode.className = o.className);
+                    patternNode = textNode.splitText(match.index);
+                    patternNode.splitText(match[0].length);
+                    wrapperNode.appendChild(patternNode.cloneNode(true));
+                    textNode.parentNode.replaceChild(wrapperNode, patternNode);
+                }
+                return !!match;
+            }
+            function traverse(el, hightlightTextNode) {
+                var childNode, TEXT_NODE_TYPE = 3;
+                for (var i = 0; i < el.childNodes.length; i++) {
+                    childNode = el.childNodes[i];
+                    if (childNode.nodeType === TEXT_NODE_TYPE) {
+                        i += hightlightTextNode(childNode) ? 1 : 0;
+                    } else {
+                        traverse(childNode, hightlightTextNode);
+                    }
+                }
+            }
+        };
+        function getRegex(patterns, caseSensitive, wordsOnly) {
+            var escapedPatterns = [], regexStr;
+            for (var i = 0, len = patterns.length; i < len; i++) {
+                escapedPatterns.push(_.escapeRegExChars(patterns[i]));
+            }
+            regexStr = wordsOnly ? "\\b(" + escapedPatterns.join("|") + ")\\b" : "(" + escapedPatterns.join("|") + ")";
+            return caseSensitive ? new RegExp(regexStr) : new RegExp(regexStr, "i");
+        }
+    }(window.document);
+    var Input = function() {
+        "use strict";
+        var specialKeyCodeMap;
+        specialKeyCodeMap = {
+            9: "tab",
+            27: "esc",
+            37: "left",
+            39: "right",
+            13: "enter",
+            38: "up",
+            40: "down"
+        };
+        function Input(o, www) {
+            o = o || {};
+            if (!o.input) {
+                $.error("input is missing");
+            }
+            www.mixin(this);
+            this.$hint = $(o.hint);
+            this.$input = $(o.input);
+            this.query = this.$input.val();
+            this.queryWhenFocused = this.hasFocus() ? this.query : null;
+            this.$overflowHelper = buildOverflowHelper(this.$input);
+            this._checkLanguageDirection();
+            if (this.$hint.length === 0) {
+                this.setHint = this.getHint = this.clearHint = this.clearHintIfInvalid = _.noop;
+            }
+        }
+        Input.normalizeQuery = function(str) {
+            return _.toStr(str).replace(/^\s*/g, "").replace(/\s{2,}/g, " ");
+        };
+        _.mixin(Input.prototype, EventEmitter, {
+            _onBlur: function onBlur() {
+                this.resetInputValue();
+                this.trigger("blurred");
+            },
+            _onFocus: function onFocus() {
+                this.queryWhenFocused = this.query;
+                this.trigger("focused");
+            },
+            _onKeydown: function onKeydown($e) {
+                var keyName = specialKeyCodeMap[$e.which || $e.keyCode];
+                this._managePreventDefault(keyName, $e);
+                if (keyName && this._shouldTrigger(keyName, $e)) {
+                    this.trigger(keyName + "Keyed", $e);
+                }
+            },
+            _onInput: function onInput() {
+                this._setQuery(this.getInputValue());
+                this.clearHintIfInvalid();
+                this._checkLanguageDirection();
+            },
+            _managePreventDefault: function managePreventDefault(keyName, $e) {
+                var preventDefault;
+                switch (keyName) {
+                  case "up":
+                  case "down":
+                    preventDefault = !withModifier($e);
+                    break;
+
+                  default:
+                    preventDefault = false;
+                }
+                preventDefault && $e.preventDefault();
+            },
+            _shouldTrigger: function shouldTrigger(keyName, $e) {
+                var trigger;
+                switch (keyName) {
+                  case "tab":
+                    trigger = !withModifier($e);
+                    break;
+
+                  default:
+                    trigger = true;
+                }
+                return trigger;
+            },
+            _checkLanguageDirection: function checkLanguageDirection() {
+                var dir = (this.$input.css("direction") || "ltr").toLowerCase();
+                if (this.dir !== dir) {
+                    this.dir = dir;
+                    this.$hint.attr("dir", dir);
+                    this.trigger("langDirChanged", dir);
+                }
+            },
+            _setQuery: function setQuery(val, silent) {
+                var areEquivalent, hasDifferentWhitespace;
+                areEquivalent = areQueriesEquivalent(val, this.query);
+                hasDifferentWhitespace = areEquivalent ? this.query.length !== val.length : false;
+                this.query = val;
+                if (!silent && !areEquivalent) {
+                    this.trigger("queryChanged", this.query);
+                } else if (!silent && hasDifferentWhitespace) {
+                    this.trigger("whitespaceChanged", this.query);
+                }
+            },
+            bind: function() {
+                var that = this, onBlur, onFocus, onKeydown, onInput;
+                onBlur = _.bind(this._onBlur, this);
+                onFocus = _.bind(this._onFocus, this);
+                onKeydown = _.bind(this._onKeydown, this);
+                onInput = _.bind(this._onInput, this);
+                this.$input.on("blur.tt", onBlur).on("focus.tt", onFocus).on("keydown.tt", onKeydown);
+                if (!_.isMsie() || _.isMsie() > 9) {
+                    this.$input.on("input.tt", onInput);
+                } else {
+                    this.$input.on("keydown.tt keypress.tt cut.tt paste.tt", function($e) {
+                        if (specialKeyCodeMap[$e.which || $e.keyCode]) {
+                            return;
+                        }
+                        _.defer(_.bind(that._onInput, that, $e));
+                    });
+                }
+                return this;
+            },
+            focus: function focus() {
+                this.$input.focus();
+            },
+            blur: function blur() {
+                this.$input.blur();
+            },
+            getLangDir: function getLangDir() {
+                return this.dir;
+            },
+            getQuery: function getQuery() {
+                return this.query || "";
+            },
+            setQuery: function setQuery(val, silent) {
+                this.setInputValue(val);
+                this._setQuery(val, silent);
+            },
+            hasQueryChangedSinceLastFocus: function hasQueryChangedSinceLastFocus() {
+                return this.query !== this.queryWhenFocused;
+            },
+            getInputValue: function getInputValue() {
+                return this.$input.val();
+            },
+            setInputValue: function setInputValue(value) {
+                this.$input.val(value);
+                this.clearHintIfInvalid();
+                this._checkLanguageDirection();
+            },
+            resetInputValue: function resetInputValue() {
+                this.setInputValue(this.query);
+            },
+            getHint: function getHint() {
+                return this.$hint.val();
+            },
+            setHint: function setHint(value) {
+                this.$hint.val(value);
+            },
+            clearHint: function clearHint() {
+                this.setHint("");
+            },
+            clearHintIfInvalid: function clearHintIfInvalid() {
+                var val, hint, valIsPrefixOfHint, isValid;
+                val = this.getInputValue();
+                hint = this.getHint();
+                valIsPrefixOfHint = val !== hint && hint.indexOf(val) === 0;
+                isValid = val !== "" && valIsPrefixOfHint && !this.hasOverflow();
+                !isValid && this.clearHint();
+            },
+            hasFocus: function hasFocus() {
+                return this.$input.is(":focus");
+            },
+            hasOverflow: function hasOverflow() {
+                var constraint = this.$input.width() - 2;
+                this.$overflowHelper.text(this.getInputValue());
+                return this.$overflowHelper.width() >= constraint;
+            },
+            isCursorAtEnd: function() {
+                var valueLength, selectionStart, range;
+                valueLength = this.$input.val().length;
+                selectionStart = this.$input[0].selectionStart;
+                if (_.isNumber(selectionStart)) {
+                    return selectionStart === valueLength;
+                } else if (document.selection) {
+                    range = document.selection.createRange();
+                    range.moveStart("character", -valueLength);
+                    return valueLength === range.text.length;
+                }
+                return true;
+            },
+            destroy: function destroy() {
+                this.$hint.off(".tt");
+                this.$input.off(".tt");
+                this.$overflowHelper.remove();
+                this.$hint = this.$input = this.$overflowHelper = $("<div>");
+            }
+        });
+        return Input;
+        function buildOverflowHelper($input) {
+            return $('<pre aria-hidden="true"></pre>').css({
+                position: "absolute",
+                visibility: "hidden",
+                whiteSpace: "pre",
+                fontFamily: $input.css("font-family"),
+                fontSize: $input.css("font-size"),
+                fontStyle: $input.css("font-style"),
+                fontVariant: $input.css("font-variant"),
+                fontWeight: $input.css("font-weight"),
+                wordSpacing: $input.css("word-spacing"),
+                letterSpacing: $input.css("letter-spacing"),
+                textIndent: $input.css("text-indent"),
+                textRendering: $input.css("text-rendering"),
+                textTransform: $input.css("text-transform")
+            }).insertAfter($input);
+        }
+        function areQueriesEquivalent(a, b) {
+            return Input.normalizeQuery(a) === Input.normalizeQuery(b);
+        }
+        function withModifier($e) {
+            return $e.altKey || $e.ctrlKey || $e.metaKey || $e.shiftKey;
+        }
+    }();
+    var Dataset = function() {
+        "use strict";
+        var keys, nameGenerator;
+        keys = {
+            val: "tt-selectable-display",
+            obj: "tt-selectable-object"
+        };
+        nameGenerator = _.getIdGenerator();
+        function Dataset(o, www) {
+            o = o || {};
+            o.templates = o.templates || {};
+            o.templates.notFound = o.templates.notFound || o.templates.empty;
+            if (!o.source) {
+                $.error("missing source");
+            }
+            if (!o.node) {
+                $.error("missing node");
+            }
+            if (o.name && !isValidName(o.name)) {
+                $.error("invalid dataset name: " + o.name);
+            }
+            www.mixin(this);
+            this.highlight = !!o.highlight;
+            this.name = o.name || nameGenerator();
+            this.limit = o.limit || 5;
+            this.displayFn = getDisplayFn(o.display || o.displayKey);
+            this.templates = getTemplates(o.templates, this.displayFn);
+            this.source = o.source.__ttAdapter ? o.source.__ttAdapter() : o.source;
+            this.async = _.isUndefined(o.async) ? this.source.length > 2 : !!o.async;
+            this._resetLastSuggestion();
+            this.$el = $(o.node).addClass(this.classes.dataset).addClass(this.classes.dataset + "-" + this.name);
+        }
+        Dataset.extractData = function extractData(el) {
+            var $el = $(el);
+            if ($el.data(keys.obj)) {
+                return {
+                    val: $el.data(keys.val) || "",
+                    obj: $el.data(keys.obj) || null
+                };
+            }
+            return null;
+        };
+        _.mixin(Dataset.prototype, EventEmitter, {
+            _overwrite: function overwrite(query, suggestions) {
+                suggestions = suggestions || [];
+                if (suggestions.length) {
+                    this._renderSuggestions(query, suggestions);
+                } else if (this.async && this.templates.pending) {
+                    this._renderPending(query);
+                } else if (!this.async && this.templates.notFound) {
+                    this._renderNotFound(query);
+                } else {
+                    this._empty();
+                }
+                this.trigger("rendered", this.name, suggestions, false);
+            },
+            _append: function append(query, suggestions) {
+                suggestions = suggestions || [];
+                if (suggestions.length && this.$lastSuggestion.length) {
+                    this._appendSuggestions(query, suggestions);
+                } else if (suggestions.length) {
+                    this._renderSuggestions(query, suggestions);
+                } else if (!this.$lastSuggestion.length && this.templates.notFound) {
+                    this._renderNotFound(query);
+                }
+                this.trigger("rendered", this.name, suggestions, true);
+            },
+            _renderSuggestions: function renderSuggestions(query, suggestions) {
+                var $fragment;
+                $fragment = this._getSuggestionsFragment(query, suggestions);
+                this.$lastSuggestion = $fragment.children().last();
+                this.$el.html($fragment).prepend(this._getHeader(query, suggestions)).append(this._getFooter(query, suggestions));
+            },
+            _appendSuggestions: function appendSuggestions(query, suggestions) {
+                var $fragment, $lastSuggestion;
+                $fragment = this._getSuggestionsFragment(query, suggestions);
+                $lastSuggestion = $fragment.children().last();
+                this.$lastSuggestion.after($fragment);
+                this.$lastSuggestion = $lastSuggestion;
+            },
+            _renderPending: function renderPending(query) {
+                var template = this.templates.pending;
+                this._resetLastSuggestion();
+                template && this.$el.html(template({
+                    query: query,
+                    dataset: this.name
+                }));
+            },
+            _renderNotFound: function renderNotFound(query) {
+                var template = this.templates.notFound;
+                this._resetLastSuggestion();
+                template && this.$el.html(template({
+                    query: query,
+                    dataset: this.name
+                }));
+            },
+            _empty: function empty() {
+                this.$el.empty();
+                this._resetLastSuggestion();
+            },
+            _getSuggestionsFragment: function getSuggestionsFragment(query, suggestions) {
+                var that = this, fragment;
+                fragment = document.createDocumentFragment();
+                _.each(suggestions, function getSuggestionNode(suggestion) {
+                    var $el, context;
+                    context = that._injectQuery(query, suggestion);
+                    $el = $(that.templates.suggestion(context)).data(keys.obj, suggestion).data(keys.val, that.displayFn(suggestion)).addClass(that.classes.suggestion + " " + that.classes.selectable);
+                    fragment.appendChild($el[0]);
+                });
+                this.highlight && highlight({
+                    className: this.classes.highlight,
+                    node: fragment,
+                    pattern: query
+                });
+                return $(fragment);
+            },
+            _getFooter: function getFooter(query, suggestions) {
+                return this.templates.footer ? this.templates.footer({
+                    query: query,
+                    suggestions: suggestions,
+                    dataset: this.name
+                }) : null;
+            },
+            _getHeader: function getHeader(query, suggestions) {
+                return this.templates.header ? this.templates.header({
+                    query: query,
+                    suggestions: suggestions,
+                    dataset: this.name
+                }) : null;
+            },
+            _resetLastSuggestion: function resetLastSuggestion() {
+                this.$lastSuggestion = $();
+            },
+            _injectQuery: function injectQuery(query, obj) {
+                return _.isObject(obj) ? _.mixin({
+                    _query: query
+                }, obj) : obj;
+            },
+            update: function update(query) {
+                var that = this, canceled = false, syncCalled = false, rendered = 0;
+                this.cancel();
+                this.cancel = function cancel() {
+                    canceled = true;
+                    that.cancel = $.noop;
+                    that.async && that.trigger("asyncCanceled", query);
+                };
+                this.source(query, sync, async);
+                !syncCalled && sync([]);
+                function sync(suggestions) {
+                    if (syncCalled) {
+                        return;
+                    }
+                    syncCalled = true;
+                    suggestions = (suggestions || []).slice(0, that.limit);
+                    rendered = suggestions.length;
+                    that._overwrite(query, suggestions);
+                    if (rendered < that.limit && that.async) {
+                        that.trigger("asyncRequested", query);
+                    }
+                }
+                function async(suggestions) {
+                    suggestions = suggestions || [];
+                    if (!canceled && rendered < that.limit) {
+                        that.cancel = $.noop;
+                        rendered += suggestions.length;
+                        that._append(query, suggestions.slice(0, that.limit - rendered));
+                        that.async && that.trigger("asyncReceived", query);
+                    }
+                }
+            },
+            cancel: $.noop,
+            clear: function clear() {
+                this._empty();
+                this.cancel();
+                this.trigger("cleared");
+            },
+            isEmpty: function isEmpty() {
+                return this.$el.is(":empty");
+            },
+            destroy: function destroy() {
+                this.$el = $("<div>");
+            }
+        });
+        return Dataset;
+        function getDisplayFn(display) {
+            display = display || _.stringify;
+            return _.isFunction(display) ? display : displayFn;
+            function displayFn(obj) {
+                return obj[display];
+            }
+        }
+        function getTemplates(templates, displayFn) {
+            return {
+                notFound: templates.notFound && _.templatify(templates.notFound),
+                pending: templates.pending && _.templatify(templates.pending),
+                header: templates.header && _.templatify(templates.header),
+                footer: templates.footer && _.templatify(templates.footer),
+                suggestion: templates.suggestion || suggestionTemplate
+            };
+            function suggestionTemplate(context) {
+                return $("<div>").text(displayFn(context));
+            }
+        }
+        function isValidName(str) {
+            return /^[_a-zA-Z0-9-]+$/.test(str);
+        }
+    }();
+    var Menu = function() {
+        "use strict";
+        function Menu(o, www) {
+            var that = this;
+            o = o || {};
+            if (!o.node) {
+                $.error("node is required");
+            }
+            www.mixin(this);
+            this.$node = $(o.node);
+            this.query = null;
+            this.datasets = _.map(o.datasets, initializeDataset);
+            function initializeDataset(oDataset) {
+                var node = that.$node.find(oDataset.node).first();
+                oDataset.node = node.length ? node : $("<div>").appendTo(that.$node);
+                return new Dataset(oDataset, www);
+            }
+        }
+        _.mixin(Menu.prototype, EventEmitter, {
+            _onSelectableClick: function onSelectableClick($e) {
+                this.trigger("selectableClicked", $($e.currentTarget));
+            },
+            _onRendered: function onRendered(type, dataset, suggestions, async) {
+                this.$node.toggleClass(this.classes.empty, this._allDatasetsEmpty());
+                this.trigger("datasetRendered", dataset, suggestions, async);
+            },
+            _onCleared: function onCleared() {
+                this.$node.toggleClass(this.classes.empty, this._allDatasetsEmpty());
+                this.trigger("datasetCleared");
+            },
+            _propagate: function propagate() {
+                this.trigger.apply(this, arguments);
+            },
+            _allDatasetsEmpty: function allDatasetsEmpty() {
+                return _.every(this.datasets, isDatasetEmpty);
+                function isDatasetEmpty(dataset) {
+                    return dataset.isEmpty();
+                }
+            },
+            _getSelectables: function getSelectables() {
+                return this.$node.find(this.selectors.selectable);
+            },
+            _removeCursor: function _removeCursor() {
+                var $selectable = this.getActiveSelectable();
+                $selectable && $selectable.removeClass(this.classes.cursor);
+            },
+            _ensureVisible: function ensureVisible($el) {
+                var elTop, elBottom, nodeScrollTop, nodeHeight;
+                elTop = $el.position().top;
+                elBottom = elTop + $el.outerHeight(true);
+                nodeScrollTop = this.$node.scrollTop();
+                nodeHeight = this.$node.height() + parseInt(this.$node.css("paddingTop"), 10) + parseInt(this.$node.css("paddingBottom"), 10);
+                if (elTop < 0) {
+                    this.$node.scrollTop(nodeScrollTop + elTop);
+                } else if (nodeHeight < elBottom) {
+                    this.$node.scrollTop(nodeScrollTop + (elBottom - nodeHeight));
+                }
+            },
+            bind: function() {
+                var that = this, onSelectableClick;
+                onSelectableClick = _.bind(this._onSelectableClick, this);
+                this.$node.on("click.tt", this.selectors.selectable, onSelectableClick);
+                _.each(this.datasets, function(dataset) {
+                    dataset.onSync("asyncRequested", that._propagate, that).onSync("asyncCanceled", that._propagate, that).onSync("asyncReceived", that._propagate, that).onSync("rendered", that._onRendered, that).onSync("cleared", that._onCleared, that);
+                });
+                return this;
+            },
+            isOpen: function isOpen() {
+                return this.$node.hasClass(this.classes.open);
+            },
+            open: function open() {
+                this.$node.addClass(this.classes.open);
+            },
+            close: function close() {
+                this.$node.removeClass(this.classes.open);
+                this._removeCursor();
+            },
+            setLanguageDirection: function setLanguageDirection(dir) {
+                this.$node.attr("dir", dir);
+            },
+            selectableRelativeToCursor: function selectableRelativeToCursor(delta) {
+                var $selectables, $oldCursor, oldIndex, newIndex;
+                $oldCursor = this.getActiveSelectable();
+                $selectables = this._getSelectables();
+                oldIndex = $oldCursor ? $selectables.index($oldCursor) : -1;
+                newIndex = oldIndex + delta;
+                newIndex = (newIndex + 1) % ($selectables.length + 1) - 1;
+                newIndex = newIndex < -1 ? $selectables.length - 1 : newIndex;
+                return newIndex === -1 ? null : $selectables.eq(newIndex);
+            },
+            setCursor: function setCursor($selectable) {
+                this._removeCursor();
+                if ($selectable = $selectable && $selectable.first()) {
+                    $selectable.addClass(this.classes.cursor);
+                    this._ensureVisible($selectable);
+                }
+            },
+            getSelectableData: function getSelectableData($el) {
+                return $el && $el.length ? Dataset.extractData($el) : null;
+            },
+            getActiveSelectable: function getActiveSelectable() {
+                var $selectable = this._getSelectables().filter(this.selectors.cursor).first();
+                return $selectable.length ? $selectable : null;
+            },
+            getTopSelectable: function getTopSelectable() {
+                var $selectable = this._getSelectables().first();
+                return $selectable.length ? $selectable : null;
+            },
+            update: function update(query) {
+                var isValidUpdate = query !== this.query;
+                if (isValidUpdate) {
+                    this.query = query;
+                    _.each(this.datasets, updateDataset);
+                }
+                return isValidUpdate;
+                function updateDataset(dataset) {
+                    dataset.update(query);
+                }
+            },
+            empty: function empty() {
+                _.each(this.datasets, clearDataset);
+                this.query = null;
+                this.$node.addClass(this.classes.empty);
+                function clearDataset(dataset) {
+                    dataset.clear();
+                }
+            },
+            destroy: function destroy() {
+                this.$node.off(".tt");
+                this.$node = $("<div>");
+                _.each(this.datasets, destroyDataset);
+                function destroyDataset(dataset) {
+                    dataset.destroy();
+                }
+            }
+        });
+        return Menu;
+    }();
+    var DefaultMenu = function() {
+        "use strict";
+        var s = Menu.prototype;
+        function DefaultMenu() {
+            Menu.apply(this, [].slice.call(arguments, 0));
+        }
+        _.mixin(DefaultMenu.prototype, Menu.prototype, {
+            open: function open() {
+                !this._allDatasetsEmpty() && this._show();
+                return s.open.apply(this, [].slice.call(arguments, 0));
+            },
+            close: function close() {
+                this._hide();
+                return s.close.apply(this, [].slice.call(arguments, 0));
+            },
+            _onRendered: function onRendered() {
+                if (this._allDatasetsEmpty()) {
+                    this._hide();
+                } else {
+                    this.isOpen() && this._show();
+                }
+                return s._onRendered.apply(this, [].slice.call(arguments, 0));
+            },
+            _onCleared: function onCleared() {
+                if (this._allDatasetsEmpty()) {
+                    this._hide();
+                } else {
+                    this.isOpen() && this._show();
+                }
+                return s._onCleared.apply(this, [].slice.call(arguments, 0));
+            },
+            setLanguageDirection: function setLanguageDirection(dir) {
+                this.$node.css(dir === "ltr" ? this.css.ltr : this.css.rtl);
+                return s.setLanguageDirection.apply(this, [].slice.call(arguments, 0));
+            },
+            _hide: function hide() {
+                this.$node.hide();
+            },
+            _show: function show() {
+                this.$node.css("display", "block");
+            }
+        });
+        return DefaultMenu;
+    }();
+    var Typeahead = function() {
+        "use strict";
+        function Typeahead(o, www) {
+            var onFocused, onBlurred, onEnterKeyed, onTabKeyed, onEscKeyed, onUpKeyed, onDownKeyed, onLeftKeyed, onRightKeyed, onQueryChanged, onWhitespaceChanged;
+            o = o || {};
+            if (!o.input) {
+                $.error("missing input");
+            }
+            if (!o.menu) {
+                $.error("missing menu");
+            }
+            if (!o.eventBus) {
+                $.error("missing event bus");
+            }
+            www.mixin(this);
+            this.eventBus = o.eventBus;
+            this.minLength = _.isNumber(o.minLength) ? o.minLength : 1;
+            this.input = o.input;
+            this.menu = o.menu;
+            this.enabled = true;
+            this.active = false;
+            this.input.hasFocus() && this.activate();
+            this.dir = this.input.getLangDir();
+            this._hacks();
+            this.menu.bind().onSync("selectableClicked", this._onSelectableClicked, this).onSync("asyncRequested", this._onAsyncRequested, this).onSync("asyncCanceled", this._onAsyncCanceled, this).onSync("asyncReceived", this._onAsyncReceived, this).onSync("datasetRendered", this._onDatasetRendered, this).onSync("datasetCleared", this._onDatasetCleared, this);
+            onFocused = c(this, "activate", "open", "_onFocused");
+            onBlurred = c(this, "deactivate", "_onBlurred");
+            onEnterKeyed = c(this, "isActive", "isOpen", "_onEnterKeyed");
+            onTabKeyed = c(this, "isActive", "isOpen", "_onTabKeyed");
+            onEscKeyed = c(this, "isActive", "_onEscKeyed");
+            onUpKeyed = c(this, "isActive", "open", "_onUpKeyed");
+            onDownKeyed = c(this, "isActive", "open", "_onDownKeyed");
+            onLeftKeyed = c(this, "isActive", "isOpen", "_onLeftKeyed");
+            onRightKeyed = c(this, "isActive", "isOpen", "_onRightKeyed");
+            onQueryChanged = c(this, "_openIfActive", "_onQueryChanged");
+            onWhitespaceChanged = c(this, "_openIfActive", "_onWhitespaceChanged");
+            this.input.bind().onSync("focused", onFocused, this).onSync("blurred", onBlurred, this).onSync("enterKeyed", onEnterKeyed, this).onSync("tabKeyed", onTabKeyed, this).onSync("escKeyed", onEscKeyed, this).onSync("upKeyed", onUpKeyed, this).onSync("downKeyed", onDownKeyed, this).onSync("leftKeyed", onLeftKeyed, this).onSync("rightKeyed", onRightKeyed, this).onSync("queryChanged", onQueryChanged, this).onSync("whitespaceChanged", onWhitespaceChanged, this).onSync("langDirChanged", this._onLangDirChanged, this);
+        }
+        _.mixin(Typeahead.prototype, {
+            _hacks: function hacks() {
+                var $input, $menu;
+                $input = this.input.$input || $("<div>");
+                $menu = this.menu.$node || $("<div>");
+                $input.on("blur.tt", function($e) {
+                    var active, isActive, hasActive;
+                    active = document.activeElement;
+                    isActive = $menu.is(active);
+                    hasActive = $menu.has(active).length > 0;
+                    if (_.isMsie() && (isActive || hasActive)) {
+                        $e.preventDefault();
+                        $e.stopImmediatePropagation();
+                        _.defer(function() {
+                            $input.focus();
+                        });
+                    }
+                });
+                $menu.on("mousedown.tt", function($e) {
+                    $e.preventDefault();
+                });
+            },
+            _onSelectableClicked: function onSelectableClicked(type, $el) {
+                this.select($el);
+            },
+            _onDatasetCleared: function onDatasetCleared() {
+                this._updateHint();
+            },
+            _onDatasetRendered: function onDatasetRendered(type, dataset, suggestions, async) {
+                this._updateHint();
+                this.eventBus.trigger("render", suggestions, async, dataset);
+            },
+            _onAsyncRequested: function onAsyncRequested(type, dataset, query) {
+                this.eventBus.trigger("asyncrequest", query, dataset);
+            },
+            _onAsyncCanceled: function onAsyncCanceled(type, dataset, query) {
+                this.eventBus.trigger("asynccancel", query, dataset);
+            },
+            _onAsyncReceived: function onAsyncReceived(type, dataset, query) {
+                this.eventBus.trigger("asyncreceive", query, dataset);
+            },
+            _onFocused: function onFocused() {
+                this._minLengthMet() && this.menu.update(this.input.getQuery());
+            },
+            _onBlurred: function onBlurred() {
+                if (this.input.hasQueryChangedSinceLastFocus()) {
+                    this.eventBus.trigger("change", this.input.getQuery());
+                }
+            },
+            _onEnterKeyed: function onEnterKeyed(type, $e) {
+                var $selectable;
+                if ($selectable = this.menu.getActiveSelectable()) {
+                    this.select($selectable) && $e.preventDefault();
+                }
+            },
+            _onTabKeyed: function onTabKeyed(type, $e) {
+                var $selectable;
+                if ($selectable = this.menu.getActiveSelectable()) {
+                    this.select($selectable) && $e.preventDefault();
+                } else if ($selectable = this.menu.getTopSelectable()) {
+                    this.autocomplete($selectable) && $e.preventDefault();
+                }
+            },
+            _onEscKeyed: function onEscKeyed() {
+                this.close();
+            },
+            _onUpKeyed: function onUpKeyed() {
+                this.moveCursor(-1);
+            },
+            _onDownKeyed: function onDownKeyed() {
+                this.moveCursor(+1);
+            },
+            _onLeftKeyed: function onLeftKeyed() {
+                if (this.dir === "rtl" && this.input.isCursorAtEnd()) {
+                    this.autocomplete(this.menu.getTopSelectable());
+                }
+            },
+            _onRightKeyed: function onRightKeyed() {
+                if (this.dir === "ltr" && this.input.isCursorAtEnd()) {
+                    this.autocomplete(this.menu.getTopSelectable());
+                }
+            },
+            _onQueryChanged: function onQueryChanged(e, query) {
+                this._minLengthMet(query) ? this.menu.update(query) : this.menu.empty();
+            },
+            _onWhitespaceChanged: function onWhitespaceChanged() {
+                this._updateHint();
+            },
+            _onLangDirChanged: function onLangDirChanged(e, dir) {
+                if (this.dir !== dir) {
+                    this.dir = dir;
+                    this.menu.setLanguageDirection(dir);
+                }
+            },
+            _openIfActive: function openIfActive() {
+                this.isActive() && this.open();
+            },
+            _minLengthMet: function minLengthMet(query) {
+                query = _.isString(query) ? query : this.input.getQuery() || "";
+                return query.length >= this.minLength;
+            },
+            _updateHint: function updateHint() {
+                var $selectable, data, val, query, escapedQuery, frontMatchRegEx, match;
+                $selectable = this.menu.getTopSelectable();
+                data = this.menu.getSelectableData($selectable);
+                val = this.input.getInputValue();
+                if (data && !_.isBlankString(val) && !this.input.hasOverflow()) {
+                    query = Input.normalizeQuery(val);
+                    escapedQuery = _.escapeRegExChars(query);
+                    frontMatchRegEx = new RegExp("^(?:" + escapedQuery + ")(.+$)", "i");
+                    match = frontMatchRegEx.exec(data.val);
+                    match && this.input.setHint(val + match[1]);
+                } else {
+                    this.input.clearHint();
+                }
+            },
+            isEnabled: function isEnabled() {
+                return this.enabled;
+            },
+            enable: function enable() {
+                this.enabled = true;
+            },
+            disable: function disable() {
+                this.enabled = false;
+            },
+            isActive: function isActive() {
+                return this.active;
+            },
+            activate: function activate() {
+                if (this.isActive()) {
+                    return true;
+                } else if (!this.isEnabled() || this.eventBus.before("active")) {
+                    return false;
+                } else {
+                    this.active = true;
+                    this.eventBus.trigger("active");
+                    return true;
+                }
+            },
+            deactivate: function deactivate() {
+                if (!this.isActive()) {
+                    return true;
+                } else if (this.eventBus.before("idle")) {
+                    return false;
+                } else {
+                    this.active = false;
+                    this.close();
+                    this.eventBus.trigger("idle");
+                    return true;
+                }
+            },
+            isOpen: function isOpen() {
+                return this.menu.isOpen();
+            },
+            open: function open() {
+                if (!this.isOpen() && !this.eventBus.before("open")) {
+                    this.menu.open();
+                    this._updateHint();
+                    this.eventBus.trigger("open");
+                }
+                return this.isOpen();
+            },
+            close: function close() {
+                if (this.isOpen() && !this.eventBus.before("close")) {
+                    this.menu.close();
+                    this.input.clearHint();
+                    this.input.resetInputValue();
+                    this.eventBus.trigger("close");
+                }
+                return !this.isOpen();
+            },
+            setVal: function setVal(val) {
+                this.input.setQuery(_.toStr(val));
+            },
+            getVal: function getVal() {
+                return this.input.getQuery();
+            },
+            select: function select($selectable) {
+                var data = this.menu.getSelectableData($selectable);
+                if (data && !this.eventBus.before("select", data.obj)) {
+                    this.input.setQuery(data.val, true);
+                    this.eventBus.trigger("select", data.obj);
+                    this.close();
+                    return true;
+                }
+                return false;
+            },
+            autocomplete: function autocomplete($selectable) {
+                var query, data, isValid;
+                query = this.input.getQuery();
+                data = this.menu.getSelectableData($selectable);
+                isValid = data && query !== data.val;
+                if (isValid && !this.eventBus.before("autocomplete", data.obj)) {
+                    this.input.setQuery(data.val);
+                    this.eventBus.trigger("autocomplete", data.obj);
+                    return true;
+                }
+                return false;
+            },
+            moveCursor: function moveCursor(delta) {
+                var query, $candidate, data, payload, cancelMove;
+                query = this.input.getQuery();
+                $candidate = this.menu.selectableRelativeToCursor(delta);
+                data = this.menu.getSelectableData($candidate);
+                payload = data ? data.obj : null;
+                cancelMove = this._minLengthMet() && this.menu.update(query);
+                if (!cancelMove && !this.eventBus.before("cursorchange", payload)) {
+                    this.menu.setCursor($candidate);
+                    if (data) {
+                        this.input.setInputValue(data.val);
+                    } else {
+                        this.input.resetInputValue();
+                        this._updateHint();
+                    }
+                    this.eventBus.trigger("cursorchange", payload);
+                    return true;
+                }
+                return false;
+            },
+            destroy: function destroy() {
+                this.input.destroy();
+                this.menu.destroy();
+            }
+        });
+        return Typeahead;
+        function c(ctx) {
+            var methods = [].slice.call(arguments, 1);
+            return function() {
+                var args = [].slice.call(arguments);
+                _.each(methods, function(method) {
+                    return ctx[method].apply(ctx, args);
+                });
+            };
+        }
+    }();
+    (function() {
+        "use strict";
+        var old, keys, methods;
+        old = $.fn.typeahead;
+        keys = {
+            www: "tt-www",
+            attrs: "tt-attrs",
+            typeahead: "tt-typeahead"
+        };
+        methods = {
+            initialize: function initialize(o, datasets) {
+                var www;
+                datasets = _.isArray(datasets) ? datasets : [].slice.call(arguments, 1);
+                o = o || {};
+                www = WWW(o.classNames);
+                return this.each(attach);
+                function attach() {
+                    var $input, $wrapper, $hint, $menu, defaultHint, defaultMenu, eventBus, input, menu, typeahead, MenuConstructor;
+                    _.each(datasets, function(d) {
+                        d.highlight = !!o.highlight;
+                    });
+                    $input = $(this);
+                    $wrapper = $(www.html.wrapper);
+                    $hint = $elOrNull(o.hint);
+                    $menu = $elOrNull(o.menu);
+                    defaultHint = o.hint !== false && !$hint;
+                    defaultMenu = o.menu !== false && !$menu;
+                    defaultHint && ($hint = buildHintFromInput($input, www));
+                    defaultMenu && ($menu = $(www.html.menu).css(www.css.menu));
+                    $hint && $hint.val("");
+                    $input = prepInput($input, www);
+                    if (defaultHint || defaultMenu) {
+                        $wrapper.css(www.css.wrapper);
+                        $input.css(defaultHint ? www.css.input : www.css.inputWithNoHint);
+                        $input.wrap($wrapper).parent().prepend(defaultHint ? $hint : null).append(defaultMenu ? $menu : null);
+                    }
+                    MenuConstructor = defaultMenu ? DefaultMenu : Menu;
+                    eventBus = new EventBus({
+                        el: $input
+                    });
+                    input = new Input({
+                        hint: $hint,
+                        input: $input
+                    }, www);
+                    menu = new MenuConstructor({
+                        node: $menu,
+                        datasets: datasets
+                    }, www);
+                    typeahead = new Typeahead({
+                        input: input,
+                        menu: menu,
+                        eventBus: eventBus,
+                        minLength: o.minLength
+                    }, www);
+                    $input.data(keys.www, www);
+                    $input.data(keys.typeahead, typeahead);
+                }
+            },
+            isEnabled: function isEnabled() {
+                var enabled;
+                ttEach(this.first(), function(t) {
+                    enabled = t.isEnabled();
+                });
+                return enabled;
+            },
+            enable: function enable() {
+                ttEach(this, function(t) {
+                    t.enable();
+                });
+                return this;
+            },
+            disable: function disable() {
+                ttEach(this, function(t) {
+                    t.disable();
+                });
+                return this;
+            },
+            isActive: function isActive() {
+                var active;
+                ttEach(this.first(), function(t) {
+                    active = t.isActive();
+                });
+                return active;
+            },
+            activate: function activate() {
+                ttEach(this, function(t) {
+                    t.activate();
+                });
+                return this;
+            },
+            deactivate: function deactivate() {
+                ttEach(this, function(t) {
+                    t.deactivate();
+                });
+                return this;
+            },
+            isOpen: function isOpen() {
+                var open;
+                ttEach(this.first(), function(t) {
+                    open = t.isOpen();
+                });
+                return open;
+            },
+            open: function open() {
+                ttEach(this, function(t) {
+                    t.open();
+                });
+                return this;
+            },
+            close: function close() {
+                ttEach(this, function(t) {
+                    t.close();
+                });
+                return this;
+            },
+            select: function select(el) {
+                var success = false, $el = $(el);
+                ttEach(this.first(), function(t) {
+                    success = t.select($el);
+                });
+                return success;
+            },
+            autocomplete: function autocomplete(el) {
+                var success = false, $el = $(el);
+                ttEach(this.first(), function(t) {
+                    success = t.autocomplete($el);
+                });
+                return success;
+            },
+            moveCursor: function moveCursoe(delta) {
+                var success = false;
+                ttEach(this.first(), function(t) {
+                    success = t.moveCursor(delta);
+                });
+                return success;
+            },
+            val: function val(newVal) {
+                var query;
+                if (!arguments.length) {
+                    ttEach(this.first(), function(t) {
+                        query = t.getVal();
+                    });
+                    return query;
+                } else {
+                    ttEach(this, function(t) {
+                        t.setVal(newVal);
+                    });
+                    return this;
+                }
+            },
+            destroy: function destroy() {
+                ttEach(this, function(typeahead, $input) {
+                    revert($input);
+                    typeahead.destroy();
+                });
+                return this;
+            }
+        };
+        $.fn.typeahead = function(method) {
+            if (methods[method]) {
+                return methods[method].apply(this, [].slice.call(arguments, 1));
+            } else {
+                return methods.initialize.apply(this, arguments);
+            }
+        };
+        $.fn.typeahead.noConflict = function noConflict() {
+            $.fn.typeahead = old;
+            return this;
+        };
+        function ttEach($els, fn) {
+            $els.each(function() {
+                var $input = $(this), typeahead;
+                (typeahead = $input.data(keys.typeahead)) && fn(typeahead, $input);
+            });
+        }
+        function buildHintFromInput($input, www) {
+            return $input.clone().addClass(www.classes.hint).removeData().css(www.css.hint).css(getBackgroundStyles($input)).prop("readonly", true).removeAttr("id name placeholder required").attr({
+                autocomplete: "off",
+                spellcheck: "false",
+                tabindex: -1
+            });
+        }
+        function prepInput($input, www) {
+            $input.data(keys.attrs, {
+                dir: $input.attr("dir"),
+                autocomplete: $input.attr("autocomplete"),
+                spellcheck: $input.attr("spellcheck"),
+                style: $input.attr("style")
+            });
+            $input.addClass(www.classes.input).attr({
+                autocomplete: "off",
+                spellcheck: false
+            });
+            try {
+                !$input.attr("dir") && $input.attr("dir", "auto");
+            } catch (e) {}
+            return $input;
+        }
+        function getBackgroundStyles($el) {
+            return {
+                backgroundAttachment: $el.css("background-attachment"),
+                backgroundClip: $el.css("background-clip"),
+                backgroundColor: $el.css("background-color"),
+                backgroundImage: $el.css("background-image"),
+                backgroundOrigin: $el.css("background-origin"),
+                backgroundPosition: $el.css("background-position"),
+                backgroundRepeat: $el.css("background-repeat"),
+                backgroundSize: $el.css("background-size")
+            };
+        }
+        function revert($input) {
+            var www, $wrapper;
+            www = $input.data(keys.www);
+            $wrapper = $input.parent().filter(www.selectors.wrapper);
+            _.each($input.data(keys.attrs), function(val, key) {
+                _.isUndefined(val) ? $input.removeAttr(key) : $input.attr(key, val);
+            });
+            $input.removeData(keys.typeahead).removeData(keys.www).removeData(keys.attr).removeClass(www.classes.input);
+            if ($wrapper.length) {
+                $input.detach().insertAfter($wrapper);
+                $wrapper.remove();
+            }
+        }
+        function $elOrNull(obj) {
+            var isValid, $el;
+            isValid = _.isJQuery(obj) || _.isElement(obj);
+            $el = isValid ? $(obj).first() : [];
+            return $el.length ? $el : null;
+        }
+    })();
+});
\ No newline at end of file
diff --git a/src/static/typeahead/typeahead.css b/src/static/typeahead/typeahead.css
new file mode 100644
index 0000000000..64c10736a9
--- /dev/null
+++ b/src/static/typeahead/typeahead.css
@@ -0,0 +1,93 @@
+span.twitter-typeahead .tt-menu,
+span.twitter-typeahead .tt-dropdown-menu {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  z-index: 1000;
+  display: none;
+  float: left;
+  min-width: 160px;
+  padding: 5px 0;
+  margin: 2px 0 0;
+  list-style: none;
+  font-size: 14px;
+  text-align: left;
+  background-color: #ffffff;
+  border: 1px solid #cccccc;
+  border: 1px solid rgba(0, 0, 0, 0.15);
+  border-radius: 4px;
+  -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
+  box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
+  background-clip: padding-box;
+}
+span.twitter-typeahead .tt-suggestion {
+  display: block;
+  padding: 3px 20px;
+  clear: both;
+  font-weight: normal;
+  line-height: 1.42857143;
+  color: #333333;
+  white-space: nowrap;
+}
+span.twitter-typeahead .tt-suggestion.tt-cursor,
+span.twitter-typeahead .tt-suggestion:hover,
+span.twitter-typeahead .tt-suggestion:focus {
+  color: #ffffff;
+  text-decoration: none;
+  outline: 0;
+  background-color: #337ab7;
+}
+.input-group.input-group-lg span.twitter-typeahead .form-control {
+  height: 46px;
+  padding: 10px 16px;
+  font-size: 18px;
+  line-height: 1.3333333;
+  border-radius: 6px;
+}
+.input-group.input-group-sm span.twitter-typeahead .form-control {
+  height: 30px;
+  padding: 5px 10px;
+  font-size: 12px;
+  line-height: 1.5;
+  border-radius: 3px;
+}
+span.twitter-typeahead {
+  width: 100%;
+}
+.input-group span.twitter-typeahead {
+  display: block !important;
+  height: 34px;
+}
+.input-group span.twitter-typeahead .tt-menu,
+.input-group span.twitter-typeahead .tt-dropdown-menu {
+  top: 32px !important;
+}
+.input-group span.twitter-typeahead:not(:first-child):not(:last-child) .form-control {
+  border-radius: 0;
+}
+.input-group span.twitter-typeahead:first-child .form-control {
+  border-top-left-radius: 4px;
+  border-bottom-left-radius: 4px;
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.input-group span.twitter-typeahead:last-child .form-control {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+  border-top-right-radius: 4px;
+  border-bottom-right-radius: 4px;
+}
+.input-group.input-group-sm span.twitter-typeahead {
+  height: 30px;
+}
+.input-group.input-group-sm span.twitter-typeahead .tt-menu,
+.input-group.input-group-sm span.twitter-typeahead .tt-dropdown-menu {
+  top: 30px !important;
+}
+.input-group.input-group-lg span.twitter-typeahead {
+  height: 46px;
+}
+.input-group.input-group-lg span.twitter-typeahead .tt-menu,
+.input-group.input-group-lg span.twitter-typeahead .tt-dropdown-menu {
+  top: 46px !important;
+}
diff --git a/src/tests/plugins/banktransfer/test_import.py b/src/tests/plugins/banktransfer/test_import.py
index 77624d605d..0385252690 100644
--- a/src/tests/plugins/banktransfer/test_import.py
+++ b/src/tests/plugins/banktransfer/test_import.py
@@ -8,6 +8,8 @@ from django.utils.timezone import now
 from pretix.base.models import (
     Event, EventPermission, Item, Order, OrderPosition, Organizer, Quota, User,
 )
+from pretix.plugins.banktransfer.models import BankImportJob
+from pretix.plugins.banktransfer.tasks import process_banktransfers
 
 
 @pytest.fixture
@@ -20,7 +22,7 @@ def env():
     user = User.objects.create_user('dummy@dummy.dummy', 'dummy')
     EventPermission.objects.create(user=user, event=event)
     o1 = Order.objects.create(
-        code='1234S', event=event,
+        code='1Z3AS', event=event,
         status=Order.STATUS_PENDING,
         datetime=now(), expires=now() + timedelta(days=10),
         total=23, payment_provider='banktransfer'
@@ -77,47 +79,57 @@ Buchungstag;Valuta;Buchungstext;Auftraggeber / Empfänger;Verwendungszweck;Betra
     for inp in doc.select("input[type=hidden]"):
         data[inp.attrs['name']] = inp.attrs['value']
     r = client.post('/control/event/dummy/dummy/banktransfer/import/', data)
-    doc = BeautifulSoup(r.content)
-    assert r.status_code == 200
-    assert len(doc.select("form table tbody tr")) == 6
-    trs = doc.select("form table tbody tr")
-    assert trs[0].select("td")[0].text == "09.04.2015"
-    assert trs[0].select("td")[1].text == "Bestellung 2015ABCDE"
-    assert trs[0].select("td")[2].text == "23.00"
-    assert trs[0].select("td")[3].text == "Karl Kunde"
-    assert trs[0].select("td")[5].text == "No order code detected"
-    assert trs[1].select("td")[0].text == "09.04.2015"
-    assert trs[1].select("td")[1].text == "Bestellung DUMMYFGHIJ"
-    assert trs[1].select("td")[2].text == "42.00"
-    assert trs[1].select("td")[3].text == "Karla Kundin"
-    assert trs[1].select("td")[5].text == "Unknown order code detected"
-    assert trs[2].select("td")[0].text == "09.04.2015"
-    assert trs[2].select("td")[1].text == "Bestellung DUMMY1234S"
-    assert trs[2].select("td")[2].text == "42.00"
-    assert trs[2].select("td")[3].text == "Karla Kundin"
-    assert trs[2].select("td")[5].text == "Found wrong amount. Expected: 23.00"
-    assert trs[3].select("td")[0].text == "09.04.2015"
-    assert trs[3].select("td")[1].text == "Bestellung DUMMY1234S"
-    assert trs[3].select("td")[2].text == "23.00"
-    assert trs[3].select("td")[3].text == "Karla Kundin"
-    assert trs[3].select("td")[5].text == "Valid payment"
-    assert trs[4].select("td")[0].text == "09.04.2015"
-    assert trs[4].select("td")[1].text == "Bestellung DUMMY6789Z"
-    assert trs[4].select("td")[2].text == "23.00"
-    assert trs[4].select("td")[3].text == "Karla Kundin"
-    assert trs[4].select("td")[5].text == "Order has been cancelled"
-    assert trs[5].select("td")[0].text == "09.04.2015"
-    # Test "autocorrection"
-    assert trs[5].select("td")[1].text == "Bestellung DUMMY65892"
-    assert trs[5].select("td")[2].text == "23.00"
-    assert trs[5].select("td")[3].text == "Karla Kundin"
-    assert "GS89Z" in trs[5].select("td")[4].text
-    assert trs[5].select("td")[5].text == "Order has been cancelled"
+    assert '/job/' in r['Location']
 
-    data = {}
-    for inp in doc.select("form input"):
-        data[inp.attrs['name']] = inp.attrs['value']
-    client.post('/control/event/dummy/dummy/banktransfer/import/', data)
 
-    assert Order.objects.get(id=env[2].id).status == Order.STATUS_PAID
-    assert Order.objects.get(id=env[3].id).status == Order.STATUS_CANCELLED
+@pytest.fixture
+def job(env):
+    return BankImportJob.objects.create(event=env[0]).pk
+
+
+@pytest.mark.django_db
+def test_mark_paid(env, job):
+    process_banktransfers(env[0].pk, job, [{
+        'payer': 'Karla Kundin',
+        'reference': 'Bestellung DUMMY1234S',
+        'date': '2016-01-26',
+        'amount': '23.00'
+    }])
+    env[2].refresh_from_db()
+    assert env[2].status == Order.STATUS_PAID
+
+
+@pytest.mark.django_db
+def test_check_amount(env, job):
+    process_banktransfers(env[0].pk, job, [{
+        'payer': 'Karla Kundin',
+        'reference': 'Bestellung DUMMY1Z3AS',
+        'date': '2016-01-26',
+        'amount': '23.50'
+    }])
+    env[2].refresh_from_db()
+    assert env[2].status == Order.STATUS_PENDING
+
+
+@pytest.mark.django_db
+def test_ignore_cancelled(env, job):
+    process_banktransfers(env[0].pk, job, [{
+        'payer': 'Karla Kundin',
+        'reference': 'Bestellung DUMMY6789Z',
+        'date': '2016-01-26',
+        'amount': '23.00'
+    }])
+    env[3].refresh_from_db()
+    assert env[3].status == Order.STATUS_CANCELLED
+
+
+@pytest.mark.django_db
+def test_autocorrection(env, job):
+    process_banktransfers(env[0].pk, job, [{
+        'payer': 'Karla Kundin',
+        'reference': 'Bestellung DUMMY12345',
+        'amount': '23.00',
+        'date': '2016-01-26',
+    }])
+    env[2].refresh_from_db()
+    assert env[2].status == Order.STATUS_PAID