Produits Entr'ouvert » w.c.s.

        data_source.store()

        resp2 = app.get(select2_url + '?q=hell')

        assert emails.count() == 1

        if pub.is_using_postgresql():

            assert pub.loggederror_class.count() == 1

            logged_error = pub.loggederror_class.select()[0]

            assert logged_error.workflow_id is None

        data_source.notify_on_errors = False

        data_source.store()

        assert pub.loggederror_class.count() == 1

        logged_error = pub.loggederror_class.select()[0]

        assert logged_error.workflow_id is None

    # expression not iterable

    datasource = {'type': 'formula', 'value': '2', 'notify_on_errors': True, 'record_on_errors': True}

        assert pub.loggederror_class.count() == 2

        logged_error = pub.loggederror_class.select()[1]

        assert logged_error.workflow_id is None

def test_python_datasource_with_evalutils(pub):

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

    datasource = {

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

    datasource = {

        assert pub.loggederror_class.count() == 3

        logged_error = pub.loggederror_class.select()[2]

        assert logged_error.workflow_id is None

    datasource = {

        'type': 'json',

        assert pub.loggederror_class.count() == 4

        logged_error = pub.loggederror_class.select()[3]

        assert logged_error.workflow_id is None

def test_json_datasource_bad_url_scheme(pub, error_email, emails):

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

    datasource = {'type': 'json', 'value': '/bla/blo', 'notify_on_errors': True, 'record_on_errors': True}

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

    datasource = {

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

    datasource = {

        assert pub.loggederror_class.count() == 3

        logged_error = pub.loggederror_class.select()[2]

        assert logged_error.workflow_id is None

    datasource = {

        'type': 'geojson',

        assert pub.loggederror_class.count() == 4

        logged_error = pub.loggederror_class.select()[3]

        assert logged_error.workflow_id is None

def test_geojson_datasource_bad_url_scheme(pub, error_email, emails):

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

    datasource = {'type': 'geojson', 'value': '/bla/blo', 'notify_on_errors': True, 'record_on_errors': True}

        assert logged_error.workflow_id is None

        assert (

            logged_error.summary

        )

        assert not User.select()[0].email

def test_process_notification_user_with_errors(pub):

    notification['full'] = False

    for key in ('uuid', 'first_name', 'last_name', 'email'):

        backup = notification['objects']['data'][0][key]

        del notification['objects']['data'][0][key]

        with pytest.raises(Exception) as e:

            CmdHoboNotify.process_notification(notification)

        assert User.count() == 0

        notification['objects']['data'][0][key] = backup

    del notification['objects']['data'][0]['uuid']

    with pytest.raises(Exception) as e:

        CmdHoboNotify.process_notification(notification)

def test_process_notification_role_with_errors(pub):

    if two_pubs.is_using_postgresql():

        errors = two_pubs.loggederror_class.select()

        assert len(errors) == 2

    # no tracking code has been created

    created_formdata = target_formdef.data_class().select()[0]

        assert two_pubs.loggederror_class.count() == 1

        logged_error = two_pubs.loggederror_class.select()[0]

        assert logged_error.summary == 'Failed to attach user (not found: "zzz")'

    # user association on invalid template

    carddef.data_class().wipe()

        assert 'Foo Bar ' in resp.text

        if notify_on_errors:

            assert emails.count() == 1

            emails.empty()

        else:

            assert emails.count() == 0

import datetime

import json

import re

import time

import urllib.parse

                if 'data_source' in info:

                    error_summary = 'Error loading JSON data source (%s)' % str(e)

                    data_source = NamedDataSource.get(info['data_source'])

                        context='[DATASOURCE]',

                        notify=data_source.notify_on_errors,

                        record=data_source.record_on_errors,

                        if field.convert_value_from_anything:

                            try:

                                field_value = field.convert_value_from_anything(field_value)

                                continue

                        user.form_data[field.id] = field_value

                    user.name_identifiers = [uuid]

                    users = User.get_users_with_name_identifier(o['uuid'])

                    for user in users:

                        user.set_deleted()

CmdHoboNotify.register()

import collections

import hashlib

import urllib.parse

import xml.etree.ElementTree as ET

    data_key = data_source.get('data_attribute') or 'data'

    geojson = data_source.get('type') == 'geojson'

    error_summary = None

    try:

        entries = misc.json_loads(misc.urlopen(url).read())

        return entries

    except misc.ConnectionError as e:

        error_summary = 'Error loading %s (%s)' % (log_message_part, str(e))

    except (ValueError, TypeError) as e:

        error_summary = 'Error reading %s output (%s)' % (log_message_part, str(e))

            context='[DATASOURCE]',

            notify=data_source.get('notify_on_errors'),

            record=data_source.get('record_on_errors'),

            # noqa pylint: disable=eval-used

            value = eval(data_source.get('value'), global_eval_dict, variables)

            if not isinstance(value, collections.Iterable):

                    context='[DATASOURCE]',

                    notify=data_source.get('notify_on_errors'),

                    record=data_source.get('record_on_errors'),

                return [{'id': x, 'text': x} for x in value]

            return value

        except Exception as exc:

                context='[DATASOURCE]',

                notify=data_source.get('notify_on_errors'),

                record=data_source.get('record_on_errors'),

        return error

    @classmethod

        return cls.record(

        )

    def build_tech_id(self):

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

import json

import os

import pickle

        conn, cur = sql.get_connection_and_cursor()

        sql.drop_views(None, conn, cur)

        sql.migrate_global_views(conn, cur)

        conn.commit()

        cur.close()

        if record and self.loggederror_class:

            )

            return

        try:

        except OSError:

            # Could happen if there is no mail server available and exceptions

            # were configured to be mailed. (formerly socket.error)

            # Could also could happen on file descriptor exhaustion.

            pass

    def apply_global_action_timeouts(self):

        from wcs.workflows import Workflow, WorkflowGlobalActionTimeoutTrigger

                self.execute()

            else:

                self.job_cmd(job=self)

            self.exception = traceback.format_exc()

            self.status = N_('failed')

        else:

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

from django.conf import settings

            publisher.substitutions.feed(extra_source(publisher, None))

        try:

            job.function(publisher)

import base64

import hashlib

import urllib.parse

import uuid

            try:

                value = WorkflowStatusItem.compute(value, context=user_info)

                continue

            if field_varname == '__name':

                user.name = value

# along with this program; if not, see <http://www.gnu.org/licenses/>.

import os

import time

import urllib.parse

from xml.sax.saxutils import escape

                != get_cfg('sp', {}).get('saml2_base_url') + get_request().get_url()[last_slash:]

            ):

                return error_page('SubjectConfirmation Recipient Mismatch')

            return error_page('Error checking SubjectConfirmation Recipient')

        assertions_dir = os.path.join(get_publisher().app_dir, 'assertions')

                return error_page('Assertion received too early')

            if not_on_or_after and current_time > not_on_or_after:

                return error_page('Assertion expired')

            return error_page('Error checking Assertion Time')

        # TODO: check for unknown conditions

            if field and field.convert_value_from_anything:

                try:

                    field_value = field.convert_value_from_anything(field_value)

                    continue

            if user.form_data.get(field_id) != field_value:

                user.form_data[field_id] = field_value

        with locket.lock_file(objects_dir + '.lock.index'):

            try:

                self.update_indexes(previous_object_value, relative_object_filename)

                # something failed, we can't keep using possibly broken indexes, so

                # we notify of the bug and remove the indexes

                self.destroy_indexes()

    @classmethod

import datetime

import json

import time

import urllib.parse

import xml.etree.ElementTree as ET

                if field and field.convert_value_from_anything:

                    try:

                        field_value = field.convert_value_from_anything(field_value)

                        # invalid attribute, do not update it

                        del new_data[field.varname]

                        continue

        user_uuid = user.name_identifiers[0]

        try:

            url = user_ws_url(user_uuid)

            return

        payload = new_data.copy()

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

from quixote import get_publisher

from quixote.html import htmltext

                # needed by AttachmentEvolutionPart.from_upload()

                upload.get_file_pointer()

                formdata.evolution[-1].add_part(AttachmentEvolutionPart.from_upload(upload, to=to))

            continue

    def perform(self, formdata):

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

import urllib.parse

from quixote import get_publisher, get_request, get_response

        user_uuid = user.name_identifiers[0]

        try:

            url = roles_ws_url(role_uuid, user_uuid)

            return

        def after_job(job=None):

        user_uuid = user.name_identifiers[0]

        try:

            url = roles_ws_url(role_uuid, user_uuid)

            return

        def after_job(job=None):

                workflow_data['%s_connection_error' % self.varname] = str(e)

                formdata.update_workflow_data(workflow_data)

                formdata.store()

            return

        app_error_code = get_app_error_code(response, data, self.response_type)

        if self.response_type == 'json':

            try:

                d = json_loads(force_text(data))

                formdata.update_workflow_data(workflow_data)

                formdata.store()

            else:

                workflow_data['%s_response' % self.varname] = d

                if isinstance(d, dict) and self.method == 'POST':

            )

            formdata.evolution[-1].add_part(attachment)

        if action in (':pass', ':stop') and (

            self.notify_on_errors or self.record_on_errors or self.record_errors

        ):

                summary = '<no response>'

                if response is not None:

                    summary = '%s %s' % (response.status_code, response.reason)

            if self.record_errors and formdata.evolution:

                formdata.evolution[-1].add_part(JournalWsCallErrorPart(summary, self.label, data))

                formdata.store()

        # verify that target still exist

        try:

            self.parent.parent.get_status(action)

        formdata.status = 'wf-%s' % action

        formdata.store()

import itertools

import os

import random

import time

import uuid

import xml.etree.ElementTree as ET

            try:

                # noqa pylint: disable=eval-used

                anchor_date = eval(self.anchor_expression, get_publisher().get_global_eval_dict(), variables)

                # get the variables in the locals() namespace so they are

                # displayed within the trace.

                expression = self.anchor_expression  # noqa pylint: disable=unused-variable

                # noqa pylint: disable=unused-variable

                global_variables = get_publisher().get_global_eval_dict()

        # convert anchor_date to datetime.datetime()

        if isinstance(anchor_date, datetime.datetime):

        elif isinstance(anchor_date, str) and anchor_date:

            try:

                anchor_date = get_as_datetime(anchor_date)

                anchor_date = None

        elif anchor_date:

            # timestamp

            try:

                anchor_date = datetime.datetime.fromtimestamp(anchor_date)

                anchor_date = None

        if not anchor_date:

                try:

                    attachment = WorkflowStatusItem.compute(attachment, allow_complex=True, raises=True)

                else:

                    if attachment:

                        complex_value = get_publisher().get_cached_complex_data(attachment)

                    # and magically convert string like 'form_var_*_raw' to a PicklableUpload

                    # noqa pylint: disable=eval-used

                    picklableupload = eval(attachment, global_eval_dict, local_eval_dict)

                    continue

                if not picklableupload:

            if not isinstance(upload, PicklableUpload):

                try:

                    upload = FileField.convert_value_from_anything(upload)

                    continue

            yield upload

import collections

import json

import urllib.parse

import xml.etree.ElementTree as ET

            try:

                value = WorkflowStatusItem.compute(value, raises=True)

                value = str(value)

            else:

                key = force_str(key)

                value = force_str(value)

            for (key, value) in post_data.items():

                try:

                    payload[key] = WorkflowStatusItem.compute(value, allow_complex=True, raises=True)

                else:

                    if payload[key]:

                        payload[key] = get_publisher().get_cached_complex_data(payload[key])

    except ConnectionError as e:

        if not handle_connection_errors:

            raise e

        return (None, None, None)

    app_error_code = get_app_error_code(response, data, 'json')

        summary = '<no response>'

        if response is not None:

            summary = '%s %s' % (status, response.reason)

        )

    return (response, status, data)