Produits Entr'ouvert » w.c.s.

    CardDef.wipe()

def test_backoffice_card_field_columns(pub):

    user = create_superuser(pub)

    create_environment(pub)

    datasource = {

        'type': 'formula',

        'value': repr([('A', 'aa'), ('B', 'bb'), ('C', 'cc')])

    }

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'foo'

    carddef.fields = [

        fields.CommentField(id='0', label='...', type='comment'),

        fields.StringField(id='1', label='Test', type='string', varname='foo'),

        fields.DateField(id='2', label='Date', type='date'),

        fields.BoolField(id='3', label='Bool', type='bool'),

        fields.ItemField(id='4', label='Item', type='item', data_source=datasource),

    ]

    carddef.backoffice_submission_roles = user.roles

    carddef.workflow_roles = {'_editor': user.roles[0]}

    carddef.digest_template = 'card {{form_var_foo}}'

    carddef.store()

    carddef.data_class().wipe()

    card = carddef.data_class()()

    card.data = {

        '1': 'plop',

        '2': time.strptime('2020-04-24', '%Y-%m-%d'),

        '3': True,

        '4': 'A',

        '4_display': 'aa',

    }

    card.store()

    formdef = FormDef.get_by_urlname('form-title')

    formdef.geolocations = {'base': 'Geolocation'}

    formdef.fields.append(

        fields.ItemField(id='4', label='card field', type='item',

            data_source={'type': 'carddef:foo', 'value': ''}))

    formdef.store()

    for formdata in formdef.data_class().select(lambda x: x.status == 'wf-new'):

        formdata.data['4'] = str(card.id)

        formdata.data['4_display'] = formdef.fields[-1].store_display_value(formdata.data, '4')

        formdata.data['4_structured'] = formdef.fields[-1].store_structured_value(formdata.data, '4')

        formdata.geolocations = {'base': {'lat': 48.83, 'lon': 2.32}}

        formdata.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/management/form-title/')

    assert resp.text.count('</th>') == 8  # six columns

    if not pub.is_using_postgresql():

        # no support for relation columns unless using SQL

        assert '4$1' not in resp.forms['listing-settings'].fields

        return

    assert '4$0' not in resp.forms['listing-settings'].fields

    resp.forms['listing-settings']['4$1'].checked = True

    resp.forms['listing-settings']['4$2'].checked = True

    resp.forms['listing-settings']['4$3'].checked = True

    resp.forms['listing-settings']['4$4'].checked = True

    resp = resp.forms['listing-settings'].submit()

    assert resp.text.count('</th>') == 12

    assert resp.text.count('data-link') == 17  # 17 rows

    assert resp.text.count('<td>plop</td>') == 17

    assert resp.text.count('<td>2020-04-24</td>') == 17

    assert resp.text.count('<td>Yes</td>') == 17

    assert resp.text.count('<td>aa</td>') == 17

    resp_csv = resp.click('Export as CSV File')

    assert resp_csv.text.splitlines()[1].endswith(',plop,2020-04-24,Yes,aa')

    resp_ods = resp.click('Export a Spreadsheet')

    resp_map = resp.click('Plot on a Map')

    geojson_url = re.findall(r'data-geojson-url="(.*?)"', resp_map.text)[0]

    resp_geojson = app.get(geojson_url)

    assert {'varname': None, 'label': 'card field - Test', 'value': 'plop', 'html_value': 'plop'} in resp_geojson.json['features'][0]['properties']['display_fields']

        for field in fake_fields + list(self.get_formdef_fields()):

            seen_parents = set()

                classnames = ''

                attrs = ''

                if isinstance(field, RelatedField):

                    classnames = 'related-field'

                    if field.parent_field.id in seen_parents:

                        classnames += ' collapsed'

                    attrs = 'data-relation-attr="%s"' % field.parent_field.id

                elif getattr(field, 'has_relations', False):

                    classnames = 'has-relations-field'

                    attrs = 'data-field-id="%s"' % field.id

                    seen_parents.add(field.id)

                r += htmltext('<li class="%s" %s><span class="handle">⣿</span>' % (classnames, attrs))

                r += htmltext('<label><input type="checkbox" name="%s"') % field.id

                if getattr(field, 'has_relations', False):

                    r += htmltext('<button class="expand-relations"></button>')

        yield FakeField('id', 'id', _('Number'))

            yield FakeField('submission_channel', 'submission_channel', _('Channel'))

            yield FakeField('submission_agent', 'submission_agent', _('Submission By'))

        yield FakeField('time', 'time', _('Created'))

        yield FakeField('last_update_time', 'last_update_time', _('Last Modified'))

        yield FakeField('user-label', 'user-label', _('User Label'))

        for field in self.formdef.get_all_fields():

            yield field

            if not get_publisher().is_using_postgresql():

                continue

            if not (field.type == 'item' and

                    field.data_source and

                    field.data_source.get('type', '').startswith('carddef:')):

                continue

            try:

                carddef = CardDef.get_by_urlname(field.data_source['type'][8:])

            except KeyError:

                continue

            for card_field in carddef.get_all_fields():

                if not hasattr(card_field, 'get_view_value'):

                    continue

                field.has_relations = True

                yield RelatedField(carddef, card_field, field)

        yield FakeField('status', 'status', _('Status'))

        yield FakeField('anonymised', 'anonymised', _('Anonymised'))

        for filter_field in fake_fields + list(self.get_formdef_fields()):

                        fields, self.selected_filter, user=user, query=query,

                        fields, self.selected_filter, user=user, query=query,

                        fields, self.selected_filter, user=user, query=query,

            None, selected_filter, user=user, query=query, criterias=criterias,

                fields, selected_filter, user=user, query=query, criterias=criterias)

                        fields, selected_filter, user=user, query=query, criterias=criterias)

class RelatedField:

    is_related_field = True

    type = 'related-field'

    store_display_value = None

    varname = None

    def __init__(self, carddef, field, parent_field):

        self.carddef = carddef

        self.carddef_field = field

        self.parent_field = parent_field

    @property

    def id(self):

        return '%s$%s' % (self.parent_field.id, self.carddef_field.id)

    @property

    def label(self):

        return '%s - %s' % (self.parent_field.label, self.carddef_field.label)

    def get_view_value(self, value, **kwargs):

        if value is None:

            return ''

        if isinstance(value, bool):

            return _('Yes') if value else _('No')

        if isinstance(value, datetime.date):

            return misc.strftime(misc.date_format(), value)

        return value

    def get_view_short_value(self, value, max_len=30, **kwargs):

        return self.get_view_value(value)

    def get_csv_heading(self):

        return [self.label]

    def get_csv_value(self, value, **kwargs):

        return [self.get_view_value(value)]

                            fields, selected_filter, offset, limit, query, order_by,

            elif hasattr(f, 'column_id'):

                field_sort_key = None

    def get_listing_items(self, fields=None, selected_filter='all', offset=None,

        kwargs = {}

        if get_publisher().is_using_postgresql():

            kwargs['fields'] = fields

                    keep_order=True, **kwargs)

            items = formdata_class.get_ids(item_ids, keep_order=True, **kwargs)

ul.columns-filter li.collapsed {

	display: none;

}

ul.columns-filter button.expand-relations {

	position: absolute;

	right: 0;

	top: 0;

	height: 100%;

	border: none;

}

ul.columns-filter button.expand-relations::before {

	font-family: FontAwesome;

	content: "\f107";  /* angle-down */

}

ul.columns-filter button.expand-relations.opened::before {

	content: "\f106";  // angle-up

}

    $dialog_filter.find('button.expand-relations').each(function(elem, i) {

      $(this).removeClass('opened');

      var field_id = $(this).parents('li.has-relations-field').data('field-id');

      $(this).parents('li').find('~ li[data-relation-attr=' + field_id + ']').addClass('collapsed');

    });

    $dialog_filter.find('button.expand-relations').on('click', function() {

      $(this).toggleClass('opened');

      var field_id = $(this).parents('li.has-relations-field').data('field-id');

      $(this).parents('li').find('~ li[data-relation-attr=' + field_id + ']').toggleClass('collapsed');

      return false;

    });

    def get_ids(cls, ids, ignore_errors=False, **kwargs):

    def get_ids(cls, ids, ignore_errors=False, keep_order=False, fields=None):

        tables = [cls._table_name]

        columns = ['%s.%s' % (cls._table_name, column_name) for column_name in

                    [x[0] for x in cls._table_static_fields] + cls.get_data_fields()]

        extra_fields = []

        if fields:

            # look for relations

            for field in fields:

                if not getattr(field, 'is_related_field', False):

                    continue

                carddef_dataclass = field.carddef.data_class()

                carddef_table_alias = 't%s' % id(field.carddef)

                carddef_table_decl = 'LEFT JOIN %s AS %s ON (CAST(%s.%s AS INTEGER) = %s.id)' % (

                        carddef_dataclass._table_name,

                        carddef_table_alias,

                        cls._table_name,

                        get_field_id(field.parent_field),

                        carddef_table_alias)

                if carddef_table_decl not in tables:

                    tables.append(carddef_table_decl)

                column_field_id = get_field_id(field.carddef_field)

                if field.carddef_field.store_display_value:

                    column_field_id += '_display'

                columns.append('%s.%s' % (carddef_table_alias, column_field_id))

                extra_fields.append(field.id)

                            WHERE %s.id IN (%s)''' % (

                                    ', '.join(columns),

                                    ' '.join(tables),

        objects = cls.get_objects(cur, extra_fields=extra_fields)

    def get_objects_iterator(cls, cur, ignore_errors=False, extra_fields=None):

            yield cls._row2ob(row, extra_fields=extra_fields)

    def get_objects(cls, cur, ignore_errors=False, iterator=False, extra_fields=None):

        generator = cls.get_objects_iterator(

                cur=cur,

                ignore_errors=ignore_errors,

                extra_fields=extra_fields)

    def _row2ob(cls, row, extra_fields=None):

        if extra_fields:

            # extra fields are tuck at the end

            for i, field_id in enumerate(reversed(extra_fields)):

                o.data[field_id] = row[-(i + 1)]

            pass

    def _row2ob(cls, row, **kwargs):

    def _row2ob(cls, row, **kwargs):

    def _row2ob(cls, row, **kwargs):

    def _row2ob(cls, row, **kwargs):

    def _row2ob(cls, row, **kwargs):