representatives_positions/urls.py

-from django.conf.urls import url
-
-import views
-
-urlpatterns = [
-    url(
-        r'^position/create/$',
-        views.PositionCreate.as_view(),
-        name='position-create'
-    ),
-    url(
-        r'^position/(?P<pk>\d+)/$',
-        views.PositionDetail.as_view(),
-        name='position-detail'
-    ),
-]

representatives_positions/views.py

-from django.views import generic
-from django.db import models
-
-from representatives.views import RepresentativeViewMixin
-from representatives.models import Mandate
-
-from .models import Position
-from .forms import PositionForm
-
-
-class PositionCreate(generic.CreateView):
-    model = Position
-    form_class = PositionForm
-
-    def get_success_url(self):
-        return self.object.representative.get_absolute_url()
-
-
-class PositionDetail(RepresentativeViewMixin, generic.DetailView):
-    queryset = Position.objects.filter(published=True).select_related(
-        'representative__score')
-
-    def get_queryset(self):
-        qs = super(PositionDetail, self).get_queryset()
-        qs = qs.prefetch_related(models.Prefetch(
-            'representative__mandates',
-            Mandate.objects.select_related('constituency__country', 'group')
-        ))
-        return qs
-
-    def get_object(self):
-        obj = super(PositionDetail, self).get_object()
-        self.add_representative_country_and_main_mandate(obj.representative)
-        return obj

representatives_recommendations/templatetags/representatives_recommendations_tags.py

-# coding: utf-8
-from django import template
-from django.utils.safestring import mark_safe
-
-register = template.Library()
-
-
-@register.filter
-def score_label(score):
-    if score > 0:
-        return mark_safe(
-            '<span class="label label-success">{}</span>'.format(score))
-    elif score < 0:
-        return mark_safe(
-            '<span class="label label-danger">{}</span>'.format(score))
-    else:
-        return mark_safe(
-            '<span class="label label-default">{}</span>'.format(score))

setup.py

-from setuptools import setup
+from setuptools import setup, find_packages
 
-setup(name='political-memory',
-    version='0.0.1',
-    description='OpenShift App',
-    packages=['political_memory'],
-    package_dir={'political_memory': '.'},
-    author='James Pic, Laurent Peuch, Arnaud Fabre',
+setup(name='memopol',
+    version='0.0.2',
+    description='Memopol Project',
+    packages=find_packages('src'),
+    package_dir={'': 'src'},
+    include_package_data=True,
+    zip_safe=False,
+    author='James Pic, Laurent Peuch, Arnaud Fabre, Nicolas Joyard',
     author_email='cortex@worlddomination.be',
-    url='http://github.com/political-memory/political_memory/',
+    url='https://git.laquadrature.net/memopol/memopol',
     install_requires=[
-        'django-autocomplete-light>=2.2,<3.0',
-        'django-bootstrap3>=6.2,<6.3',
+        'django-autocomplete-light==3.2.0',
+        'django-autoslug>=1.9,<1.10',
+        'django-bootstrap3>=6,<7',
         'django-coffeescript>=0.7,<0.8',
-        'django-compressor>=1.6,<1.7',
+        'django-compressor>=1,<2',
         'django-datetime-widget>=0.9,<1.0',
-        'django-filter>=0.11,<0.12',
-        'django-representatives>=0.0.6',
-        'django-representatives-votes>=0.0.7',
+        'django-filter>=0.15,<0.16',
+        'django-fontawesome>=0.2,<0.3',
+        'django-rql-filter>=0.1.3,<0.2',
         'django-taggit>=0.17,<0.18',
         'django>=1.8,<1.9',
+        'djangorestframework>=3,<3.5.1',
         'hamlpy>=0.82,<0.83',
         'ijson>=2.2,<2.3',
-        'lesscpy',
         'python-dateutil>=2.4,<2.5',
-        'pytz==2015.7',
-        'django-suit',
+        'unicodecsv>=0.14,<0.15',
+        'pytz',  # Always use up-to-date TZ data
+        'django-suit>=0.2,<0.3',
+        'psycopg2>=2,<3',
+        'django-haystack==2.6.0',
+        'pysolr==3.6.0',
+        'Whoosh==2.7.4',
+        'alabaster==0.7.10',
+        'django-nested-admin==3.0.17',
     ],
     extras_require={
+        # Full version hardcode for testing dependencies so that
+        # tests don't break on master without any obvious reason.
         'testing': [
-            'flake8',
-            'pep8',
-            'pytest',
-            'pytest-django',
-            'pytest-cov',
-            'codecov',
+            'codecov>=2,<3',
+            'flake8>=2,<3',
+            'django-responsediff>=0.7,<0.8',
+            'pep8>=1,<2',
+            'pytest>=2,<3',
+            'pytest-django>=2,<3',
+            'pytest-cov>=2,<3',
+            'mock==2.0.0',
+            'tox>=2.3,<3',
+        ]
+    },
+    entry_points={
+        'console_scripts': [
+            'parltrack_import_representatives = representatives.contrib.parltrack.import_representatives:main',  # noqa
+            'parltrack_import_dossiers = representatives_votes.contrib.parltrack.import_dossiers:main',  # noqa
+            'parltrack_import_votes = representatives_votes.contrib.parltrack.import_votes:main',  # noqa
+            'francedata_import_representatives = representatives.contrib.francedata.import_representatives:main',  # noqa
+            'francedata_import_dossiers = representatives_votes.contrib.francedata.import_dossiers:main',  # noqa
+            'francedata_import_scrutins = representatives_votes.contrib.francedata.import_scrutins:main',  # noqa
+            'francedata_import_votes = representatives_votes.contrib.francedata.import_votes:main',  # noqa
+            'memopol_import_positions = representatives_positions.contrib.import_positions:main',  # noqa
+            'memopol_import_recommendations = representatives_recommendations.contrib.import_recommendations:main',  # noqa
+            'memopol = memopol.manage:main',
         ]
     }
 )

src/core/templates/core/blocks/active-filter.html

+{% block active %}
+  Display :
+  {% if active_only %}
+    current legislature only /
+    <a href="{queries.urlencode}&active_only=0">
+        all data
+    </a>
+  {% else %}
+    <a href="{queries.urlencode}&active_only=1">
+        current legislature only
+    </a>
+    / all data
+  {% endif %}
+{% endblock %}

core/templates/core/blocks/grid-list.haml → src/core/templates/core/blocks/grid-list.haml

 %span.grid-list-selector
-  %a{:href => '?display=grid'}
+  %a{:href => '?={queries.urlencode}&display=grid'}<
     <i class="fa fa-th"></i>
-  %a{:href => '?display=list'}
+  %a{:href => '?={queries.urlencode}&display=list'}<
     <i class="fa fa-th-list"></i>

src/core/templates/core/blocks/pagination.html

+{% block pagination %}
+
+  <nav>
+    <ul class="pagination pagination-sm">
+      {% if page_obj.has_previous %}
+        <li>
+            <a href="{{queries.urlencode}}&page=1" aria-label="First">
+            <i aria-hidden="true" class="fa fa-chevron-circle-left"></i>
+          </a>
+        </li>
+        <li>
+            <a href="{queries.urlencode}&page=={page_obj.previous_page_number}" aria-label="Previous">
+             
+            <i aria-hidden="true" class="fa fa-chevron-left"></i>
+          </a>
+        </li>
+      {% endif %}
+      {% for p in page_range %}
+        {% if p %}
+          {% if p == page_obj.number %}
+            <li class="active">
+              <a href=''>
+                  {{ p }}
+              </a>
+            </li>
+          {% else %}
+            <li>
+              <a href="{queries.urlencode}&page=={p}">
+                  {{ p }}
+              </a>
+            </li>
+          {% endif %}
+        {% endif %}
+      {% endfor %}
+           
+      {% if page_obj.has_next %}
+        <li>
+          <a href=""{queries.urlencode}&page=={page_obj.next_page_number}" aria-label="Next">
+            <i aria-hidden="true" class="fa fa-chevron-right"></i>
+          </a>
+        </li>
+        <li>
+          <a href="{queries.urlencode}&page=={paginator.num_pages}" aria-label="Last">
+            <i aria-hidden="true" class="fa fa-chevron-circle-right"></i>
+          </a>
+        </li>
+        {% endif %}
+    </ul>
+  </nav>
+  <div class=".count">
+    {% block count %}
+      Number of results : {{ paginator.count }}
+
+    {% if active_only != None %}
+      {% include 'core/blocks/active-filter.html' %}
+    {% endif %}
+
+    {% if sort != None %}
+      {% include 'core/blocks/sorting.html' %}
+    {% endif %}
+    {% endblock %}
+
+    {% block page-size %}
+      Number of displayed results :
+      {{ paginator.per_page }}
+      (
+      {% for limit in pagination_limits %}
+        <a href="{queries.urlencode}&paginate_by={{ limit }}">
+          {{ limit }}
+        </a>
+        {% if not forloop.last %}
+          /
+        {% endif %}
+      {% endfor %}
+      )
+      {% if grid_list %}
+        {% include 'core/blocks/grid-list.html' %}
+      {% endif %}
+    {% endblock %}
+  </div>
+
+{% endblock %}

src/core/templates/core/blocks/sorting.haml

+- if sort.fields|length > 0
+  .sorting-block
+    Order by :
+
+      - for field, label in sort.fields.items
+          - if sort.field == field
+            {{ label }}
+          - else
+            %a{'href': '?={queries.urlencode}&sort_by=={field}'}<
+              {{ label }}
+
+          - if not forloop.last
+            =" | "
+
+      &ndash;
+
+      - if sort.dir == 'asc'
+        ascending |
+        %a{'href': '?={queries.urlencode}&sort_dir=desc'}<
+          descending
+      - else
+        %a{'href': '?={queries.urlencode}&sort_dir=asc'}<
+          ascending
+        ="| descending"

src/core/views.py

+# coding: utf-8
+
+from copy import copy
+
+from django import http
+
+import unicodecsv as csv
+
+
+class ThemeSelectionMixin(object):
+    """
+    Mixin for views that allow selecting a theme
+    """
+
+    def get(self, *args, **kwargs):
+        self.set_selected_theme()
+        return super(ThemeSelectionMixin, self).get(*args, **kwargs)
+
+    def set_selected_theme(self):
+        if 'selected_theme' in self.request.GET:
+            theme = self.request.GET['selected_theme']
+            self.request.session['selected_theme'] = \
+                theme if len(theme) else None
+        elif 'selected_theme' not in self.request.session:
+            self.request.session['selected_theme'] = None
+
+    def get_selected_theme(self):
+        if 'selected_theme' in self.request.session:
+            return self.request.session['selected_theme']
+        else:
+            return None
+
+    def get_context_data(self, **kwargs):
+        c = super(ThemeSelectionMixin, self).get_context_data(**kwargs)
+        c['selected_theme'] = self.get_selected_theme()
+        c['theme_querystring'] = copy(self.request.GET)
+        if 'selected_theme' in c['theme_querystring']:
+            del c['theme_querystring']['selected_theme']
+        return c
+
+
+class ActiveLegislatureMixin(object):
+    """
+    Mixin for views that can switch between active legislature and all data
+    """
+
+    default_active_only = True
+
+    def get(self, *args, **kwargs):
+        self.set_active_only()
+        return super(ActiveLegislatureMixin, self).get(*args, **kwargs)
+
+    def override_active_only(self):
+        """
+        Redefine this method to override active legislature selection
+        - return None to enable user choice
+        - return True or False to disable user choice and set active state
+        """
+        return None
+
+    def set_active_only(self):
+        if 'active_only' in self.request.GET:
+            self.request.session['active_only'] = \
+                self.request.GET['active_only'] == '1'
+        elif 'active_only' not in self.request.session:
+            self.request.session['active_only'] = self.default_active_only
+
+    def get_active_only(self):
+        overriden = self.override_active_only()
+        if overriden is None:
+            if 'active_only' in self.request.session:
+                return self.request.session['active_only']
+            else:
+                return self.default_active_only
+        else:
+            return overriden
+
+    def get_context_data(self, **kwargs):
+        c = super(ActiveLegislatureMixin, self).get_context_data(**kwargs)
+        if self.override_active_only() is None:
+            c['active_only'] = self.get_active_only()
+        return c
+
+
+class SortMixin(object):
+    """
+    Mixin for views that allow sorting.
+    The sort_modes attribute should be defined to a dict as such:
+    {
+        'mode1': {
+            'order': 42,
+            'label': 'mode label',
+            'fields': ['-field1', 'field2', ...]
+        },
+        ...
+    }
+
+    The sort_default attribute should contain the default sorting mode.
+    """
+    sort_modes = {}
+    sort_default = None
+    sort_session_prefix = ''
+
+    def get(self, *args, **kwargs):
+        self.set_sorting()
+        return super(SortMixin, self).get(*args, **kwargs)
+
+    def _session_get_sort(self):
+        k = '%s_sort' % self.sort_session_prefix
+        return self.request.session[k]
+
+    def _session_set_sort(self, value):
+        k = '%s_sort' % self.sort_session_prefix
+        self.request.session[k] = value
+
+    def _session_sort_exists(self):
+        k = '%s_sort' % self.sort_session_prefix
+        return k in self.request.session
+
+    def set_sorting(self):
+        if 'sort' in self.request.GET:
+            self._session_set_sort(self.request.GET['sort'])
+        elif not self._session_sort_exists():
+            self._session_set_sort(self.sort_default)
+
+        if self._session_get_sort() not in self.sort_modes:
+            self._session_set_sort(self.sort_default)
+
+    def get_context_data(self, **kwargs):
+        c = super(SortMixin, self).get_context_data(**kwargs)
+
+        c['sort_querystring'] = copy(self.request.GET)
+        if 'sort' in c['sort_querystring']:
+            del c['sort_querystring']['sort']
+
+        c['sort'] = {
+            'modes': [{'id': k, 'label': v['label'], 'order': v['order']}
+                      for k, v in self.sort_modes.iteritems()],
+            'mode': self._session_get_sort()
+        }
+        return c
+
+    def get_queryset(self):
+        qs = super(SortMixin, self).get_queryset()
+        if self._session_get_sort() in self.sort_modes:
+            mode = self.sort_modes[self._session_get_sort()]
+            qs = qs.order_by(*mode['fields'])
+        return qs
+
+
+class PaginationMixin(object):
+    pagination_limits = (12, 24, 48, 96)
+
+    def get(self, *args, **kwargs):
+        self.set_paginate_by()
+        return super(PaginationMixin, self).get(*args, **kwargs)
+
+    def set_paginate_by(self):
+        if 'paginate_by' in self.request.GET:
+            self.request.session['paginate_by'] = \
+                self.request.GET['paginate_by']
+
+        elif 'paginate_by' not in self.request.session:
+            self.request.session['paginate_by'] = 12
+
+    def get_paginate_by(self, queryset):
+        return self.request.session['paginate_by']
+
+    def get_page_range(self, page):
+        pages = []
+
+        if page and page.paginator.num_pages != 1:
+            for i in page.paginator.page_range:
+                if page.number - 4 < i < page.number + 4:
+                    pages.append(i)
+
+        return pages
+
+    def get_context_data(self, **kwargs):
+        c = super(PaginationMixin, self).get_context_data(**kwargs)
+        c['pagination_limits'] = self.pagination_limits
+        c['paginate_by'] = self.request.session['paginate_by']
+        c['page_range'] = self.get_page_range(c['page_obj'])
+        c['pagination_querystring'] = copy(self.request.GET)
+        if 'page' in c['pagination_querystring']:
+            del c['pagination_querystring']['page']
+        return c
+
+
+class GridListMixin(object):
+    def set_session_display(self):
+        if self.request.GET.get('display') in ('grid', 'list'):
+            self.request.session['display'] = self.request.GET.get('display')
+
+        if 'display' not in self.request.session:
+            self.request.session['display'] = 'grid'
+
+    def get(self, *args, **kwargs):
+        self.set_session_display()
+        return super(GridListMixin, self).get(*args, **kwargs)
+
+    def get_template_names(self):
+        return [t.replace('_list', '_%s' % self.request.session['display'])
+                for t in super(GridListMixin, self).get_template_names()]
+
+    def get_context_data(self, **kwargs):
+        c = super(GridListMixin, self).get_context_data(**kwargs)
+        c['grid_list'] = True
+        return c
+
+
+class CSVDownloadMixin(object):
+    def get_context_data(self, **kwargs):
+        c = super(CSVDownloadMixin, self).get_context_data(**kwargs)
+        c['csv'] = True
+        c['csv_querystring'] = copy(self.request.GET)
+        return c
+
+    def get_paginate_by(self, queryset):
+        if self.request.GET.get('csv', None) is None:
+            return super(CSVDownloadMixin, self).get_paginate_by(queryset)
+        return None
+
+    def render_to_csv_response(self, context, **kwargs):
+        response = http.HttpResponse(content_type='text/csv')
+
+        writer = csv.writer(response)
+        for result in self.get_csv_results(context, **kwargs):
+            writer.writerow(self.get_csv_row(result))
+
+        response['Content-Disposition'] = 'attachment; filename="%s.csv"' % (
+            self.csv_name)
+
+        return response
+
+    def render_to_response(self, context, **kwargs):
+        if self.request.GET.get('csv', None) is None:
+            return super(CSVDownloadMixin, self).render_to_response(
+                context, **kwargs)
+
+        return self.render_to_csv_response(context, **kwargs)

src/memopol/api.py

+from rest_framework import routers
+
+from rql_filter.backend import RQLFilterBackend as RQLBackend
+
+from representatives.api import (
+    CountryViewSet,
+    ChamberViewSet,
+    ConstituencyViewSet,
+    GroupViewSet,
+    MandateViewSet,
+    RepresentativeViewSet,
+)
+
+from representatives_votes.api import (
+    DossierViewSet,
+    ProposalViewSet,
+    VoteViewSet,
+)
+
+from representatives_recommendations.api import (
+    RecommendationViewSet
+)
+
+from memopol_themes.api import (
+    ThemeViewSet
+)
+
+from memopol_scores.api import (
+    DossierScoreViewSet,
+    RepresentativeScoreViewSet,
+    ThemeScoreViewSet,
+    VoteScoreViewSet
+)
+
+
+class RQLDossierViewSet(DossierViewSet):
+    filter_backends = DossierViewSet.filter_backends + (RQLBackend,)
+
+
+class RQLProposalViewSet(ProposalViewSet):
+    filter_backends = ProposalViewSet.filter_backends + (RQLBackend,)
+
+
+class RQLVoteViewSet(VoteViewSet):
+    filter_backends = VoteViewSet.filter_backends + (RQLBackend,)
+
+
+router = routers.DefaultRouter()
+
+router.register('countries', CountryViewSet, 'api-country')
+router.register('chambers', ChamberViewSet, 'api-chamber')
+router.register('constituencies', ConstituencyViewSet, 'api-constituency')
+router.register('dossiers', RQLDossierViewSet, 'api-dossier')
+router.register('dossier_scores', DossierScoreViewSet, 'api-dossierscore')
+router.register('groups', GroupViewSet, 'api-group')
+router.register('mandates', MandateViewSet, 'api-mandate')
+router.register('proposals', RQLProposalViewSet, 'api-proposal')
+router.register('recommendations', RecommendationViewSet, 'api-recommendation')
+router.register('representatives', RepresentativeViewSet,
+                'api-representative')
+router.register('scores', RepresentativeScoreViewSet, 'api-score')
+router.register('theme_scores', ThemeScoreViewSet, 'api-themescore')
+router.register('themes', ThemeViewSet, 'api-themes')
+router.register('vote_scores', VoteScoreViewSet, 'api-votescore')
+router.register('votes', RQLVoteViewSet, 'api-vote')

bin/install_client_deps.sh → src/memopol/bin/install_client_deps.sh

@@ -8,7 +8,7 @@
 # starting with 'downloadFromGithub' at the bottom.
 # The last argument is expected to be a git ref (ie
 # a branch name, tag or commit-ish).
-# 
+#
 
 set -e
 
@@ -24,6 +24,10 @@ function downloadFromGithub()
 	local repo=$2
 	local ref=$3
 
+	if [ -d $dest ]; then
+		echo "* $repo ($ref) already downloaded, skipping"
+		return
+	fi
 	echo "* Downloading $repo ($ref) from Github..."
 	wget -O temp.zip -q https://github.com/${repo}/archive/${ref}.zip
 	unzip -q temp.zip
@@ -33,12 +37,12 @@ function downloadFromGithub()
 
 set -e
 
-[ -d ${DEST} ] && rm -r ${DEST}
+if [ -z ${CI-} ]; then
+	[ -d ${DEST} ] && rm -r ${DEST}
+fi
 mkdir -p ${DEST}
 
 downloadFromGithub jquery jquery/jquery 2.1.4
-downloadFromGithub fontawesome FortAwesome/Font-Awesome v4.3.0
 downloadFromGithub flag-icon-css lipis/flag-icon-css 0.7.1
-downloadFromGithub bootstrap twbs/bootstrap v3.3.5
 
 echo "* Done."

src/memopol/context_processors.py

+from .forms import DossierSearchForm, RepresentativeSearchForm
+
+from memopol_settings.models import Setting
+
+
+def search_forms(request):
+    return {
+        'representative_search_form': RepresentativeSearchForm(request.GET),
+        'dossier_search_form': DossierSearchForm(request.GET)
+    }
+
+
+def intro_text(request):
+    d = {}
+
+    for s in Setting.objects.filter(pk__in=['HOMEPAGE_INTRO_TEXT',
+                                            'HOMEPAGE_INSTANCE_TEXT']):
+        d[s.pk] = s.comment
+
+    return d

src/memopol/filters.py

+# coding: utf-8
+
+import datetime
+
+from django.db.models import Q
+from django.utils.text import slugify
+
+from django_filters import FilterSet, MethodFilter
+
+from representatives.models import Representative
+from representatives_votes.models import Dossier
+from memopol_themes.models import Theme
+
+
+class RepresentativeFilter(FilterSet):
+
+    search = MethodFilter(action='search_filter')
+    scoremin = MethodFilter(action='score_min_filter')
+    scoremax = MethodFilter(action='score_max_filter')
+    chamber = MethodFilter(action='chamber_filter')
+    country = MethodFilter(action='group_filter')
+    party = MethodFilter(action='group_filter')
+    delegation = MethodFilter(action='group_filter')
+    committee = MethodFilter(action='group_filter')
+
+    class Meta:
+        model = Representative
+        fields = ['search', 'chamber', 'country', 'party', 'delegation',
+                  'committee']
+
+    def search_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        return qs.filter(slug__icontains=slugify(value))
+
+    def chamber_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        today = datetime.date.today()
+        return qs.filter(
+            Q(mandates__end_date__gte=today) |
+            Q(mandates__end_date__isnull=True),
+            mandates__group__chamber=value
+        )
+
+    def group_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        today = datetime.date.today()
+        return qs.filter(
+            Q(mandates__end_date__gte=today) |
+            Q(mandates__end_date__isnull=True),
+            mandates__group=value
+        )
+
+    def score_min_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        try:
+            return qs.filter(representative_score__score__gte=int(value))
+        except ValueError:
+            return qs
+
+    def score_max_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        try:
+            return qs.filter(representative_score__score__lte=int(value))
+        except ValueError:
+            return qs
+
+
+class DossierFilter(FilterSet):
+
+    search = MethodFilter(action='search_filter')
+    chamber = MethodFilter(action='chamber_filter')
+
+    class Meta:
+        model = Dossier
+        fields = ['search', 'chamber']
+
+    def search_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        return qs.filter(Q(title__icontains=value) |
+                         Q(reference__icontains=value) |
+                         Q(documents__link__icontains=value))
+
+    def chamber_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        return qs.filter(documents__chamber=value)
+
+
+class ThemeFilter(FilterSet):
+
+    search = MethodFilter(action='search_filter')
+
+    class Meta:
+        model = Theme
+        fields = ['search']
+
+    def search_filter(self, qs, value):
+        if len(value) == 0:
+            return qs
+
+        return qs.filter(Q(name__icontains=value) |
+                         Q(description__icontains=value))

src/memopol/forms.py

+from django import forms
+from dal import autocomplete, forward
+
+from representatives.models import Chamber, Group
+
+
+class RepresentativeSearchForm(forms.Form):
+    search = forms.CharField(
+        required=False,
+        label='Name',
+        widget=forms.TextInput(attrs={'placeholder': ''})
+    )
+    scoremin = forms.FloatField(
+        required=False,
+        label='Between',
+        widget=forms.NumberInput(attrs={'placeholder': 'Min. score'})
+    )
+    scoremax = forms.FloatField(
+        required=False,
+        label='and',
+        widget=forms.NumberInput(attrs={'placeholder': 'Max. score'})
+    )
+    chamber = forms.ModelChoiceField(
+        queryset=Chamber.objects.all(),
+        required=False,
+        widget=autocomplete.ModelSelect2(
+            url='chamber-autocomplete',
+            attrs={'data-html': 'true'}
+        )
+    )
+    country = forms.ModelChoiceField(
+        queryset=Group.objects.filter(kind='country'),
+        required=False,
+        widget=autocomplete.ModelSelect2(
+            url='group-autocomplete',
+            forward=(forward.Const('country', 'kind'),),
+            attrs={'data-html': 'true'}
+        )
+    )
+    party = forms.ModelChoiceField(
+        queryset=Group.objects.filter(kind='group'),
+        required=False,
+        widget=autocomplete.ModelSelect2(
+            url='group-autocomplete',
+            forward=(forward.Const('group', 'kind'),),
+            attrs={'data-html': 'true'}
+        )
+    )
+    committee = forms.ModelChoiceField(
+        queryset=Group.objects.filter(kind='committee'),
+        required=False,
+        widget=autocomplete.ModelSelect2(
+            url='group-autocomplete',
+            forward=(forward.Const('committee', 'kind'),),
+            attrs={'data-html': 'true'}
+        )
+    )
+    delegation = forms.ModelChoiceField(
+        queryset=Group.objects.filter(kind='delegation'),
+        required=False,
+        widget=autocomplete.ModelSelect2(
+            url='group-autocomplete',
+            forward=(forward.Const('delegation', 'kind'),),
+            attrs={'data-html': 'true'}
+        )
+    )
+
+
+class DossierSearchForm(forms.Form):
+    search = forms.CharField(
+        required=False,
+        label='Name',
+        widget=forms.TextInput(attrs={'placeholder': ''})
+    )
+    chamber = forms.ModelChoiceField(
+        queryset=Chamber.objects.all(),
+        required=False,
+        widget=autocomplete.ModelSelect2(
+            url='chamber-autocomplete',
+            attrs={'data-html': 'true'}
+        )
+    )

src/memopol/legacy_urls.py

+from django.conf.urls import url
+from django.core.urlresolvers import reverse
+from django.views.generic.base import RedirectView
+
+
+class TabRedirectView(RedirectView):
+    permanent = True
+
+    def get_redirect_url(self, *args, **kwargs):
+        if 'tab' in kwargs:
+            tab = kwargs.pop('tab')
+            return reverse('%s-%s' % (self.pattern_base, tab), args=args,
+                           kwargs=kwargs)
+        else:
+            return reverse('%s-detail' % self.pattern_base, args=args,
+                           kwargs=kwargs)
+
+
+class RepresentativeListRedirect(RedirectView):
+    permanent = True
+    query_string = True
+    pattern_name = 'representative-list'
+
+
+class RepresentativeDetailRedirect(TabRedirectView):
+    pattern_base = 'representative'
+
+
+class DossierListRedirect(RedirectView):
+    permanent = True
+    query_string = True
+    pattern_name = 'dossier-list'
+
+
+class DossierDetailRedirect(TabRedirectView):
+    pattern_base = 'dossier'
+
+
+class ThemeListRedirect(RedirectView):
+    permanent = True
+    query_string = True
+    pattern_name = 'theme-list'
+
+
+class ThemeDetailRedirect(RedirectView):
+    permanent = True
+    pattern_name = 'theme-detail'
+
+
+urlpatterns = [
+    # Representative list
+
+    url(
+        r'^legislature/representative/$',
+        RepresentativeListRedirect.as_view(),
+        name='legacy-representative-list'
+    ),
+
+    # Representative detail
+
+    url(
+        r'^legislature/representative/(?P<slug>[-\w]+)/$',
+        RepresentativeDetailRedirect.as_view(),
+        name='legacy-representative-detail'
+    ),
+
+    url(
+        r'^legislature/representative/(?P<slug>[-\w]+)/(?P<tab>\w+)/$',
+        RepresentativeDetailRedirect.as_view(),
+        name='legacy-representative-detail'
+    ),
+
+    # Dossier list
+
+    url(
+        r'^votes/dossier/$',
+        DossierListRedirect.as_view(),
+        name='legacy-dossier-list'
+    ),
+
+    # Dossier detail
+
+    url(
+        r'^votes/dossier/(?P<pk>\d+)/$',
+        DossierDetailRedirect.as_view(),
+        name='legacy-dossier-detail'
+    ),
+
+    url(
+        r'^votes/dossier/(?P<pk>\d+)/(?P<tab>\w+)/$',
+        DossierDetailRedirect.as_view(),
+        name='legacy-dossier-detail'
+    ),
+
+    # Theme list
+
+    url(
+        r'^theme/$',
+        ThemeListRedirect.as_view(),
+        name='legacy-theme-list'
+    ),
+
+    # Theme detail
+
+    url(
+        r'^theme/(?P<slug>[-\w]+)/$',
+        ThemeDetailRedirect.as_view(),
+        name='legacy-theme-detail'
+    ),
+]