wikipedia-transifex

# -*- coding: utf-8 -*-

"""

Django app to interact with Transifex.

"""

from txapp.init import setup

setup()

# -*- coding: utf-8 -*-

"""

Auth framework for the client of the API.

"""

import os

import base64

import hashlib

import binascii

from txapp.models import AuthToken

def generate_token(length=16):

    """Generate a new authentication token."""

    return base64.b64encode(os.urandom(length))

def create_auth_token(project):

    """Create and save an authentication token to be used for the project.

    Args:

        project: The project the token is for.

    Returns:

        The token.

    """

    token = generate_token()

    auth_info, created = AuthToken.objects.get_or_create(project=project)

    auth_info.token = _hash_token(token)

    auth_info.save()

    return token

def clear_auth_token(project):

    """Clear the authentication token used by a project."""

    AuthToken.objects.filter(project=project).delete()

def auth_token_exists(project):

    """Return whether an auth token for the proejct exists already.

    Args:

        project: The project to check whether an auth token exists for.

    Returns:

        True, if it exists, else false.

    """

    return AuthToken.objects.filter(project=project).exists()

def authenticate(project_slug, token):

    """Authenticate a project against the given token.

    Args:

        project_slug: The slug of the project to authenticate.

        token: The authentication token.

    Returns:

        True for success, False for failure.

    """

    try:

        auth = AuthToken.objects.get(project__slug=project_slug)

    except AuthToken.DoesNotExist:

        return False

    salt = auth.token.split('$')[2]

    hashed_token = _hash_token(token, salt)

    # protect against timing attacks

    return int(binascii.b2a_hex(auth.token), 16) ^ int(binascii.b2a_hex(hashed_token), 16) == 0

def _hash_token(token, salt_used=None):

    """Hash the token using the SHA512 function."""

    salt = base64.b64encode(os.urandom(4)) if salt_used is None else salt_used

    algo_id = "6"               # see man 3 crypt

    h = hashlib.sha512(salt)

    h.update(token)

    return "$".join(['', algo_id, salt, h.hexdigest()]).decode()

def _do_match(hashed_token, token):

    """Check whether the hash of the token is the hashed_token.

    Use a XOR operation to avoid timing attacks.

    """

    hashed_token = hashed_token[1:]

    (algo_id, salt, digest) = hashed_token.split('$')

    assert algo_id == 6

    new_digest = _hash_token(token, salt=salt)

    return digest ^ new_digest == 0

# -*- coding: utf-8 -*-

"""

Exceptions for a TxApp.

"""

class TxAppError(Exception):

    """Base class for all TxApp related exceptions."""

class NetworkError(Exception):

    """There was a network error while contacting Transifex."""

class ApiError(Exception):

    """There was an error with the API request."""

class AuthError(Exception):

    """There was an authentication error with the API request."""

# -*- coding: utf-8 -*-

"""

Initialization functions for txapp.

"""

from django.conf import settings

from txlib.http.http_requests import HttpRequest

from txlib.registry import registry

def setup():

    """Setup Transifex related functions."""

    registry.http_handler = HttpRequest(settings.TX_URL)

# -*- coding: utf-8 -*-

"""

Log settings for txapp.

"""

import logging

logger = logging.getLogger('txapp')

from django.db import models

class Project(models.Model):

    """Save the settings per project."""

    slug = models.SlugField(

        verbose_name='Slug', max_length=30, primary_key=True,

        help_text=('A short label to be used in the URL, containing only '

                   'letters, numbers, underscores or hyphens.')

    )

    source_language = models.CharField(

        verbose_name='Drupal source language', max_length=10, default='en',

        help_text="The language code used in the Drupal installation."

    )

    def __unicode__(self):

        return u"<Project: %s>" % self.slug

class AuthToken(models.Model):

    """Authentication token for projects."""

    token = models.CharField(

        'Token', max_length=100,

        help_text="The authentication token used by the other end-point."

    )

    project = models.OneToOneField(

        'Project', verbose_name='Project', unique=True,

        help_text="The project this token is for."

    )

class LanguageMapping(models.Model):

    """Save language mappings."""

    tx_lang = models.CharField(

        verbose_name='Transifex language', max_length=10, unique=True,

        help_text="The language code on the Tx side."

    )

    remote_lang = models.CharField(

        verbose_name="Remote langauge", max_length=10, unique=True,

        help_text="The language code on the remote side."

    )

# -*- coding: utf-8 -*-

from django.utils import simplejson as json

from django.template.response import TemplateResponse

class TxTemplateResponse(TemplateResponse):

    """Transifex specific response class."""

    @property

    def rendered_content(self):

        """

        Render the content.

        Convert the content to a suitable json-encoded string to send to

        Transifex.

        """

        content = super(TxTemplateResponse, self).rendered_content

        return self._convert_to_json(content)

    def _convert_to_json(self, content):

        """Convert the content to a json-encoded string along

        with any other information necessary.

        """

        data = {'content': content}

        return json.dumps(data)

# -*- coding: utf-8 -*-

"""

Signals raised by txapp.

"""

from django.dispatch import Signal

# Signal raised whenever Transifex informs us about an update in a resource.

translation_updated_signal = Signal(

    providing_args=["project", "resource", "language", "percentage", ]

)

{% block txapp_body %}

{% endblock %}

{% block txapp_body %}

<p>Default overview</p>

{% endblock %}

{% block txapp_body %}

<p>Default settings</p>

{% endblock %}

"""

This file demonstrates writing tests using the unittest module. These will pass

when you run "manage.py test".

Replace this with more appropriate tests for your application.

"""

from django.test import TestCase

from txapp.auth import generate_token, _hash_token, _match_token

class TestAuth(TestCase):

    """Test the authentication framework."""

    def test_hash_format(self):

        """Test the format of the hash generated."""

        token = generate_token()

        hashed = _hash_token(token)

        self.assertEqual(hashed.count('$'), 4)

    def test_check_match(self):

        token1 = generate_token()

        original_digest = _hash_token(token1)

        self.assertTrue(_match_token(original_digest, token1))

        token2 = ~token1

        self.assertFalse(_match_token(original_digest, token2))

# -*- coding: utf-8 -*-

"""

Tx API related functions.

TODO: Fine-grained handling of the exceptions (see docstrings).

"""

from txlib.api.resources import Resource

from txlib.api.translations import Translation

from txapp.exceptions import NetworkError, ApiError, AuthError

from txapp.models import Project

from txapp.log import logger

def create_resource(project_slug, resource_slug, **kwargs):

    """Create a resource to Tx through the API.

    There are certain variables the user must submit, documented in the API of

    Transifex. All arguments should be passed as keyword arguments.

    Args:

        project_slug: The slug of the project in Transifex under which the

            resource will be created.

        resource_slug: The slug of the new resource.

        name: The name of the new resource.

        i18n_type: The type of the new resource.

        source_language: The source language for the new resource. Default is

            'en'.

        content: The source content of the new resource.

        auth: The authentication info to use in the API calls.

    Raises:

        NetworkError, in case of a network error in contacting Transifex.

        ApiError, in case of an error with the API request.

        AuthError, in case of an authentication error with the API reuqest.

    """

    try:

        name = kwargs['name']

        i18n_type = kwargs['i18n_type']

        auth = kwargs['auth']

        content = kwargs['content']

        source_language = kwargs.get('source_language', 'en')

    except KeyError, e:

        logger.error("Error in arguments: %s" % e)

        raise ArgumentError(unicode(e))

    logger.debug("Creating the resource %s.%s" % (project_slug, resource_slug))

    p = Project.objects.get(slug=project_slug)

    try:

        r = Resource(

            project_slug=project_slug, slug=resource_slug, auth=auth

        )

    except Exception, e:

        logger.error(unicode(e), exc_info=True)

        raise

    r.name = name

    r.mimetype = i18n_type

    r.content = content

    r.source_language = source_language

    try:

        r.save()

        logger.info("Created resource %s.%s" % (project_slug, resource_slug))

    except Exception, e:

        logger.error("Error creating resource: %s" % unicode(e), exc_info=True)

        raise ApiError(unicode(e))

def update_source_content(project_slug, resource_slug, **kwargs):

    """Update the source content of a resource through the API.

    Args:

        project_slug: The slug of the project the resource belongs to.

        resource_slug: The slug of the resource to update.

        content: The source content of the new resource.

        auth: The authentication info to use in the API calls.

    Raises:

        NetworkError, in case of a network error in contacting Transifex.

        ApiError, in case of an error with the API request.

        AuthError, in case of an authentication error with the API reuqest.

    """

    try:

        content = kwargs['content']

        auth = kwargs['auth']

    except KeyError, e:

        logger.error("Error in arguments: %s" % e)

        raise ArgumentError(unicode(e))

    try:

        r = Resource.get(

            project_slug=project_slug, slug=resource_slug, auth=auth

        )

    except Exception, e:

        msg = "Error fetching resource for %s.%s: %s"

        logger.error(msg % (project_slug, resource_slug, e), exc_info=True)

        raise

    r.content = content

    try:

        r.save()

        msg = "Updated source content of resource %s.%s"

        logger.info(msg % (project_slug, resource_slug))

    except Exception, e:

        msg = "Error saving translation for %s.%s: %s"

        logger.error(msg % (project_slug, resource_slug, e), exc_info=True)

        raise

def get_translation(project_slug, resource_slug, language_code, **kwargs):

    """Get a translation for a specific resource throug hthe API.

    Args:

        project_slug: The slug of the project the resource belongs to.

        resource_slug: The slug of the resource to update.

        language_code: The code of the language of the Translation.

    Returns:

        The translated content.

    Raises:

        NetworkError, in case of a network error in contacting Transifex.

        ApiError, in case of an error with the API request.

        AuthError, in case of an authentication error with the API reuqest.

    """

    try:

        auth = kwargs['auth']

    except KeyError, e:

        logger.error("Error in arguments: %s" % e)

        raise ArgumentError(unicode(e))

    try:

        t = Translation.get(

            project_slug=project_slug, slug=resource_slug,

            lang=language_code, auth=auth

        )

    except Exception, e:

        msg = (

            "Error with getting the translation of resource %s.%s "

            "for the language %s: %s"

        )

        logger.error(

            msg % (project_slug, resource_slug, language_code, e),

            exc_info=True

        )

        raise

    return t.content

def delete_resource(project_slug, resource_slug, **kwargs):

    """Delete a resource identified by (project_slug, resource_slug) in

    Transifex.

    Args:

        project_slug: The slug of the project the resource belongs to.

        resource_slug: The slug of the resource to delete.

    Raises:

        NetworkError, in case of a network error in contacting Transifex.

        ApiError, in case of an error with the API request.

        AuthError, in case of an authentication error with the API reuqest.

    """

    try:

        auth = kwargs['auth']

    except KeyError, e:

        logger.error("Error in arguments: %s" % e)

        raise ArgumentError(unicode(e))

    try:

        r = Resource.get(

            project_slug=project_slug, slug=resource_slug, auth=auth

        )

    except Exception, e:

        msg = "Error fetching resource for %s.%s: %s"

        logger.error(msg % (project_slug, resource_slug, e), exc_info=True)

        raise

    try:

        r.delete()

        msg = "Delete resource %s.%s"

        logger.info(msg % (project_slug, resource_slug))

    except Exception, e:

        msg = "Error deleting resource %s.%s: %s"

        logger.error(msg % (project_slug, resource_slug, e), exc_info=True)

        raise

# -*- coding: utf-8 -*-

from django.conf.urls.defaults import *

from txapp.views import translation_updated, register_project, \

        unregister_project

urlpatterns = patterns('',

    url(

        r'^translation_updated/$', translation_updated, name='translation_updated'

    ),

    url(

        r'^register/(?P<project_slug>[-\w]+)$', register_project, name='register_project'

    ),

    url(

        r'^unregister/(?P<project_slug>[-\w]+)$', unregister_project, name='unregister_project'

    ),

)

# -*- coding: utf-8 -*-

"""

Utility functions for a TxApp.

"""

from txapp.models import Project

def register_project(project_slug):

    """Register a project to the TxApp.

    Args:

        project_slug: The slug of the project to register.

    """

    Project.objects.get_or_create(slug=project_slug)

from django.utils import simplejson as json

from django.utils.datastructures import MultiValueDictKeyError

from django.http import HttpResponse, HttpResponseBadRequest

from django.views.generic.base import TemplateView

from django.views.generic.edit import FormView

from txapp.response import TxTemplateResponse

from txapp.signals import translation_updated_signal

from txapp.models import Project

class Overview(TemplateView):

    """A view to present the user with an overview of the app.

    Subclasses should override the template name.

    """

    template_name = "txapp_overview.html"

    response_class = TxTemplateResponse

class Settings(FormView):

    """A view to present the user with the settings for the project.

    Subclasses should override the variables ``template_name``, ``success_url``

    and ``form_class`` and the methods ``get_initial``, ``form_valid`` and

    ``form_invalid``.

    """

    template_name = "txapp_settings.html"

    response_class = TxTemplateResponse

    def form_valid(self, form):

        data = {'next_url': self.get_success_url()}

        return HttpResponse(json.dumps(data))

def translation_updated(request):

    """A view that is called whenever we get a signal from Transifex about

    a resource being updated.

    The view raises the ``translation_updated_signal``, which must be called by

    the app itself.

    """

    if request.method != 'POST':

        return HttpResponseBadRequest(

            "Method '%s' not allowed" % request.method

        )

    try:

        project = request.POST['project']

        resource = request.POST['resource']

        language = request.POST['language']

        percent = request.POST['percent']

    except MultiValueDictKeyError, e:

        return HttpResponseBadRequest("Malformed POST request")

    translation_updated_signal.send(

        sender='Tx', project=project, resource=resource,

        language=language, percent=percent

    )

    return HttpResponse()

def register_project(request, project_slug):

    """Register a project for this app.

    Args:

        project_slug: The slug of the project to register.

    """

    if request.method != 'POST':

        return HttpResponseBadRequest(

            "Method '%s' not allowed" % request.method

        )

    try:

        source_language = request.POST.get('source_language')

        Project.objects.get_or_create(

            slug=project_slug, defaults={'source_language': source_language}

        )

    except Exception, e:

        return HttpResponseBadRequest(unicode(e))

    return HttpResponse('""', status=200)

def unregister_project(request, project_slug):

    """Unregister a project for this app.

    Args:

        project_slug: The slug of the project to unregister.

    """

    if request.method != 'POST':

        return HttpResponseBadRequest(

            "Method '%s' not allowed" % request.method

        )

    try:

        Project.objects.filter(slug=project_slug).delete()

    except Exception, e:

        return HttpResponseBadRequest(unicode(e))

    return HttpResponse('""', status=200)