def get(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return JsonResponseBadRequest({"msg": "Not enough privileges"})
form_data = self.request.GET.dict()
form_data.update({"language": kwargs["language_code"]})
form = self.form_class(form_data)
if not form.is_valid():
# FIXME: make raising a `ValidationError` return from parent
# classes the appropriate response
return JsonResponseBadRequest({"errors": form.errors})
context = self.get_context_data(form=form)
return JsonResponse(context)
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 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 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 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 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 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 handle_exception(self, exc):
"""Handles response exceptions."""
if isinstance(exc, Http404):
return JsonResponseNotFound({"msg": "Not found"})
if isinstance(exc, PermissionDenied):
return JsonResponseForbidden({"msg": "Permission denied."})
if isinstance(exc, JSONDecodeError):
return JsonResponseBadRequest({"msg": "Invalid JSON data"})
raise
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 remove_paid_task(request, task_id=None):
if request.method == 'DELETE':
try:
obj = PaidTask.objects.get(id=task_id)
str = '%s\t%s\t%s' % (request.user.username, PAID_TASK_DELETED,
obj)
obj.delete()
log(str)
return JsonResponse({'removed': 1})
except PaidTask.DoesNotExist:
return JsonResponseNotFound({})
return JsonResponseBadRequest({'error': _('Invalid request method')})
def submit(request, unit, **kwargs_):
"""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
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit, request=request)
if form.is_valid():
suggestion = form.cleaned_data['suggestion']
if suggestion:
review.get(Suggestion)([suggestion], request.user,
SubmissionTypes.NORMAL).accept()
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:
# 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
form.save(changed_with=SubmissionTypes.NORMAL)
json['checks'] = _get_critical_checks_snippet(request, unit)
json['user_score'] = request.user.public_score
json['newtargets'] = [
target for target in form.instance.target.strings
]
return JsonResponse(json)
return JsonResponseBadRequest({'msg': _("Failed to process submission.")})
def delete_comment(request, unit):
"""Deletes a comment by blanking its contents and records a new
submission.
"""
unit.commented_by = None
unit.commented_on = None
language = request.translation_project.language
comment_form_class = unit_comment_form_factory(language)
form = comment_form_class({}, instance=unit, request=request)
if form.is_valid():
form.save()
return JsonResponse({})
return JsonResponseBadRequest({'msg': _("Failed to remove comment.")})
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 process_exception(self, request, exception):
msg = force_str(exception)
if isinstance(exception, Http404):
if request.is_ajax():
return JsonResponseNotFound({"msg": msg})
elif isinstance(exception, Http400):
if request.is_ajax():
return JsonResponseBadRequest({"msg": msg})
elif isinstance(exception, PermissionDenied):
if request.is_ajax():
return JsonResponseForbidden({"msg": msg})
ctx = {
"permission_error": msg,
}
if not request.user.is_authenticated:
msg_args = {
"login_link": reverse("account_login"),
}
login_msg = _(
'You need to <a class="js-login" '
'href="%(login_link)s">login</a> to access this page.' %
msg_args)
ctx["login_message"] = login_msg
return HttpResponseForbidden(
render_to_string("errors/403.html",
context=ctx,
request=request))
elif exception.__class__.__name__ in (
"OperationalError",
"ProgrammingError",
"DatabaseError",
):
# HACKISH: Since exceptions thrown by different databases do not
# share the same class heirarchy (DBAPI2 sucks) we have to check
# the class name instead. Since python uses duck typing I will call
# this poking-the-duck-until-it-quacks-like-a-duck-test
return handle_exception(request, exception, "errors/db.html")
else:
return handle_exception(request, exception, "errors/500.html")
def process_exception(self, request, exception):
msg = force_unicode(exception)
if isinstance(exception, Http404):
if request.is_ajax():
return JsonResponseNotFound({'msg': msg})
elif isinstance(exception, Http400):
if request.is_ajax():
return JsonResponseBadRequest({'msg': msg})
elif isinstance(exception, PermissionDenied):
if request.is_ajax():
return JsonResponseForbidden({'msg': msg})
ctx = {
'permission_error': msg,
}
if not request.user.is_authenticated():
msg_args = {
'login_link': reverse('account_login'),
}
login_msg = _(
'You need to <a class="js-login" href="%(login_link)s">login</a> '
'to access this page.', msg_args)
ctx["login_message"] = login_msg
return HttpResponseForbidden(
render_to_string('errors/403.html', ctx,
RequestContext(request)))
elif (exception.__class__.__name__
in ('OperationalError', 'ProgrammingError', 'DatabaseError')):
# HACKISH: Since exceptions thrown by different databases do
# not share the same class heirarchy (DBAPI2 sucks) we have to
# check the class name instead. Since python uses duck typing
# I will call this
# poking-the-duck-until-it-quacks-like-a-duck-test
return handle_exception(request, exception, 'errors/db.html')
else:
return handle_exception(request, exception, 'errors/500.html')
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
old_unit = copy.copy(unit)
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():
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,
submitter=request.user,
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.user
form.instance.submitted_on = current_time
form.instance.reviewed_by = None
form.instance.reviewed_on = None
form.instance._log_user = request.user
form.save()
json["checks"] = _get_critical_checks_snippet(request, unit)
json["user_score"] = request.user.public_score
return JsonResponse(json)
return JsonResponseBadRequest({"msg": _("Failed to process submission.")})