Produits Entr'ouvert » Combo

        from .models import WcsFormCell, WcsCategoryCell, WcsFormsOfCategoryCell, WcsCardsCell, WcsCardInfosCell

        models_to_update = [WcsFormCell, WcsCategoryCell, WcsFormsOfCategoryCell, WcsCardsCell, WcsCardInfosCell]

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

from __future__ import unicode_literals

import combo.apps.wcs.models

from django.db import migrations, models

import django.db.models.deletion

import jsonfield.fields

class Migration(migrations.Migration):

    dependencies = [

        ('auth', '0008_alter_user_username_max_length'),

        ('data', '0045_link_list_limit'),

        ('wcs', '0020_cards'),

    ]

    operations = [

        migrations.CreateModel(

            name='WcsCardInfosCell',

            fields=[

                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

                ('placeholder', models.CharField(max_length=20)),

                ('order', models.PositiveIntegerField()),

                ('slug', models.SlugField(blank=True, verbose_name='Slug')),

                ('extra_css_class', models.CharField(blank=True, max_length=100, verbose_name='Extra classes for CSS styling')),

                ('public', models.BooleanField(default=True, verbose_name='Public')),

                ('restricted_to_unlogged', models.BooleanField(default=False, verbose_name='Restrict to unlogged users')),

                ('last_update_timestamp', models.DateTimeField(auto_now=True)),

                ('carddef_reference', models.CharField(max_length=150, verbose_name='Card Model')),

                ('cached_title', models.CharField(max_length=150, verbose_name='Title')),

                ('cached_json', jsonfield.fields.JSONField(blank=True, default=dict)),

                ('groups', models.ManyToManyField(blank=True, to='auth.Group', verbose_name='Groups')),

                ('page', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='data.Page')),

            ],

            options={

                'verbose_name': 'Card Information Cell',

            },

            bases=(combo.apps.wcs.models.CardMixin, models.Model),

        ),

    ]

class CardMixin(object):

    invalid_reason_codes = invalid_reason_codes

    def populate_cache(self, store_json=False):

        if self.carddef_reference:

            wcs_key, card_slug = self.carddef_reference.split(':')

            wcs_site = get_wcs_services().get(wcs_key)

            card_models = get_wcs_json(wcs_site, 'api/cards/@list')

            if not card_models:

                # can not retrieve data, don't report cell as invalid

                self.mark_as_valid()

                return

            card_found = False

            for card in card_models.get('data', []):

                slug = card['slug']

                if slug == card_slug:

                    self.cached_title = card['title']

                    if store_json:

                        self.cached_json = card

                        self.save(update_fields=['cached_title', 'cached_json'])

                    else:

                        self.save(update_fields=['cached_title'])

                    card_found = True

                    break

            if card_found:

                self.mark_as_valid()

                return

            else:

                return self.mark_as_invalid('wcs_card_not_found')

        else:

            return self.mark_as_invalid('wcs_card_not_defined')

    def is_relevant(self, context):

        return bool(self.carddef_reference)

    def get_default_form_class(self):

        from .forms import WcsCardsCellForm

        return WcsCardsCellForm

    @property

    def wcs_site(self):

        return self.carddef_reference.split(':')[0]

    def get_additional_label(self):

        if not self.cached_title:

            return

        return self.cached_title

class WcsCardsCell(CardMixin, WcsBlurpMixin, CellBase):

        if 'update_fields' in kwargs:

            # don't populate the cache

            return

        self.populate_cache()

@register_cell_class

class WcsCardInfosCell(CardMixin, CellBase):

    carddef_reference = models.CharField(_('Card Model'), max_length=150)

    cached_title = models.CharField(_('Title'), max_length=150)

    cached_json = JSONField(blank=True)

    is_enabled = classmethod(is_wcs_enabled)

    template_name = 'combo/wcs/card.html'

    class Meta:

        verbose_name = _('Card Information Cell')

    def save(self, *args, **kwargs):

        super().save(*args, **kwargs)

        if 'update_fields' in kwargs:

            # don't populate the cache

            return

        self.populate_cache(store_json=True)

    def get_cell_extra_context(self, context):

        extra_context = super().get_cell_extra_context(context)

        extra_context['title'] = self.cached_title

        card_id = '%s_id' % self.carddef_reference.split(':')[1]

        if not context.get(card_id):

            return extra_context

        api_url = 'api/cards/%s/%s/' % (self.carddef_reference.split(':')[1], context.get(card_id))

        wcs_site = get_wcs_services().get(self.wcs_site)

        response = requests.get(

                api_url,

                remote_service=wcs_site,

                user=getattr(context.get('request'), 'user', None),

                cache_duration=5,

                raise_if_not_cached=not(context.get('synchronous')),

                log_errors=False)

        if response.status_code == 200:

            extra_context['card'] = response.json()

        return extra_context

{% load assets i18n %}

{% block cell-content %}

<div class="card">

{% block cell-header %}

<h2>{{ title }}{% if card %} - {{ card.text }}{% endif %}</h2>

{% include "combo/asset_picture_fragment.html" %}

{% endblock %}

{% if card %}

{% for key, value in card.fields.items|dictsort:0 %}

    {% if not key|endswith:'_raw' and not key|endswith:'_structured' %}

    <p><span class="label">{{ key }}</span> <span class="value">{{ value|default:"" }}</span></p>

    {% endif %}

{% endfor %}

{% else %}

<p>{% trans 'Unknown Card' %}</p>

{% endif %}

</div>

{% endblock %}

        assert len(ctx.captured_queries) == 223

    WcsCardsCell, WcsCardInfosCell)

WCS_CARD_DATA = {

    'id': 11,

    'display_id': '10-11',

    'display_name': 'Card Model 1 - n°10-11',

    'digest': 'a a a',

    'text': 'aa',

    'url': '/backoffice/data/card_model_1/11/',

    'fields': {

        'fielda': 'a',

        'fieldb': 'b',

        'related': 'Foo Bar',

        'related_raw': 42,

        'related_structured': {'id': 42, 'text': 'blah'},

    }

}

    if 'api/cards/card_model_1/11/' in url:

        return WCS_CARD_DATA

    if 'api/cards/card_model_1/list' in url:

    if not isinstance(data, list):

        return MockedRequestResponse(content=json.dumps(data))

@pytest.mark.parametrize('cell_class', [WcsCardsCell, WcsCardInfosCell])

def test_card_cells_setup(mock_send, cell_class):

    cell = cell_class()

@pytest.mark.parametrize('cell_class', [WcsCardsCell, WcsCardInfosCell])

def test_card_cells_validity(mock_send, cell_class):

    cell = cell_class.objects.create(page=page, placeholder='content', order=0)

@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)

def test_card_cell_save_cache(mock_send):

    page = Page.objects.create(title='xxx', slug='test_cards_cell_save_cache', template_name='standard')

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    assert cell.get_additional_label() is None

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

    assert cell.cached_title == 'Card Model 1'

    assert cell.cached_json == {'slug': 'card_model_1', 'title': 'Card Model 1'}

    assert cell.get_additional_label() == 'Card Model 1'

    # make sure cached attributes are removed from serialized pages

    assert 'cached_' not in json.dumps(page.get_serialized_page())

    # artificially change title and json

    WcsCardInfosCell.objects.filter(pk=cell.pk).update(cached_title='XXX', cached_json={})

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_title == 'XXX'

    # run update db cache

    appconfig = apps.get_app_config('wcs')

    appconfig.update_db_cache()

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_title == 'Card Model 1'

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_json == {'slug': 'card_model_1', 'title': 'Card Model 1'}

@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)

def test_card_cell_load(mock_send):

    page = Page.objects.create(title='xxx', slug='test_cards', template_name='standard')

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

    site_export = [page.get_serialized_page()]

    cell.delete()

    assert not Page.objects.get(pk=page.pk).get_cells()

    Page.load_serialized_pages(site_export)

    page = Page.objects.get(slug='test_cards')

    cells = page.get_cells()

    assert len(cells) == 1

    cell = cells[0]

    assert cell.cached_title == 'Card Model 1'

    assert cell.cached_json == {'slug': 'card_model_1', 'title': 'Card Model 1'}

@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)

def test_card_cell_render(mock_send, context):

    page = Page.objects.create(title='xxx', template_name='standard')

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    cell.carddef_reference = u'default:card_model_1'

    cell.save()

    # card id not in context

    assert 'card_model_1_id' not in context

    result = cell.render(context)

    assert '<h2>Card Model 1</h2>' in result

    assert '<p>Unknown Card</p>' in result

    context['card_model_1_id'] = 11

    # query should fail as nothing is cached

    cache.clear()

    with pytest.raises(NothingInCacheException):

        result = cell.render(context)

    context['synchronous'] = True  # to get fresh content

    result = cell.render(context)

    assert '<h2>Card Model 1 - aa</h2>' in result

    assert '<span class="label">fielda</span> <span class="value">a</span>' in result

    assert '<span class="label">fieldb</span> <span class="value">b</span>' in result

    assert '<span class="label">related</span> <span class="value">Foo Bar</span>' in result

    assert 'related_raw' not in result

    assert 'related_structured' not in result