Produits Entr'ouvert » Passerelle

import collections

from django.utils.html import mark_safe, format_html, conditional_escape, escape

from django.utils.translation import ugettext as _

def render_json_schema(schema):

    if not isinstance(schema, dict):

        if schema is True:

            return mark_safe('<em>ALWAYS VALID</em>')

        if schema is False:

            return mark_safe('<em>ALWAYS INVALID</em>')

        return format_html('<tt>{!r}</tt>', schema)

    def many_of(name, schemas):

        s = format_html('<b>{}</b>', name)

        parts = [render_json_schema(schema) for schema in schemas]

        if any('\n' in part for part in parts):

            s += '<ul>'

            for part in parts:

                s += format_html('<li>{0}</li>\n', part)

            s += '</ul>'

        else:

            s += ' [ ' + ' | '.join(parts) + ' ]'

        return mark_safe(s)

    if 'anyOf' in schema:

        return many_of('anyOf', schema['anyOf'])

    if 'oneOf' in schema:

        return many_of('oneOf', schema['oneOf'])

    if 'allOf' in schema:

        return many_of('allOf', schema['allOf'])

    original_schema = schema

    schema = schema.copy()

    schema.pop('$schema', None)

    schema.pop('$id', None)

    title = schema.pop('title', None)

    description = schema.pop('description', None)

    typ = schema.pop('type', None)

    if typ == 'null':

        return mark_safe('<b>null</b>')

    if typ == 'string':

        enum = schema.pop('enum', [])

        min_length = schema.pop('minLength', '')

        max_length = schema.pop('maxLength', '')

        pattern = schema.pop('pattern', '')

        if enum:

            enum = mark_safe(' | '.join(

                [format_html('"<tt>{}</tt>"', el) for el in enum]))

        s = '<b>string'

        if max_length or min_length:

            s += format_html('[{0}:{1}]', min_length, max_length)

        s += '</b>'

        if enum:

            s += ' %s' % enum

        if pattern:

            s += format_html(' /<tt>{}</tt>/', pattern)

        if schema:

            s += format_html('\n{!r}', schema)

        return mark_safe(s)

    if typ == 'integer':

        if not schema:

            return mark_safe('<b>integer</b>')

    if typ == 'number':

        if not schema:

            return mark_safe('<b>number</b>')

    if typ == 'array':

        s = '<b>array</b> '

        if 'items' in schema:

            s += render_json_schema(schema['items'])

        return mark_safe(s)

    if typ == 'object':

        s = '<b>object</b>'

        unflatten = schema.pop('unflatten', False)

        merge_extra = schema.pop('merge_extra', False)

        properties = schema.pop('properties', {})

        required_keys = schema.pop('required', [])

        additional_properties = schema.pop('additionalProperties', True)

        if unflatten:

            s += ', <em class="unflatten">unflatten</em>'

        if merge_extra:

            s += ', <em class="merge-extra">merge_extra</em>'

        if not additional_properties:

            s += ', <em class="additional-properties-false">no additional properties</em>'

        if title:

            s += format_html(', <em class="title">{}</em>', title)

        if schema:

            s += format_html('<tt class="raw">{!r}</tt>', schema)

        if description:

            s += format_html('\n<p class="description">{}</p>', description)

        s += ' '

        if properties:

            s += '\n<ul>'

            keys = properties

            if not isinstance(properties, collections.OrderedDict):

                keys = sorted(properties, key=lambda key: key.lower())

            for key in keys:

                sub = properties.get(key, {}).copy()

                required = key in required_keys

                # FIXME: workaround wrong schemas in vivaticket, gesbac,

                # planitech, astregs, atal, iparapheur, iws, lille_kimoce

                if sub.get('required') in (True, False):

                    required |= sub.pop('required')

                sub_description = sub.pop('description', '')

                sub_title = sub.pop('title', '')

                s += format_html('<li><tt>{0}</tt>', key)

                if required:

                    s += format_html('<span title="{}" class="required">*</span>', _('required'))

                if description or sub:

                    s += ' :'

                if sub_title:

                    s += format_html(' <em>{0}</em>', sub_title)

                elif sub_description and '\n' not in sub_description:

                    s += format_html(' <em>{0}</em>', sub_description)

                if sub_title or '\n' in sub_description:

                    s += format_html('\n<p class="description">{}</p>', sub_description)

                if sub:

                    s += format_html('\n{0}', render_json_schema(sub))

                s += '</li>'

            s += '</ul>'

        return mark_safe(s)

    if typ == 'boolean':

        if not schema:

            return mark_safe('<b>bool</b>')

    return format_html('<em>unknown {!r}</em>', original_schema)

@register.simple_tag(takes_context=False)

def render_body_schemas(body_schemas):

    if not body_schemas:

        return ''

    s = mark_safe('<ul>')

    for key in body_schemas:

        if key == 'application/json':

            s += mark_safe('<li><tt>application/json</tt> : <span class"json-schema">')

            s += render_json_schema(body_schemas['application/json'])

            s += mark_safe('</span></li>')

        else:

            s += format_html('<li><tt>{0}</tt></li>', key)

    s += mark_safe('<ul>')

    return mark_safe(s)

         {% if endpoint.get_params %}

           <li>{% trans "Query parameters" %}

             <ul class="get-params">

               {% for param in endpoint.get_params %}

                 <li>{{param.name}}

                     {% if param.optional %}({% trans 'optional' %}{% if param.default_value %},

                       {% trans 'default value:' %} {{param.default_value}}{% endif %}){% endif %}

                       {% if param.description %}{% trans ':' %} {{param.description}}{% endif %}

                       <b class="type">{% if param.type %}{{ param.type }}{% else %}string{% endif %}</b>

                 </li>

               {% endfor %}

             </ul>

         {% endif %}

         {% if endpoint.body_schemas %}

           <li>{% trans "Request body" %}

             <div class="body-schemas">

             {% render_body_schemas body_schemas=endpoint.body_schemas %}

             </div>

           </li>

         {% endif %}

    @property

    def body_schemas(self):

        if (self.http_method == 'post'

                and self.post

                and 'request_body' in self.post

                and 'schema' in self.post['request_body']):

            return self.post['request_body']['schema']

        return {}

            if param == 'post_data':

                continue