def project_delete_permission_request(request, project_slug, permission_pk): """ View for deleting a request of permission of a user. This view is an abstraction of a txpermissions.views method. """ project, permission = _get_project_and_permission(project_slug, permission_pk) # It's necessary to distinguish between maintainer and normal users that # did the request if request.user.id == permission.user.id: notice_type = 'project_submit_access_request_withdrawn' sendto = project.maintainers.all() else: notice_type = 'project_submit_access_request_denied' sendto = [permission.user] notice = { 'type': notice_type, 'object': project, 'sendto': sendto, 'extra_context': { 'project': project, 'user_request': permission.user, 'user_action': request.user, }, } check = ProjectPermission(request.user) if check.maintain(project) or \ request.user.has_perm('authority.delete_permission') or \ request.user.pk == permission.creator.pk: return delete_permission_or_request( request, permission, False, extra_context={'notice': notice}, ) check = ProjectPermission(request.user) if check.maintain(project) or \ request.user.has_perm('authority.delete_permission') or \ request.user.pk == permission.creator.pk: return delete_permission_or_request(request, permission, False) return permission_denied(request)
def _has_perm(self, user, project): """ Check that the user has access to this resource. """ perm = ProjectPermission(user) if not perm.private(project): return False return True
def _save_translation(source_string, translations, target_language, user): """Save a translation string to the database. This functions handle a signle source entity translation (could be pluralized). Currently, the function only returns warning strings. There is no message for success. Args: source_string: A Translation object of the string in the source language. translations: A (rule, string) tuple. target_language: The language the string is translated to. user: The translator. Returns: A list if strings to display to the user. Raises: An LotteBadRequestError exception in case of errors. """ source_id = source_string.pk resource = source_string.resource source_language = resource.source_language warnings = [] check = ProjectPermission(user) review_perm = check.proofread(resource.project, target_language) for rule, target_string in translations.items(): rule = target_language.get_rule_num_from_name(rule) if rule != 5: # fetch correct source string for plural rule try: source_string = Translation.objects.get( source_entity=source_string.source_entity, language=source_language, rule=rule) except Translation.DoesNotExist: # target language has extra plural forms pass # check for errors try: for ErrorValidator in create_error_validators( resource.i18n_method): v = ErrorValidator(source_language, target_language, rule) v(source_string.string, target_string) except ValidationError, e: raise LotteBadRequestError(e.message) # check for warnings for WarningValidator in create_warning_validators( resource.i18n_method): v = WarningValidator(source_language, target_language, rule) try: v(source_string.string, target_string) except ValidationError, e: warnings.append(e.message)
def render(self, context): obj = self.resolve(self.obj, context) perm = self.resolve(self.perm, context) if self.template_name: template_name = [ self.resolve(obj, context) for obj in self.template_name.split(',') ] else: template_name = 'txpermissions/permission_form.html' request = context['request'] extra_context = {} if self.approved: check = ProjectPermission(request.user) if request.user.is_authenticated(): if (check.maintain(obj) or request.user.has_perm('authority.add_permission')): extra_context = { 'form_url': txadd_url_for_obj(obj), 'next': request.build_absolute_uri(), 'approved': self.approved, 'form': UserAjaxPermissionForm(perm, obj, approved=self.approved, initial=dict(codename=perm)), } else: if request.user.is_authenticated( ) and not request.user.is_superuser: extra_context = { 'form_url': txrequest_url_for_obj(obj), 'next': request.build_absolute_uri(), 'approved': self.approved, 'form': UserAjaxPermissionForm(perm, obj, approved=self.approved, initial=dict( codename=perm, user=request.user.username)), } return template.loader.render_to_string( template_name, extra_context, context_instance=template.RequestContext(request))
def txpermission_request_approve_form(context, obj, perm): """ Render a html form to the approve view of the given permission request. Return no content if the request-user has no permission to delete permissions. """ user = context['request'].user if user.is_authenticated(): check = ProjectPermission(user) if (check.maintain(obj) or user.has_perm('authority.approve_permission_requests')): return _base_permission_form(context, obj, perm, 'project_approve_permission_request') return {'url': None}
def txpermission_delete_form(context, obj, perm): """ Render a html form to the delete view of the given permission. Return no content if the request-user has no permission to delete foreign permissions. """ user = context['request'].user if user.is_authenticated(): check = ProjectPermission(user) if (check.maintain(obj) or user.has_perm('authority.delete_permission') or user.pk == perm.creator.pk): return _base_permission_form(context, obj, perm, 'project_delete_permission') return {'url': None}
def clone_language(request, project_slug=None, resource_slug=None, source_lang_code=None, target_lang_code=None): ''' Get a resource, a src lang and a target lang and clone all translation strings for the src to the target. The user is redirected to the online editor for the target language. ''' resource = get_object_or_404(Resource, slug=resource_slug, project__slug=project_slug) # Permissions handling # Project should always be available project = get_object_or_404(Project, slug=project_slug) team = Team.objects.get_or_none(project, target_lang_code) check = ProjectPermission(request.user) if not check.submit_translations(team or project) or not \ resource.accept_translations: return permission_denied(request) source_lang = get_object_or_404(Language, code=source_lang_code) target_lang = get_object_or_404(Language, code=target_lang_code) # get the strings which will be cloned strings = Translation.objects.filter(resource=resource, language=source_lang) # If the language we want to create, has the same plural rules with the # source, we also copy the pluralized translations! if not source_lang.get_pluralrules() == target_lang.get_pluralrules(): strings = strings.exclude(source_entity__pluralized=True) # clone them in new translation for s in strings: Translation.objects.get_or_create(language=target_lang, string=s.string, source_entity=s.source_entity, rule=s.rule, resource=s.resource) invalidate_stats_cache(resource, target_lang, user=request.user) return HttpResponseRedirect( reverse('translate_resource', args=[project_slug, resource_slug, target_lang_code]), )
def tab_suggestions_snippet(request, entity_id, lang_code): """Return a template snippet with entity & translation details.""" source_entity = get_object_or_404(SourceEntity, pk=entity_id) check = ProjectPermission(request.user) if not check.private(source_entity.resource.project): return permission_denied(request) current_translation = source_entity.get_translation(lang_code) return render_to_response("tab_suggestions_snippet.html", { 'source_entity': source_entity, 'lang_code': lang_code, 'current_translation': current_translation }, context_instance=RequestContext(request))
def txpermission_request_delete_form(context, obj, perm): """ Render a html form to the delete view of the given permission request. Return no content if the request-user has no permission to delete permissions. """ user = context['request'].user if user.is_authenticated(): check = ProjectPermission(user) form_kwargs = _base_permission_form( context, obj, perm, 'project_delete_permission_request') if check.maintain(obj) or user.has_perm('authority.delete_permission'): form_kwargs['is_requestor'] = False return form_kwargs if not perm.approved and perm.user == user: form_kwargs['is_requestor'] = True return form_kwargs return {'url': None}
def add_edit_developer_comment_extra(request, project_slug, *args, **kwargs): """ View for handling AJAX calls from Lotte in order to add/edit the developer comment for a source entity. Only maintainers can edit it. """ # Permissions handling project = get_object_or_404(Project, slug=project_slug) check = ProjectPermission(request.user) if not check.maintain(project): content = {'error': True, 'message': _('Permission error.')} elif not request.POST: content = {'error': True, 'message': _('Bad request.')} else: previous_comment = None try: se = SourceEntity.objects.get(id=request.POST.get( 'source_entity_id', None), resource__project=project) previous_comment_extra = se.developer_comment_extra se.developer_comment_extra = request.POST.get('comment_extra', '') se.save() content = { 'error': False, 'comment': se.developer_comment, 'comment_extra': se.developer_comment_extra, } except SourceEntity.DoesNotExist: content = { 'error': True, 'message': _('No such Source Entity for the given project.'), } except Exception, e: logger.error('Lotte: Error while editing developer comment: %s' % (e.message or str(e))) content = { 'error': True, 'message': _('Ops! Something weird happened. The admins ' 'were notified about it.'), }
def update_translation(request, project_slug, resource_slug, lang_code=None): """Ajax view that gets an uploaded translation as a file and saves it. If the language is not specified, the translation does not exist yet. Othewise, this is an update. Returns: Either an error message, or nothing for success. """ resource = get_object_or_404(Resource.objects.select_related('project'), project__slug=project_slug, slug=resource_slug) if lang_code is None: lang_code = request.POST.get('language_code', None) target_language = get_object_or_404(Language, code=lang_code) project = resource.project # Get the team if exists to use it for permissions and links team = Team.objects.get_or_none(project, lang_code) check = ProjectPermission(request.user) if (not check.submit_translations(team or resource.project) or\ not resource.accept_translations) and not\ check.maintain(resource.project): return HttpResponse(simplejson.dumps({ 'msg': _("You are not allowed to upload a translation."), 'status': 403, }), status=403, content_type='text/plain') content = content_from_uploaded_file(request.FILES) try: _save_translation(resource, target_language, request.user, content) except FormatsBackendError, e: return HttpResponse(simplejson.dumps({ 'msg': unicode(e), 'status': 400, }), status=400, content_type='text/plain')
def suggestion_vote(request, entity_id, lang_code, suggestion_id, direction): """Vote up or down for a suggestion.""" suggestion = get_object_or_404(Suggestion, pk=suggestion_id) # Permissions handling check = ProjectPermission(request.user) if not check.private(suggestion.source_entity.resource.project): return permission_denied(request) #FIXME: All basic POST checks could be done in a decorator. if not request.method == "POST": return HttpResponseBadRequest(_("POST method only allowed.")) if direction == 'up': suggestion.vote_up(request.user) elif direction == 'down': suggestion.vote_down(request.user) return HttpResponse(status=200)
def stringset_handling(request, project_slug, lang_code, resource_slug=None, *args, **kwargs): """ Function to serve AJAX data to the datatable holding the translating stringset. """ project = get_object_or_404(Project, slug=project_slug) resources = [] if resource_slug: try: resources = [ Resource.objects.get(slug=resource_slug, project__slug=project_slug) ] except Resource.DoesNotExist: raise Http404 else: resources = Resource.objects.filter(project__slug=project_slug) try: language = Language.objects.by_code_or_alias(lang_code) except Language.DoesNotExist: raise Http404 # Check if user is a team reviewer so that we can # send the extra info. check = ProjectPermission(request.user) review = check.proofread(project, language) # FIXME Do we need to check for non-POST requests and return an error? return _get_stringset(request.POST, resources, language, review=review, session=request.session)
def _read(self, request, project_slug): """ Return a list of projects or the details for a specific project. """ if project_slug is None: # Use pagination p = Project.objects.for_user(request.user) res, msg = paginate(p, request.GET.get('start'), request.GET.get('end')) if res is None: return BAD_REQUEST(msg) return res else: try: p = Project.objects.get(slug=project_slug) perm = ProjectPermission(request.user) if not perm.private(p): return rc.FORBIDDEN except Project.DoesNotExist: return rc.NOT_FOUND return p
def tab_details_snippet(request, entity_id, lang_code): """Return a template snippet with entity & translation details.""" source_entity = get_object_or_404(SourceEntity, pk=entity_id) check = ProjectPermission(request.user) if not check.private(source_entity.resource.project): return permission_denied(request) language = get_object_or_404(Language, code=lang_code) translation = source_entity.get_translation(language.code) return list_detail.object_detail(request, queryset=SourceEntity.objects.all(), object_id=entity_id, template_name="tab_details_snippet.html", template_object_name='source_entity', extra_context={ "translation": translation, "project": source_entity.resource.project })
def suggestion_create(request, entity_id, lang_code): """Create a suggestion for an entity and a language.""" source_entity = get_object_or_404(SourceEntity, pk=entity_id) # Permissions handling check = ProjectPermission(request.user) if not check.private(source_entity.resource.project): return permission_denied(request) #FIXME: All basic POST checks could be done in a decorator. if not request.method == "POST": return HttpResponseBadRequest(_("POST method only allowed.")) suggestion_string = request.POST['suggestion_string'] if not suggestion_string: return HttpResponseBadRequest( _("POST variable 'suggestion_string' missing.")) language = Language.objects.by_code_or_alias(lang_code) source_entity.suggestions.create(language=language, string=request.POST['suggestion_string'], user=request.user) return HttpResponse(status=200)
def cla_project_sign(request, project_slug): project = get_object_or_404(Project, slug=project_slug) cla = get_object_or_404(Cla, project=project) check = ProjectPermission(request.user) if not check.submit_translations(project, any_team=True): return permission_denied(request) try: signed_cla = request.user.cla_set.filter(project=project)[0] except IndexError: signed_cla = None if request.method == 'POST' and not signed_cla: form = ClaForm(request.POST) if form.is_valid(): kwargs = { 'cla_sign': True, 'project': project, 'user': request.user } handle_pre_team(None, **kwargs) messages.success(request, _("You have signed the CLA.")) return HttpResponseRedirect( reverse('cla_project_sign', args=[project_slug]), ) else: form = ClaForm() return render_to_response("project_cla.html", { 'project': project, 'cla': cla, 'signed_cla': signed_cla, 'form': form }, context_instance=RequestContext(request))
def _update(self, request, project_slug, resource_slug, lang_code=None): # Permissions handling try: resource = Resource.objects.select_related('project').get( slug=resource_slug, project__slug=project_slug) except Resource.DoesNotExist: return rc.NOT_FOUND source_push = False if lang_code == "source": language = resource.source_language source_push = True else: try: language = Language.objects.by_code_or_alias(lang_code) except Language.DoesNotExist: logger.error("Weird! Selected language code (%s) does " "not match with any language in the database." % lang_code) return BAD_REQUEST( "Selected language code (%s) does not match with any" "language in the database." % lang_code) team = Team.objects.get_or_none(resource.project, lang_code) check = ProjectPermission(request.user) if source_push and not check.maintain(resource.project): return rc.FORBIDDEN elif (not check.submit_translations(team or resource.project) or\ not resource.accept_translations) and not\ check.maintain(resource.project): return rc.FORBIDDEN try: t = Translation.get_object("create", request, resource, language) res = t.create() except BadRequestError, e: return BAD_REQUEST(unicode(e))
def resource_translation_toggle_watch(request, project_slug, resource_slug, language_code): """Add/Remove a TranslationWatch for a specific user.""" if request.method != 'POST': return json_error(_('Must use POST to activate')) if not settings.ENABLE_NOTICES: return json_error(_('Notification is not enabled')) resource = get_object_or_404(Resource, slug=resource_slug, project__slug=project_slug) project = resource.project language = get_object_or_404(Language, code=language_code) team = Team.objects.get_or_none(project, language_code) check = ProjectPermission(request.user) if not check.submit_translations(team or project) and not \ check.maintain(project) and not \ request.user.has_perm('watches.add_translationwatch') and not \ request.user.has_perm('watches.delete_translationwatch'): return permission_denied(request) url = reverse('resource_translation_toggle_watch', args=(project_slug, resource_slug, language_code)) try: twatch = TranslationWatch.objects.get(resource=resource, language=language) result = { 'style': 'watch_add', 'title': _('Watch it'), 'id': twatch.id, 'url': url, 'error': None, } notification.stop_observing(twatch, request.user, signal='project_resource_translation_changed') except (TranslationWatch.DoesNotExist, notification.ObservedItem.DoesNotExist): try: twatch = TranslationWatch.objects.get_or_create(resource=resource, language=language)[0] result = { 'style': 'watch_remove', 'title': _('Stop watching'), 'id': twatch.id, 'url': url, 'error': None, } notification.observe(twatch, request.user, 'project_resource_translation_changed', signal='project_resource_translation_changed') except WatchException, e: return json_error(e.message, result)
def project_access_control_edit(request, project_slug): project = get_object_or_404(Project, slug=project_slug) outsourced = project.outsource if request.method == 'POST': form = ProjectAccessControlForm(request.POST, instance=project, user=request.user) if form.is_valid(): access_control = form.cleaned_data['access_control'] project_type = form.cleaned_data['project_type'] project = form.save(commit=False) project_hub = project.outsource hub_request = None # TODO call signal project_outsourced_changed if 'outsourced' != project_type: project.outsource = None else: check = ProjectPermission(request.user) if not (check.maintain(project) and check.maintain(project_hub)): # If the user is not maintainer of both projects it does # not associate the outsource project directly. # It does a request instead. try: hub_request = HubRequest.objects.get(project=project) except ObjectDoesNotExist: hub_request = HubRequest(project=project) hub_request.project_hub = project_hub hub_request.user = request.user hub_request.save() messages.success( request, _("Requested to join the '%s' project hub.") % project_hub) # ActionLog & Notification # TODO: Use signals nt = 'project_hub_join_requested' context = { 'hub_request': hub_request, 'sender': request.user } # Logging action action_logging(request.user, [project, project_hub], nt, context=context) if settings.ENABLE_NOTICES: # Send notification for project hub maintainers notification.send(project_hub.maintainers.all(), nt, context) return HttpResponseRedirect( reverse('project_detail', args=[project.slug]), ) if 'hub' == project_type: project.is_hub = True else: project.is_hub = False if ('free_for_all' == access_control and project_type != "outsourced"): project.anyone_submit = True else: project.anyone_submit = False # Check if cla form exists before sending the signal if 'limited_access' == access_control and \ form.cleaned_data.has_key('cla_license_text'): # send signal to save CLA signals.cla_create.send( sender='project_access_control_edit_view', project=project, license_text=form.cleaned_data['cla_license_text'], request=request) project.save() form.save_m2m() handle_stats_on_access_control_edit(project) project_outsourced_changed.send(sender=project_hub) if outsourced and not project.outsource: # Drop resources from all-resources release of the hub project update_all_release(outsourced) # Logging action nt = 'project_hub_left' context = { 'project': project, 'project_hub': outsourced, 'sender': request.user } action_logging(request.user, [project, outsourced], nt, context=context) return HttpResponseRedirect( reverse('project_detail', args=[project.slug]), ) else: form = ProjectAccessControlForm(instance=project, user=request.user) return render_to_response('projects/project_form_access_control.html', { 'project_permission': True, 'project': project, 'form': form, }, context_instance=RequestContext(request))
def lock_and_get_translation_file(request, project_slug, resource_slug, lang_code): """ Lock and download the translations file. View to lock a resource for the requested language and as a second step to download (export+download) the translations in a formatted file. """ resource = get_object_or_404(Resource, project__slug=project_slug, slug=resource_slug) # Permissions handling # Project should always be available project = get_object_or_404(Project, slug=project_slug) team = Team.objects.get_or_none(project, lang_code) check = ProjectPermission(request.user) if not check.submit_translations(team or project) or not \ resource.accept_translations: return permission_denied(request) language = get_object_or_404(Language, code=lang_code) lock = Lock.objects.get_valid(resource, language) can_lock = Lock.can_lock(resource, language, request.user) response = {} if not can_lock: #print_gray_text(You cannot assign this file to you) response['status'] = "FAILED" response['message'] = _("Sorry, you cannot lock this file!") else: # User can lock if not lock: try: # Lock the resource now Lock.objects.create_update(resource, language, request.user) response['status'] = 'OK' response['redirect'] = reverse( 'download_for_translation', args=[resource.project.slug, resource.slug, lang_code]) except: response['status'] = "FAILED" response['message'] = _("Failed to lock the resource!") else: if lock.owner == request.user: try: # File already locked by me, so extend the lock period. Lock.objects.create_update(resource, language, request.user) response['status'] = 'OK' response['redirect'] = reverse( 'download_for_translation', args=[resource.project.slug, resource.slug, lang_code]) except: response['status'] = "FAILED" response['message'] = _("Failed to extend lock period on " "the resource!") else: # File locked by someone else: response['status'] = "FAILED" response['message'] = _( "You cannot lock it right now! (Locked " "by %s )" % (lock.owner, )) return HttpResponse(simplejson.dumps(response), mimetype='application/json')
def push_translation(request, project_slug, lang_code, *args, **kwargs): """ Client pushes an id and a translation string. Id is considered to be of the source translation string and the string is in the target_lang. FIXME: Document in detail the form of the 'strings' POST variable. """ logger.debug("POST data when saving translation: %s" % request.POST) # Permissions handling # Project should always be available project = get_object_or_404(Project, slug=project_slug) team = Team.objects.get_or_none(project, lang_code) check = ProjectPermission(request.user) if not check.submit_translations(team or project) and not\ check.maintain(project): return permission_denied(request) if not request.POST: return HttpResponseBadRequest() data = simplejson.loads(request.raw_post_data) strings = data["strings"] try: target_language = Language.objects.by_code_or_alias(lang_code) except Language.DoesNotExist: raise Http404 # This dictionary will hold the results of the save operation and will map # status code for each translation pushed, to indicate the result on each # translation push separately. push_response_dict = {} # Form the strings dictionary, get as Json object # The fields are the following: # id-> source_entity id # translations-> translation strings (includes all plurals) # context-> source_entity context # occurrence-> occurrence (not yet well supported) # Iterate through all the row data that have been sent. for row in strings: source_id = int(row['id']) try: source_string = Translation.objects.select_related(depth=1).get( id=source_id) except Translation.DoesNotExist: # TODO: Log or inform here push_response_dict[source_id] = { 'status': 400, 'message': _("Source string cannot be identified in the DB") } # If the source_string cannot be identified in the DB then go to next # translation pair. continue if not source_string.resource.accept_translations: push_response_dict[source_id] = { 'status': 400, 'message': _("The resource of this source string is not " "accepting translations.") } # If the translated source string is pluralized check that all the # source language supported rules have been filled in, else return error # and donot save the translations. if source_string.source_entity.pluralized: error_flag = False for rule in target_language.get_pluralrules(): if rule in row[ 'translations'] and row['translations'][rule] != "": continue else: error_flag = True if error_flag: error_flag = False # Check also if all of them are "". If yes, delete all the plurals! for rule in target_language.get_pluralrules(): if rule in row['translations'] and row['translations'][ rule] == "": continue else: error_flag = True if error_flag: push_response_dict[source_id] = { 'status': 400, 'message': (_("Cannot save unless plural translations are either " "completely specified or entirely empty!")) } # Skip the save as we hit on an error. continue try: msgs = _save_translation(source_string, row['translations'], target_language, request.user) if not msgs: push_response_dict[source_id] = {'status': 200} else: push_response_dict[source_id] = { 'status': 200, 'message': msgs[-1] } except LotteBadRequestError, e: push_response_dict[source_id] = { 'status': 400, 'message': e.message } except Exception, e: logger.error("Unexpected exception raised: %s" % e.message, exc_info=True) push_response_dict[source_id] = { 'status': 400, 'message': e.message }
def translate(request, project_slug, lang_code, resource_slug=None, *args, **kwargs): """ Main lotte view. """ # Permissions handling # Project should always be available project = get_object_or_404(Project, slug=project_slug) team = Team.objects.get_or_none(project, lang_code) check = ProjectPermission(request.user) if not check.submit_translations(team or project) and not\ check.maintain(project): return permission_denied(request) resources = [] if resource_slug: resource_list = [ get_object_or_404(Resource, slug=resource_slug, project=project) ] else: resource_list = Resource.objects.filter(project=project) # Return a page explaining that the project has multiple source langs and # cannot be translated as a whole. if resource_list.values('source_language').distinct().count() > 1: messages.info( request, _("There are multiple source languages for this project. " "You will only be able to translate resources for one " "source language at a time.")) return HttpResponseRedirect( reverse('project_detail', args=[project_slug]), ) # Filter resources that are not accepting translations for resource in resource_list: if resource.accept_translations: resources.append(resource) # If no resource accepting translations, raise a 403 if not resources: return permission_denied(request) target_language = Language.objects.by_code_or_alias_or_404(lang_code) # If it is an attempt to edit the source language, redirect the user to # resource_detail and show him a message explaining the reason. if target_language == get_source_language(resources): messages.error( request, _("Cannot edit the source language because this would " "result in translation mismatches! If you want to " "update the source strings consider using the transifex " "command-line client.")) if resource_slug: return HttpResponseRedirect( reverse('resource_detail', args=[project_slug, resource_slug]), ) else: return HttpResponseRedirect( reverse('project_detail', args=[project_slug]), ) total_strings = SourceEntity.objects.filter(resource__in=resources).count() translated_strings = Translation.objects.filter( resource__in=resources, language=target_language, source_entity__pluralized=False, rule=5).count() reviewed_strings = Translation.objects.filter( resource__in=resources, language=target_language, source_entity__pluralized=False, rule=5, reviewed=True).count() # Include counting of pluralized entities for pluralized_entity in SourceEntity.objects.filter( resource__in=resources, pluralized=True): plurals_translated = Translation.objects.filter( language=target_language, source_entity=pluralized_entity).count() if plurals_translated == len(target_language.get_pluralrules()): translated_strings += 1 if len(resources) > 1: translation_resource = None else: translation_resource = resources[0] contributors = User.objects.filter(pk__in=Translation.objects.filter( resource__in=resources, language=target_language, rule=5).values_list( "user", flat=True)) lotte_init.send(None, request=request, resources=resources, language=target_language) if target_language in [team.language for team in project.available_teams]: team_language = True else: team_language = False GtModel = get_model('gtranslate', 'Gtranslate') try: auto_translate = GtModel.objects.get(project=project) except GtModel.DoesNotExist: auto_translate = None """ if cache.get('lotte_%s' % request.session.session_key, None): cache.delete('lotte_%s' % request.session.session_key) """ #Set rtl to True if target_language is an RTL language rtl = False if target_language.code in settings.RTL_LANGUAGE_CODES: rtl = True return render_to_response("translate.html", { 'project': project, 'resource': translation_resource, 'target_language': target_language, 'translated_strings': translated_strings, 'reviewed_strings': reviewed_strings, 'untranslated_strings': total_strings - translated_strings, 'contributors': contributors, 'resources': resources, 'resource_slug': resource_slug, 'languages': Language.objects.all(), 'auto_translate': auto_translate, 'spellcheck_supported_langs': SPELLCHECK_SUPPORTED_LANGS, 'team_language': team_language, 'RTL': rtl, }, context_instance=RequestContext(request))
def proofread(request, project_slug, lang_code, resource_slug=None, *args, **kwargs): """AJAX view that sets the reviewed flag on Translations to true or false. The request data is expected in JSON, with the following format: { 'true': [1,2,3] 'false': [4,5] } Note: The IDs are source entity IDs. """ if request.method != 'POST': return HttpResponse(status=405) project = get_object_or_404(Project, slug=project_slug) resource = get_object_or_404(Resource, slug=resource_slug, project=project) try: language = Language.objects.by_code_or_alias(lang_code) except Language.DoesNotExist: raise Http404 # Check if the user has the necessary permissions to review strings. check = ProjectPermission(request.user) if not check.proofread(project, language): return permission_denied(request) request_data = simplejson.loads(request.raw_post_data) if 'true' in request_data: source_entity_ids = request_data['true'] translations = Translation.objects.filter( source_entity__id__in=source_entity_ids, language__code=lang_code, ) translations.update(reviewed=True) ReviewHistory.add_many(translations, request.user, project.id, reviewed=True) if 'false' in request_data: source_entity_ids = request_data['false'] translations = Translation.objects.filter( source_entity__id__in=source_entity_ids, language__code=lang_code, ) translations.update(reviewed=False) ReviewHistory.add_many(translations, request.user, project.id, reviewed=False) invalidate_stats_cache(resource, language, user=request.user) return HttpResponse(status=200)
def exit(request, project_slug, lang_code, resource_slug=None, *args, **kwargs): """ Exiting Lotte """ if request.method != 'POST': return HttpResponse(status=405) # Permissions handling # Project should always be available project = get_object_or_404(Project, slug=project_slug) team = Team.objects.get_or_none(project, lang_code) check = ProjectPermission(request.user) if not check.submit_translations(team or project) and not\ check.maintain(project): return permission_denied(request) language = Language.objects.by_code_or_alias(lang_code) resources = [] if resource_slug: resources = Resource.objects.filter(slug=resource_slug, project=project) if not resources: raise Http404 else: resources = Resource.objects.filter(project=project) data = simplejson.loads(request.raw_post_data) if data.get('updated'): modified = True # ActionLog & Notification for resource in resources: nt = 'project_resource_translated' context = { 'project': project, 'resource': resource, 'language': language, 'sender': request.user } object_list = [project, resource, language] if team: object_list.append(team) action_logging(request.user, object_list, nt, context=context) else: modified = False lotte_done.send(None, request=request, resources=resources, language=language, modified=modified) redirect_url = reverse('team_detail', args=[project_slug, language.code]) if request.is_ajax(): json = simplejson.dumps(dict(redirect=redirect_url)) return HttpResponse(json, mimetype='application/json') return HttpResponseRedirect(redirect_url)