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.")})