Produits Entr'ouvert » w.c.s.

    # afterjobs are actually run synchronously during tests; we don't have

    # to wait to check the digest has been updated:

    carddef.digest_templates = {'default': '{{ form_var_foo }}'}

    carddef.store()

    assert 'Existing forms will be updated in the background.' in resp.text

    # afterjobs are actually run synchronously during tests; we don't have

    # to wait to check the digest has been updated:

    resp = app.get('/backoffice/forms/1/options/templates')

    resp.form['lateral_template'] = 'X{{form_var_test}}Y'

    assert len(resp.json['data']) == 1

    assert resp.json['data'][0]['display_id'] == formdata.get_display_id()

    assert resp.json['data'][0]['display_name'] == formdata.get_display_name()

    resp = get_app(pub).get(

        sign_uri('/api/cards/test/list?NameID=%s&full=on' % local_user.name_identifiers[0])

    )

    assert resp.json['data'][0]['fields']['foo'] == 'blah'

    # get single carddata (as signed request without any user specified, so

    # no check for permissions)

    resp = get_app(pub).get(sign_uri('/api/cards/test/%s/' % formdata.id))

    # get schema

    resp = get_app(pub).get(sign_uri('/api/cards/test/@schema'), status=200)

    # check digest is part of contents

    formdef.digest_templates = {'default': 'XYZ'}

    formdef.data_class().get(formdata.id).store()

    resp = get_app(pub).get(sign_uri('/api/user/forms', user=local_user))

    assert resp.json['data'][0]['form_digest'] == 'XYZ'

    )

    formdata.formdef.digest_templates = {'default': 'digest of number <{{form_number}}>'}

    formdata.store()

    resp = app.get('/backoffice/management/listing')

    assert formdata.get_url(backoffice=True) in resp.text

    assert 'digest of number <%s>' % formdata.id_display in resp.text

    user_pending_form_url = re.findall('data-async-url="(.*/user-pending-forms)"', resp.text)[0]

    partial_resp = app.get(user_pending_form_url)

    assert number31.get_url(backoffice=True) not in partial_resp.text

    assert '<span class="formname">%s</span>' % number31.formdef.name in partial_resp.text

    # another item with status = new

    formdata = formdef.data_class()()

    formdata.data = {'0': time.strptime('2015-05-12', '%Y-%m-%d')}

    formdata.store()

    pub.cfg['language'] = {'language': 'fr'}

    pub.write_cfg()

    formdata = formdef.data_class()()

    formdata.data = {'0': time.strptime('2015-05-12', '%Y-%m-%d')}

    formdata.store()

    formdef.digest_templates = {'default': 'plop {{ form_var_date|date:"Y" }} plop'}

    formdef.store()

    formdata = formdef.data_class()()

    formdata.data = {'0': time.strptime('2015-05-12', '%Y-%m-%d')}

    formdata.store()

    formdef.digest_templates = {'default': 'plop {{ form_var_date_raw|date:"Y" }} plop'}

    formdef.store()

    formdata = formdef.data_class()()

    formdata.data = {'0': time.strptime('2015-05-12', '%Y-%m-%d')}

    formdata.store()

    formdef.digest_templates = {'default': 'plop {{ form_var_date|date:"Y" }} plop'}

    formdef.store()

    formdata = formdef.data_class()()

    formdata.data = {'0': None}

    formdata.store()

    # check there's no crash when an invaliad variable is given

    formdef.digest_templates = {'default': 'plop {{ blah|date:"Y" }} plop'}

    formdata = formdef.data_class()()

    formdata.data = {'0': time.strptime('2015-05-12', '%Y-%m-%d')}

    formdata.store()

def test_lazy_formdata_decimal_filter(pub):

            popup_response_data = json.dumps(

                {

                    'value': str(filled.id),

                }

            )

            return template.QommonTemplateResponse(

            if include_submission_channel:

                r += htmltext('<td>%s</td>') % formdata.get_submission_channel_label()

            r += htmltext('<td>%s') % formdata.formdef.name

            r += htmltext('</td>')

            r += htmltext('<td><a href="%s">%s</a></td>') % (

                formdata.get_url(backoffice=True),

        if get_publisher().is_using_postgresql():

            self.formdef.data_class().load_all_evolutions(items)

        if get_request().form.get('full') == 'on':

        else:

            output = [

                {

                    'id': filled.id,

                    'display_id': filled.get_display_id(),

                    'display_name': filled.get_display_name(),

                    'text': filled.get_display_label(),

                    'url': filled.get_url(),

                    'receipt_time': datetime.datetime(*filled.receipt_time[:6]),

                        formdata.id,

                    )

                    summary = force_text(formdata.get_display_name(), charset)

                    vevent.add('summary').value = summary

                    vevent.add('dtstart').value = dtstart

                    if dtend:

                    form_name = force_text(formdef.name, charset)

                    status_name = force_text(formdata.get_status_label(), charset)

                    description = '%s | %s | %s\n' % (form_name, formdata.get_display_id(), status_name)

                    description += backoffice_url

                    # TODO: improve performance by loading all users in one

                    # single query before the loop

                        submit_date,

                        status_label,

                    )

                    r += htmltext('</li>')

                r += htmltext('</ul>')

            r += htmltext('</div>')

    def get_data_source_structured_item(self):

        item = {

            'id': self.id,

        }

        for field in self.formdef.get_all_fields():

            if not field.varname:

        return item

    def get_display_label(self):

    def get_author_qualification(self):

        return None

from wcs.formdef import FormDef, get_formdefs_of_all_kinds

from .qommon import _, force_text, misc

from .qommon.template import Template

if not hasattr(types, 'ClassType'):

                criteria.value = WorkflowStatusItem.compute(criteria.value)

        if query:

        if get_by_id:

            try:

                if int(get_by_id) >= 2 ** 31:

            else:

                criterias.append(Equal('id', get_by_id))

        if get_by_text:

        items = [

            x.get_data_source_structured_item()

    submission_context = None

    submission_channel = None

    criticality_level = 0

    prefilling_data = None

    workflow_data = None

            self.submission_agent_id = str(self.submission_context.get('agent_id'))

            changed = True

        if changed:

            self.store()

        self.evolution = [evo]

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

        if not self.id_display:

            # only set id_display once as it may have been set automatically

            # by interpreting a webservice response.

        if any(fields.values()):

            context = self.get_substitution_variables()

            context['formdef_id'] = self.formdef.id

            for attribute, template in fields.items():

                if template is None:

                    new_value = None

                else:

                    new_value = Template(template, autoescape=False).render(context)

                    changed = True

        return changed

                    'form_url_backoffice': self.get_url(backoffice=True),

                    'form_uri': '%s/%s/' % (self.formdef.url_name, self.id),

                    'form_criticality_level': self.criticality_level,

                    'form_display_name': self.get_display_name(),

                }

            )

    def get_display_name(self):

        return _('%(name)s #%(id)s') % {'name': self.formdef.name, 'id': self.get_display_id()}

    def get_display_label(self):

        return self.get_display_name()

    def get_auto_geoloc(self):

    def get_json_export_dict(self, include_files=True, anonymise=False, user=None):

        data = {}

        data['id'] = str(self.id)

        data['display_id'] = self.get_display_id()

        data['display_name'] = self.get_display_name()

        data['text'] = self.get_display_label()

        return lambda x: getattr(x, self.attribute, None) is None

def parse_clause(clause):

    # creates a callable out of a clause

    #  (attribute, operator, value)

        return 'fts @@ plainto_tsquery(%%(c%s)s)' % id(self.value)

def get_name_as_sql_identifier(name):

    name = qommon.misc.simplify(name)

    for char in '<>|{}!?^*+/=\'':  # forbidden chars

            'submission_channel',

            'criticality_level',

            'last_update_time',

            'user_label',

            'prefilling_data',

        ]

    if 'last_update_time' not in existing_fields:

        cur.execute('''ALTER TABLE %s ADD COLUMN last_update_time timestamp''' % table_name)

    if 'user_label' not in existing_fields:

        cur.execute('''ALTER TABLE %s ADD COLUMN user_label varchar''' % table_name)

        'submission_channel',

        'backoffice_submission',

        'last_update_time',

        'user_label',

    ):

        view_fields.append((field, field))

        ('submission_channel', 'varchar'),

        ('criticality_level', 'int'),

        ('last_update_time', 'timestamp'),

        ('user_label', 'varchar'),

    ]

        conn.commit()

        cur.close()

    @guard_postgres

    @invalidate_substitution_cache

    def store(self):

                cur.execute(sql_statement, sql_dict)

                self.id = cur.fetchone()[0]

        if self._evolution:

            for evo in self._evolution:

# latest migration, number + description (description is not used

# programmaticaly but will make sure git conflicts if two migrations are

# separately added with the same number)

def migrate_global_views(conn, cur):

        raise RuntimeError()

    if sql_level < 1:  # 1: introduction of tracking_code table

        do_tracking_code_table()

        # 2: introduction of formdef_id in views

        # 5: add concerned_roles_array, is_at_endpoint and fts to views

        # 7: add backoffice_submission to tables

        # 33: add anonymised field to global view

        # 38: extract submission_agent_id to its own column

        # 43: add prefilling_data to formdata

        migrate_views(conn, cur)

    if sql_level < 40:

        # 3: introduction of _structured for user fields

                    for evo in formdata.evolution:

                        evo.who = None

                    formdata.store()

    if sql_level < 42:

        # 42: create snapshots table

        do_snapshots_table()

    @property

    def digest(self):

    @property

    def display_name(self):