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)