Suggestion feedback and accepting altered suggestions

pootle/apps/pootle_store/forms.py

@@ -37,7 +37,7 @@
 from .form_fields import (
     CategoryChoiceField, ISODateTimeField, MultipleArgsField,
     CommaSeparatedCheckboxSelectMultiple)
-from .models import Unit
+from .models import Unit, Suggestion
 from .util import FUZZY, OBSOLETE, TRANSLATED, UNTRANSLATED
 
 
@@ -259,6 +259,10 @@ class Meta(object):
         )
         similarity = forms.FloatField(required=False)
         mt_similarity = forms.FloatField(required=False)
+        suggestion = forms.ModelChoiceField(
+            queryset=Suggestion.objects.all(),
+            required=False)
+        comment = forms.CharField(required=False)
 
         def __init__(self, *args, **kwargs):
             self.request = kwargs.pop('request', None)
@@ -279,16 +283,42 @@ def clean_target_f(self):
 
             return value
 
-        def clean_state(self):
+        def clean_similarity(self):
+            value = self.cleaned_data['similarity']
+
+            if 0 <= value <= 1 or value is None:
+                return value
+
+            raise forms.ValidationError(
+                _('Value of `similarity` should be in in the [0..1] range')
+            )
+
+        def clean_mt_similarity(self):
+            value = self.cleaned_data['mt_similarity']
+
+            if 0 <= value <= 1 or value is None:
+                return value
+
+            raise forms.ValidationError(
+                _('Value of `mt_similarity` should be in in the [0..1] range')
+            )
+
+        def clean(self):
             old_state = self.instance.state  # Integer
             is_fuzzy = self.cleaned_data['state']  # Boolean
             new_target = self.cleaned_data['target_f']
 
+            # If suggestion is provided set `old_state` should be `TRANSLATED`.
+            if self.cleaned_data['suggestion']:
+                old_state = TRANSLATED
+
             if (self.request is not None and
                 not check_permission('administrate', self.request) and
                 is_fuzzy):
-                raise forms.ValidationError(_('Needs work flag must be '
-                                              'cleared'))
+                self.add_error('state',
+                               forms.ValidationError(
+                                   _('Needs work flag must be '
+                                     'cleared')))
 
             if new_target:
                 if old_state == UNTRANSLATED:
@@ -320,31 +350,12 @@ def clean_state(self):
                 self.updated_fields.append((SubmissionFields.STATE,
                                             old_state, new_state))
 
-                return new_state
-
-            self.instance._state_updated = False
-
-            return old_state
-
-        def clean_similarity(self):
-            value = self.cleaned_data['similarity']
-
-            if 0 <= value <= 1 or value is None:
-                return value
-
-            raise forms.ValidationError(
-                _('Value of `similarity` should be in in the [0..1] range')
-            )
-
-        def clean_mt_similarity(self):
-            value = self.cleaned_data['mt_similarity']
-
-            if 0 <= value <= 1 or value is None:
-                return value
+                self.cleaned_data['state'] = new_state
+            else:
+                self.instance._state_updated = False
+                self.cleaned_data['state'] = old_state
 
-            raise forms.ValidationError(
-                _('Value of `mt_similarity` should be in in the [0..1] range')
-            )
+            return super(UnitForm, self).clean()
 
     return UnitForm
 

pootle/apps/pootle_store/migrations/0008_flush_django_cache.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.core.management import call_command
+from django.db import migrations
+
+
+def flush_django_cache(apps, schema_editor):
+    call_command('flush_cache', '--django-cache')
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('pootle_store', '0007_case_sensitive_schema'),
+    ]
+
+    operations = [
+        migrations.RunPython(flush_django_cache),
+    ]

pootle/apps/pootle_store/unit/timeline.py

@@ -17,11 +17,13 @@
 from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext as _
 
+from pootle_comment import get_model as get_comment_model
 from pootle_misc.checks import check_names
 from pootle_statistics.models import (
     Submission, SubmissionFields, SubmissionTypes)
 
 from pootle_store.fields import to_python
+from pootle_store.models import Suggestion
 from pootle_store.util import STATES_MAP
 
 
@@ -60,24 +62,46 @@ def gravatar_url(self, size=80):
 
 class SuggestionEvent(object):
 
-    def __init__(self, submission_type, username, full_name):
+    def __init__(self, submission_type, username, full_name, comment):
         self.submission_type = submission_type
         self.username = username
         self.full_name = full_name
+        self.comment = comment
 
     @cached_property
     def user(self):
         return DisplayUser(self.username, self.full_name)
 
     @property
     def description(self):
-        author_link = self.user.author_link
+        params = {
+            'author': self.user.author_link
+        }
+        sugg_accepted_desc = _(u'Accepted suggestion from %(author)s', params)
+        sugg_rejected_desc = _(u'Rejected suggestion from %(author)s', params)
+
+        if self.comment:
+            params.update({
+                'comment': format_html(u'<span class="comment">{}</span>',
+                                       self.comment),
+            })
+            sugg_accepted_desc = _(
+                u'Accepted suggestion from %(author)s '
+                u'with comment: %(comment)s',
+                params
+            )
+            sugg_rejected_desc = _(
+                u'Rejected suggestion from %(author)s '
+                u'with comment: %(comment)s',
+                params
+            )
+
         description_dict = {
             SubmissionTypes.SUGG_ADD: _(u'Added suggestion'),
-            SubmissionTypes.SUGG_ACCEPT: _(u'Accepted suggestion from %s',
-                                           author_link),
-            SubmissionTypes.SUGG_REJECT: _(u'Rejected suggestion from %s',
-                                           author_link)}
+            SubmissionTypes.SUGG_ACCEPT: sugg_accepted_desc,
+            SubmissionTypes.SUGG_REJECT: sugg_rejected_desc,
+        }
+
         return description_dict.get(self.submission_type, None)
 
 
@@ -126,6 +150,10 @@ def suggestion_username(self):
     def suggestion_target(self):
         return self.values['suggestion__target_f']
 
+    @property
+    def suggestion_comment(self):
+        return self.values['comment']
+
 
 class TimelineEntry(object):
 
@@ -165,11 +193,15 @@ def state_change_entry(self):
 
     def suggestion_entry(self):
         entry = self.entry_dict
+
         suggestion_description = mark_safe(
             SuggestionEvent(
                 self.submission.type,
                 self.submission.suggestion_username,
-                self.submission.suggestion_full_name).description)
+                self.submission.suggestion_full_name,
+                self.submission.suggestion_comment,
+            ).description
+        )
         entry.update(
             {'suggestion_text': self.submission.suggestion_target,
              'suggestion_description': suggestion_description})
@@ -219,6 +251,29 @@ def submissions(self):
                                        creation_time=self.object.commented_on)
                               .order_by("id"))
 
+    @cached_property
+    def submissions_values(self):
+        return list(self.submissions.values(*self.fields))
+
+    @property
+    def suggestion_ids(self):
+        return list(set([
+            x["suggestion_id"]
+            for x in self.submissions_values
+            if x["suggestion_id"]
+        ]))
+
+    @cached_property
+    def comment_dict(self):
+        Comment = get_comment_model()
+        return dict([
+            # we need convert `object_pk` because it is TextField
+            (int(x[0]), x[1])
+            for x in Comment.objects.for_model(Suggestion)
+                                    .filter(object_pk__in=self.suggestion_ids)
+                                    .values_list("object_pk", "comment")
+        ])
+
     def add_creation_entry(self, grouped_entries):
         User = get_user_model()
         has_creation_entry = (
@@ -238,8 +293,16 @@ def add_creation_entry(self, grouped_entries):
     def get_grouped_entries(self):
         grouped_entries = []
         grouped_timeline = groupby(
-            self.submissions.values(*self.fields),
-            key=lambda x: ("%d\001%s" % (x['submitter_id'], x['creation_time'])))
+            self.submissions_values,
+            key=lambda item: "\001".join([
+                str(x) for x in
+                [
+                    item['submitter_id'],
+                    item['creation_time'],
+                    item['suggestion_id'],
+                ]
+            ])
+        )
         # Group by submitter id and creation_time because
         # different submissions can have same creation time
         for key, values in grouped_timeline:
@@ -257,4 +320,5 @@ def get_grouped_entries(self):
         return grouped_entries
 
     def get_entry(self, item):
+        item["comment"] = self.comment_dict.get(item["suggestion_id"])
         return self.entry_class(ProxySubmission(item)).entry

pootle/apps/pootle_store/views.py

@@ -6,12 +6,14 @@
 # or later license. See the LICENSE file for a copy of the license and the
 # AUTHORS file for copyright and authorship information.
 
+import copy
+
 from translate.lang import data
 
 from django import forms
 from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
-from django.http import Http404
+from django.http import Http404, QueryDict
 from django.shortcuts import redirect
 from django.template import RequestContext, loader
 from django.utils import timezone
@@ -30,6 +32,7 @@
 from pootle_app.models.directory import Directory
 from pootle_app.models.permissions import (check_permission,
                                            check_user_permission)
+from pootle_comment.forms import UnsecuredCommentForm
 from pootle_misc.util import ajax_required
 from pootle_statistics.models import (Submission, SubmissionFields,
                                       SubmissionTypes)
@@ -505,6 +508,7 @@ def submit(request, unit):
 
     translation_project = request.translation_project
     language = translation_project.language
+    old_unit = copy.copy(unit)
 
     if unit.hasplural():
         snplurals = len(unit.source.strings)
@@ -518,8 +522,23 @@ def submit(request, unit):
     form = form_class(request.POST, instance=unit, request=request)
 
     if form.is_valid():
+        suggestion = form.cleaned_data['suggestion']
+        if suggestion:
+            old_unit.accept_suggestion(suggestion,
+                                       request.translation_project, request.user)
+            if form.cleaned_data['comment']:
+                kwargs = dict(
+                    comment=form.cleaned_data['comment'],
+                    user=request.user,
+                )
+                comment_form = UnsecuredCommentForm(suggestion, kwargs)
+                if comment_form.is_valid():
+                    comment_form.save()
+
         if form.updated_fields:
             for field, old_value, new_value in form.updated_fields:
+                if field == SubmissionFields.TARGET and suggestion:
+                    old_value = str(suggestion.target_f)
                 sub = Submission(
                     creation_time=current_time,
                     translation_project=translation_project,
@@ -628,6 +647,15 @@ def reject_suggestion(request, unit, suggid):
         raise PermissionDenied(_('Insufficient rights to access review mode.'))
 
     unit.reject_suggestion(sugg, request.translation_project, request.user)
+    r_data = QueryDict(request.body)
+    if "comment" in r_data and r_data["comment"]:
+        kwargs = dict(
+            comment=r_data["comment"],
+            user=request.user,
+        )
+        comment_form = UnsecuredCommentForm(sugg, kwargs)
+        if comment_form.is_valid():
+            comment_form.save()
 
     json['user_score'] = request.user.public_score
 
@@ -647,6 +675,14 @@ def accept_suggestion(request, unit, suggid):
         raise Http404
 
     unit.accept_suggestion(suggestion, request.translation_project, request.user)
+    if "comment" in request.POST and request.POST["comment"]:
+        kwargs = dict(
+            comment=request.POST["comment"],
+            user=request.user,
+        )
+        comment_form = UnsecuredCommentForm(suggestion, kwargs)
+        if comment_form.is_valid():
+            comment_form.save()
 
     json['user_score'] = request.user.public_score
     json['newtargets'] = [highlight_whitespace(target)