src/representatives_positions/models.py

+from django.db import models
+from django.template.defaultfilters import truncatewords
+from representatives.models import Representative
+
+
+KIND_CHOICES = (
+    ('other', 'Other'),
+    ('blog', 'Blog post'),
+    ('social', 'Social network'),
+    ('press', 'Press interview'),
+    ('parliament', 'Parliament debate'),
+    ('amendment', 'Amendment'),
+)
+
+
+class Position(models.Model):
+    representatives = models.ManyToManyField(Representative,
+                                             related_name='positions')
+    datetime = models.DateField()
+    kind = models.CharField(max_length=64, choices=KIND_CHOICES,
+                            default='other')
+    title = models.CharField(max_length=500, null=True)
+    text = models.TextField()
+    link = models.URLField(max_length=500)
+    score = models.IntegerField(default=0)
+    published = models.BooleanField(default=False)
+
+    @property
+    def short_title(self):
+        return truncatewords(self.title, 5)
+
+    @property
+    def short_text(self):
+        return truncatewords(self.text, 5)
+
+    def publish(self):
+        self.published = True
+
+    def unpublish(self):
+        self.published = False

src/representatives_positions/templatetags/representatives_positions_tags.py

+from datetime import timedelta
+from datetime import date
+
+from django import template
+
+register = template.Library()
+
+
+@register.filter
+def regroup_by_age(positions):
+    """
+    Returns a list of lists
+    """
+    timeframes = [[],  # Before
+                  [],  # Last year
+                  [],  # Last 6 months
+                  []]  # This month
+    for position in positions:
+        index = 0
+        if position.datetime + timedelta(30) >= date.today():
+            index = 3
+        elif position.datetime + timedelta(180) >= date.today():
+            index = 2
+        elif position.datetime + timedelta(365) >= date.today():
+            index = 1
+
+        timeframes[index].append(position)
+
+    return timeframes

src/representatives_positions/views.py

+from django.views import generic
+from django.views.decorators.csrf import csrf_exempt
+from django.utils.decorators import method_decorator
+
+from .forms import PositionForm
+
+
+class PositionFormMixin(generic.View):
+    """
+    Mixin for class views that handle a position form (should be all full-page
+    views, ie. all template views that use a templates that extends base.html).
+
+    We don't use a FormView here to allow usage of this mixin in views that
+    have their own form.
+    """
+
+    position_form = None
+    position_created = False
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(PositionFormMixin, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        if 'position-representatives' in request.POST:
+            self.position_form = PositionForm(request.POST, prefix='position')
+            if self.position_form.is_valid():
+                self.position_form.save()
+                self.position_form = None
+                self.position_created = True
+
+        return self.get(request, args, kwargs)
+
+    def get_context_data(self, **kwargs):
+        c = super(PositionFormMixin, self).get_context_data(**kwargs)
+
+        c['position_form'] = \
+            self.position_form or PositionForm(prefix='position')
+        c['position_created'] = self.position_created
+
+        return c

src/representatives_recommendations/admin.py

+# coding: utf-8
+from __future__ import absolute_import
+
+from django.contrib import admin
+
+from .forms import RecommendationForm
+from .models import Recommendation
+
+
+class RecommendationsAdmin(admin.ModelAdmin):
+    list_display = ('id', 'title', 'proposal', 'recommendation', 'weight')
+    search_fields = ('title', 'description', 'proposal__title',
+                     'proposal__dossier__title')
+    form = RecommendationForm
+
+
+admin.site.register(Recommendation, RecommendationsAdmin)

src/representatives_recommendations/api.py

+from rest_framework import (
+    filters,
+    viewsets,
+)
+
+from rql_filter.backend import RQLFilterBackend
+
+from representatives.api import DefaultWebPagination
+
+from .models import Recommendation
+
+from .serializers import RecommendationSerializer
+
+
+class RecommendationViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    API endpoint that allows recommendations to be viewed.
+    """
+    queryset = Recommendation.objects.select_related('proposal') \
+                                     .order_by('proposal_id', 'id')
+    filter_backends = (
+        filters.DjangoFilterBackend,
+        filters.SearchFilter,
+        filters.OrderingFilter,
+        RQLFilterBackend
+    )
+    filter_fields = {
+        'id': ['exact'],
+        'recommendation': ['exact'],
+        'title': ['exact', 'icontains'],
+        'description': ['exact', 'icontains'],
+        'weight': ['exact', 'gte', 'lte']
+    }
+    search_fields = ('title', 'description')
+    ordering_fields = ('id', 'weight', 'title')
+    pagination_class = DefaultWebPagination
+    serializer_class = RecommendationSerializer

src/representatives_recommendations/contrib/import_data.py

+# coding: utf-8
+# flake8: noqa
+
+dossier_mappings = {
+    # Patent law: patentability of computer-implemented inventions
+    "Directive on patentability of \"computer-implemented inventions\" (software patents), 1st reading":
+        "2002/0047(COD)",
+
+    # Criminal measures aimed at ensuring the enforcement of intellectual property rights
+    "Criminal measures aimed at ensuring the enforcement of intellectual property rights (IPRED 2), 1st reading":
+        "2005/0127(COD)",
+
+    # Electronic communications: common regulatory framework for networks and services, access, interconnection and authorisation ['Telecoms Package' (amend. Directives 2002/19/EC, 2002/20/EC and 2002/21/EC)]
+    "Directives reforming the EU's regulatory framework for electronic communications networks and services (telecoms package), 1st reading":
+        "2007/0247(COD)",
+
+    "Directives reforming the EU's regulatory framework for electronic communications networks and services (telecoms package), 2nd reading":
+        "2007/0247(COD)",
+
+    # Cultural industries in Europe
+    "Rapport Bono on cultural industries in Europe":
+        "2007/2153(INI)",
+
+    # Strengthening security and fundamental freedoms on the Internet
+    "Rapport Lambrinidis on strengthening security and fundamental freedoms on the Internet":
+        "2008/2160(INI)",
+
+    # Enforcement of intellectual property rights in the internal market
+    "Rapport Gallo on enforcement of intellectual property rights in the internal market":
+        "2009/2178(INI)",
+
+    # Resolution on the Anti-Counterfeiting Trade Agreement (ACTA)
+    "Resolution on Anti-Counterfeiting Trade Agreement (ACTA)":
+        "2010/2935(RSP)",
+
+    # Enhanced cooperation in the area of the creation of unitary patent protection: implementation
+    "A7-0001/2012":
+        "2011/0093(COD)",
+
+    # EU/Australia, Canada, Japan, Korea, Mexico, Morocco, New Zealand, Singapore, Switzerland and United States Anti-Counterfeiting Trade Agreement (ACTA)
+    "A7-0204/2012":
+        "2011/0167(NLE)",
+}
+
+resolutions = [
+    u'résolution législative',
+    u'résolution',
+    'legislative resolution',
+    'resolution'
+]

src/representatives_recommendations/contrib/import_recommendations.py

+# coding: utf-8
+
+import csv
+import django
+from django.apps import apps
+import logging
+import sys
+
+from representatives_recommendations.models import Recommendation
+from representatives_votes.models import Dossier, Proposal
+
+from .import_data import dossier_mappings, resolutions
+
+logger = logging.getLogger(__name__)
+
+
+class RecommendationImporter:
+    def __init__(self):
+        self.dossier_cache = {}
+
+    def get_dossier(self, title):
+        dossier = self.dossier_cache.get(title, None)
+
+        if dossier is None:
+            ref = dossier_mappings.get(title, None)
+            if ref is not None:
+                query = {'reference': ref}
+            else:
+                query = {'title__iexact': title}
+
+            try:
+                dossier = Dossier.objects.get(**query)
+                self.dossier_cache[title] = dossier
+            except Dossier.DoesNotExist:
+                dossier = None
+
+        return dossier
+
+    def get_proposal(self, dossier, kind):
+        kinds = [kind]
+
+        try:
+            resolutions.index(kind.lower())
+            kinds.extend(resolutions)
+        except ValueError:
+            pass
+
+        for k in kinds:
+            try:
+                return Proposal.objects.get(dossier=dossier, kind__iexact=k)
+            except Proposal.DoesNotExist:
+                continue
+
+        return None
+
+    def import_row(self, row):
+        try:
+            dossier = self.get_dossier(row['title'])
+            if dossier is None:
+                logger.warn('No dossier "%s"' % row['title'])
+                return False
+
+            proposal = self.get_proposal(dossier, row['part'])
+            if proposal is None:
+                logger.warn('No proposal "%s" for dossier %s (%d): "%s"' % (
+                    row['part'].decode('utf-8'), dossier.reference, dossier.pk,
+                    row['title']))
+                return False
+
+            weight = int(row['weight']) * int(row['ponderation'])
+            descr = row['description'].strip()
+            if len(descr) == 0:
+                descr = '%s on %s' % (row['part'], dossier.reference)
+
+            try:
+                recom = Recommendation.objects.get(proposal=proposal)
+            except Recommendation.DoesNotExist:
+                recom = Recommendation(
+                    proposal=proposal,
+                    recommendation=row['recommendation'],
+                    title=descr,
+                    weight=weight
+                )
+                recom.save()
+                logger.info('Created recommendation with weight %s for %s: %s'
+                            % (
+                                weight,
+                                row['title'],
+                                row['part']
+                            ))
+
+            return True
+        except Exception:
+            logger.exception('error trying to import recommendation %s',
+                             str(row))
+            return False
+
+
+def main(stream=None):
+    """
+    Imports recommendations from an old memopol instance.
+
+    Usage:
+        cat recommendations.csv | memopol_import_recommendations
+
+    The input CSV file should be generated by the following query:
+        SELECT CONCAT(r.description, '|', r.weight, '|', r.recommendation, '|',
+            r.part, '|', p.title, '|', p.ponderation)
+        FROM votes_recommendation r
+            LEFT JOIN votes_proposal p ON r.proposal_id = p.id
+        WHERE p.institution = 'EU'
+
+    """
+
+    if not apps.ready:
+        django.setup()
+
+    importer = RecommendationImporter()
+    rejected = []
+    imported = 0
+
+    reader = csv.DictReader(stream or sys.stdin, delimiter='|', fieldnames=[
+        'description',
+        'weight',
+        'recommendation',
+        'part',
+        'title',
+        'ponderation'
+    ], quoting=csv.QUOTE_NONE)
+
+    for row in reader:
+        if not importer.import_row(row):
+            rejected.append(row)
+        else:
+            imported = imported + 1
+
+    logger.info('%d rows imported, %d rows rejected', imported, len(rejected))

src/representatives_recommendations/forms.py

+from dal import autocomplete
+
+from django import forms
+
+from models import Recommendation
+
+
+class RecommendationForm(forms.ModelForm):
+    class Meta:
+        model = Recommendation
+        fields = '__all__'
+        widgets = {
+            'proposal': autocomplete.ModelSelect2(
+                url='proposal-autocomplete',
+            )
+        }

src/representatives_recommendations/management/commands/remove_proposals_without_recommendation.py

+from representatives.management.remove_command import RemoveCommand
+
+from representatives_votes.models import Proposal
+
+
+class Command(RemoveCommand):
+    conditions = {'recommendation': None}
+    manager = Proposal.objects

src/representatives_recommendations/migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('representatives_votes', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Recommendation',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('recommendation', models.CharField(max_length=10, choices=[(b'abstain', b'abstain'), (b'for', b'for'), (b'against', b'against')])),
+                ('title', models.CharField(max_length=1000, blank=True)),
+                ('description', models.TextField(blank=True)),
+                ('weight', models.FloatField(default=0)),
+                ('proposal', models.OneToOneField(related_name='recommendation', to='representatives_votes.Proposal')),
+            ],
+            options={
+                'ordering': ['proposal__datetime'],
+            },
+        ),
+    ]

src/representatives_recommendations/models.py

+# coding: utf-8
+from django.db import models
+
+from representatives_votes.contrib.parltrack.import_votes import \
+    vote_pre_import
+from representatives_votes.models import Dossier, Proposal, Vote
+
+
+class Recommendation(models.Model):
+    proposal = models.OneToOneField(
+        Proposal,
+        related_name='recommendation'
+    )
+
+    recommendation = models.CharField(max_length=10, choices=Vote.VOTECHOICES)
+    title = models.CharField(max_length=1000, blank=True)
+    description = models.TextField(blank=True)
+    weight = models.FloatField(default=0)
+
+    class Meta:
+        ordering = ['proposal__datetime']
+
+
+def skip_votes(sender, vote_data=None, **kwargs):
+    dossiers = getattr(sender, 'memopol_filters', None)
+
+    if dossiers is None:
+        sender.memopol_filters = dossiers = Dossier.objects.filter(
+            proposals__recommendation__in=Recommendation.objects.all()
+        ).values_list('reference', flat=True)
+
+    if vote_data.get('epref', None) not in dossiers:
+        return False
+
+
+vote_pre_import.connect(skip_votes)

src/representatives_recommendations/serializers.py

+from rest_framework import serializers
+
+from .models import Recommendation
+
+
+class RecommendationSerializer(serializers.HyperlinkedModelSerializer):
+
+    class Meta:
+        model = Recommendation
+        fields = ('recommendation', 'title', 'description', 'weight',
+                  'proposal')
+        extra_kwargs = {
+            'proposal': {'view_name': 'api-proposal-detail'},
+        }