def get_context_units(request, unit):
"""Retrieves context units.
:return: An object in JSON notation that contains the lightweight unit
information for units around `unit`.
"""
units_qs = request.store.units
limit = 5
units_before = []
if unit.index > 0:
limit_before = min(unit.index - 1, limit)
units_before = units_qs.filter(
index__gt=unit.index - 1 - limit
).order_by('index')[:limit_before]
# FIXME: can we avoid this query if length is known?
units_after = units_qs.filter(
index__gt=unit.index,
)[:limit]
return JsonResponse({
'before': CtxRowResults(units_before).data,
'after': CtxRowResults(units_after).data,
})
def get(self, request, *args, **kwargs):
"""GET handler."""
if self.kwargs.get(self.pk_field_name, None) is not None:
object = self.get_object()
return JsonResponse(self.object_to_values(object))
return self.get_collection(request, *args, **kwargs)
def suggest(request, unit, **kwargs_):
"""Processes translation suggestions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit, request=request)
if form.is_valid():
if form.cleaned_data.get("target_updated"):
# TODO: Review if this hackish method is still necessary
# HACKISH: django 1.2 stupidly modifies instance on model form
# validation, reload unit from db
unit = Unit.objects.get(id=unit.id)
review.get(Suggestion)().add(unit,
form.cleaned_data['target_f'],
user=request.user)
if not request.user.is_anonymous:
json['user_score'] = request.user.public_score
return JsonResponse(json)
return JsonResponseBadRequest({'msg': _("Failed to process suggestion.")})
def accept_suggestion(request, unit, suggid):
json = {
'udbid': unit.id,
'sugid': suggid,
}
try:
suggestion = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
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)
for target in unit.target.strings]
json['newdiffs'] = {}
for sugg in unit.get_suggestions():
json['newdiffs'][sugg.id] = [highlight_diffs(unit.target.strings[i],
target) for i, target in
enumerate(sugg.target.strings)]
json['checks'] = _get_critical_checks_snippet(request, unit)
return JsonResponse(json)
def suggest(request, unit, **kwargs_):
"""Processes translation suggestions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit, request=request)
unit_target = unit.target
if form.is_valid():
target = form.cleaned_data["target_f"]
if target and target != unit_target:
unit = Unit.objects.get(id=unit.id)
review.get(Suggestion)().add(
unit,
form.cleaned_data['target_f'],
user=request.user)
if not request.user.is_anonymous:
json['user_score'] = request.user.public_score
return JsonResponse(json)
return JsonResponseBadRequest({'msg': _("Failed to process suggestion.")})
def accept_suggestion(request, unit, suggid):
json = {
'udbid': unit.id,
'sugid': suggid,
}
if request.POST.get('accept'):
try:
suggestion = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
unit.accept_suggestion(suggestion, request.translation_project,
request.profile)
json['user_score'] = request.profile.public_score
json['newtargets'] = [
highlight_whitespace(target) for target in unit.target.strings
]
json['newdiffs'] = {}
for sugg in unit.get_suggestions():
json['newdiffs'][sugg.id] = \
[highlight_diffs(unit.target.strings[i], target)
for i, target in enumerate(sugg.target.strings)]
json['checks'] = _get_critical_checks_snippet(request, unit)
return JsonResponse(json)
def get_qualitycheck_stats(request, *args, **kwargs):
failing_checks = request.resource_obj.get_checks()
if failing_checks is None:
return JsonResponse({})
result = [
dict(count=count, **get_qc_data_by_name(check))
for check, count in failing_checks.iteritems()
]
def alphabetical_critical_first(item):
critical_first = 0 if item['is_critical'] else 1
return critical_first, item['title'].lower()
result = sorted(result, key=alphabetical_critical_first)
return JsonResponse(result)
def get_units(request):
"""Gets source and target texts and its metadata.
:return: A JSON-encoded string containing the source and target texts
grouped by the store they belong to.
The optional `count` GET parameter defines the chunk size to
consider. The user's preference will be used by default.
When the `initial` GET parameter is present, a sorted list of
the result set ids will be returned too.
"""
search_form = UnitSearchForm(request.GET, user=request.user)
if not search_form.is_valid():
errors = search_form.errors.as_data()
if "path" in errors:
for error in errors["path"]:
if error.code == "max_length":
raise Http400(_('Path too long.'))
elif error.code == "required":
raise Http400(_('Arguments missing.'))
raise Http404(forms.ValidationError(search_form.errors).messages)
total, start, end, units_qs = search_backend.get(Unit)(
request.user, **search_form.cleaned_data).search()
return JsonResponse({
'start': start,
'end': end,
'total': total,
'unitGroups': GroupedResults(units_qs).data
})
def users(request):
User = get_user_model()
data = list(
User.objects.hide_meta()
.values('id', 'username', 'full_name')
)
return JsonResponse(data)
def save_comment(request, unit):
"""Stores a new comment for the given ``unit``.
:return: If the form validates, the cleaned comment is returned.
An error message is returned otherwise.
"""
# Update current unit instance's attributes
unit.commented_by = request.user
unit.commented_on = timezone.now().replace(microsecond=0)
language = request.translation_project.language
form = unit_comment_form_factory(language)(request.POST,
instance=unit,
request=request)
if form.is_valid():
form.save()
user = request.user
directory = unit.store.parent
ctx = {
'unit': unit,
'language': language,
'cantranslate': check_user_permission(user, 'translate',
directory),
'cansuggest': check_user_permission(user, 'suggest', directory),
}
t = loader.get_template('editor/units/xhr_comment.html')
c = RequestContext(request, ctx)
return JsonResponse({'comment': t.render(c)})
return JsonResponseBadRequest({'msg': _("Comment submission failed.")})
def accept_suggestion(request, unit, suggid):
try:
suggestion = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
unit.accept_suggestion(suggestion, request.translation_project,
request.user)
if "comment" in request.POST and request.POST["comment"]:
handle_suggestion_comment(request, suggestion, unit,
request.POST["comment"], "accepted")
json = {
'udbid':
unit.id,
'sugid':
suggid,
'user_score':
request.user.public_score,
'newtargets':
[highlight_whitespace(target) for target in unit.target.strings],
'checks':
_get_critical_checks_snippet(request, unit),
'newdiffs': {},
}
for sugg in unit.get_suggestions():
json['newdiffs'][sugg.id] = [
highlight_diffs(unit.target.strings[i], target)
for i, target in enumerate(sugg.target.strings)
]
return JsonResponse(json)
def reject_suggestion(request, unit, suggid, **kwargs_):
try:
suggestion = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
# In order to be able to reject a suggestion, users have to either:
# 1. Have `review` rights, or
# 2. Be the author of the suggestion being rejected
has_permission = (
check_permission('review', request)
or (not request.user.is_anonymous()
and request.user == suggestion.user))
if not has_permission:
raise PermissionDenied(
_('Insufficient rights to access review mode.'))
review.get(Suggestion)(
[suggestion],
request.user).reject(QueryDict(request.body).get("comment"))
json = {
'udbid': unit.id,
'sugid': suggid,
'user_score': request.user.public_score,
}
return JsonResponse(json)
def toggle_qualitycheck(request, unit, check_id, **kwargs_):
try:
unit.toggle_qualitycheck(check_id, 'mute' in request.POST, request.user)
except ObjectDoesNotExist:
raise Http404
return JsonResponse({})
def submit(request, unit):
"""Processes translation submissions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
# Store current time so that it is the same for all submissions
current_time = timezone.now()
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit, request=request)
if form.is_valid():
if form.updated_fields:
for field, old_value, new_value in form.updated_fields:
sub = Submission(
creation_time=current_time,
translation_project=translation_project,
submitter=request.profile,
unit=unit,
store=unit.store,
field=field,
type=SubmissionTypes.NORMAL,
old_value=old_value,
new_value=new_value,
similarity=form.cleaned_data['similarity'],
mt_similarity=form.cleaned_data['mt_similarity'],
)
sub.save()
# Update current unit instance's attributes
# important to set these attributes after saving Submission
# because we need to access the unit's state before it was saved
if SubmissionFields.TARGET in (f[0] for f in form.updated_fields):
form.instance.submitted_by = request.profile
form.instance.submitted_on = current_time
form.instance.reviewed_by = None
form.instance.reviewed_on = None
form.instance._log_user = request.profile
form.save()
json['checks'] = _get_critical_checks_snippet(request, unit)
json['user_score'] = request.profile.public_score
return JsonResponse(json)
return JsonResponseBadRequest({'msg': _("Failed to process submission.")})
def reject_suggestion(request, unit, suggid):
json = {
'udbid': unit.id,
'sugid': suggid,
}
try:
sugg = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
# In order to be able to reject a suggestion, users have to either:
# 1. Have `review` rights, or
# 2. Be the author of the suggestion being rejected
if (not check_permission('review', request)
and (request.user.is_anonymous() or request.user != sugg.user)):
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
return JsonResponse(json)
def reject_suggestion(request, unit, suggid):
try:
sugg = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
# In order to be able to reject a suggestion, users have to either:
# 1. Have `review` rights, or
# 2. Be the author of the suggestion being rejected
if (not check_permission('review', request)
and (request.user.is_anonymous or request.user != sugg.user)):
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"]:
handle_suggestion_comment(request, sugg, unit, r_data["comment"],
"rejected")
json = {
'udbid': unit.id,
'sugid': suggid,
'user_score': request.user.public_score,
}
return JsonResponse(json)
def toggle_qualitycheck(request, unit, check_id):
try:
unit.toggle_qualitycheck(check_id, bool(request.POST.get('mute')),
request.user)
except ObjectDoesNotExist:
raise Http404
return JsonResponse({})
def legal_agreement(request):
"""Displays the pending documents to be agreed by the current user."""
pending_pages = LegalPage.objects.pending_user_agreement(request.user)
form_class = agreement_form_factory(pending_pages, request.user)
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid():
form.save()
return JsonResponse({})
rendered_form = _get_rendered_agreement(request, form)
return JsonResponseBadRequest({'form': rendered_form})
rendered_form = _get_rendered_agreement(request, form_class())
return JsonResponse({'form': rendered_form})
def add_paid_task(request):
form = PaidTaskForm(request.POST)
if form.is_valid():
form.save()
obj = form.instance
log('%s\t%s\t%s' % (request.user.username, PAID_TASK_ADDED, obj))
return JsonResponse({'result': obj.id})
return JsonResponseBadRequest({'errors': form.errors})
def get_single_item(self, request, *args, **kwargs):
"""Returns a single model instance."""
try:
qs = self.base_queryset.filter(pk=kwargs[self.pk_field_name])
assert len(qs) == 1
except AssertionError:
raise Http404
return JsonResponse(self.qs_to_values(qs))
def preview_content(request):
"""Returns content rendered based on the configured markup settings."""
if 'text' not in request.POST:
return JsonResponseBadRequest({
'msg': _('Text is missing'),
})
return JsonResponse({
'rendered': apply_markup_filter(request.POST['text']),
})
def update_user_rates(request):
form = UserRatesForm(request.POST)
if form.is_valid():
try:
User = get_user_model()
user = User.objects.get(username=form.cleaned_data['username'])
except User.DoesNotExist:
error_text = _("User %s not found", form.cleaned_data['username'])
return JsonResponseNotFound({'msg': error_text})
user.currency = form.cleaned_data['currency']
user.rate = form.cleaned_data['rate']
user.review_rate = form.cleaned_data['review_rate']
user.hourly_rate = form.cleaned_data['hourly_rate']
scorelog_filter = {'user': user}
paid_task_filter = scorelog_filter.copy()
if form.cleaned_data['effective_from'] is not None:
effective_from = form.cleaned_data['effective_from']
scorelog_filter.update({
'creation_time__gte': effective_from
})
paid_task_filter.update({
'datetime__gte': effective_from
})
scorelog_query = ScoreLog.objects.filter(**scorelog_filter)
scorelog_count = scorelog_query.count()
paid_task_query = PaidTask.objects.filter(**paid_task_filter)
paid_task_count = paid_task_query.count()
scorelog_query.update(rate=user.rate, review_rate=user.review_rate)
def get_task_rate_for(user, task_type):
return {
PaidTaskTypes.TRANSLATION: user.rate,
PaidTaskTypes.REVIEW: user.review_rate,
PaidTaskTypes.HOURLY_WORK: user.hourly_rate,
PaidTaskTypes.CORRECTION: 1,
}.get(task_type, 0)
for task in paid_task_query:
task.rate = get_task_rate_for(user, task.task_type)
task.save()
user.save()
return JsonResponse({
'scorelog_count': scorelog_count,
'paid_task_count': paid_task_count,
})
return JsonResponseBadRequest({'errors': form.errors})
def delete(self, request, *args, **kwargs):
"""Delete the model and return its JSON representation."""
if self.pk_field_name not in kwargs:
return self.status_msg("DELETE is not supported for collections",
status=405)
obj = self.get_object()
try:
obj.delete()
return JsonResponse({})
except ProtectedError as e:
return self.status_msg(str(e), status=405)
def user_date_prj_activity(request):
username = request.GET.get('username', None)
month = request.GET.get('month', None)
try:
User = get_user_model()
user = User.objects.get(username=username)
except User.DoesNotExist:
user = ''
data = get_activity_data(request, user, month)
return JsonResponse(data)
def put(self, request, *args, **kwargs):
"""Update the current model."""
if self.pk_field_name not in self.kwargs:
return self.status_msg("PUT is not supported for collections",
status=405)
form = self.edit_form_class(**self.get_form_kwargs())
if form.is_valid():
updated_object = form.save()
return JsonResponse(self.object_to_values(updated_object))
return self.form_invalid(form)
def remove_paid_task(request, task_id=None):
if request.method == "DELETE":
try:
obj = PaidTask.objects.get(id=task_id)
string = "%s\t%s\t%s" % (request.user.username, PAID_TASK_DELETED, obj)
obj.delete()
log(string)
return JsonResponse({"removed": 1})
except PaidTask.DoesNotExist:
return JsonResponseNotFound({})
return JsonResponseBadRequest({"error": _("Invalid request method")})
def toggle_qualitycheck(request, unit, check_id):
json = {
'udbid': unit.id,
'checkid': check_id,
}
try:
unit.toggle_qualitycheck(check_id, bool(request.POST.get('mute')),
request.profile)
except ObjectDoesNotExist:
raise Http404
return JsonResponse(json)
def get_stats(request, *args, **kwargs):
stats = request.resource_obj.get_stats()
if (isinstance(request.resource_obj, Directory)
and 'virtualfolder' in settings.INSTALLED_APPS):
stats['vfolders'] = {}
for vfolder_treeitem in request.resource_obj.vf_treeitems.iterator():
if request.user.is_superuser or vfolder_treeitem.is_visible:
stats['vfolders'][vfolder_treeitem.code] = \
vfolder_treeitem.get_stats(include_children=False)
return JsonResponse(stats)
def get_more_context(request, unit):
"""Retrieves more context units.
:return: An object in JSON notation that contains the source and target
texts for units that are in the context of unit ``uid``.
"""
store = request.store
json = {}
gap = int(request.GET.get('gap', 0))
qty = int(request.GET.get('qty', 1))
json["ctx"] = _filter_ctx_units(store.units, unit, qty, gap)
return JsonResponse(json)
def post(self, request, *args, **kwargs):
"""Creates a new model instance.
The form to be used can be customized by setting
`self.add_form_class`. By default a model form will be used with
the fields from `self.fields`.
"""
form = self.add_form_class(**self.get_form_kwargs())
if form.is_valid():
new_object = form.save()
return JsonResponse(self.object_to_values(new_object))
return self.form_invalid(form)
