Produits Entr'ouvert » w.c.s.

        http_post_request.return_value = None, 400, 'null', None  # fail

        resp = resp.form.submit('button_export_to')

        assert http_post_request.call_count == 1

    # failed to push to portfolio, but document is here

    resp = resp.follow()  # $form/$id/create_doc

            }

        )

    )

    resp = app.get(

        '/ident/fc/callback?%s'

        % urllib.parse.urlencode(

            }

        )

    )

    # Login existing user

    def logme(login_url):

            try:

                sms_class.send(sender, [form.get_widget('sms').parse()], message)

            except errors.SMSError as e:

            get_session().message = ('info', _('SMS with tracking code sent to the user'))

        else:

            # send mail

def push_document(user, filename, stream):

    if not user:

        return

    payload = {}

    if user.name_identifiers:

        payload['user_nameid'] = force_text(user.name_identifiers[0], 'ascii')

    elif user.email:

        payload['user_email'] = force_text(user.email, 'ascii')

    payload['file_name'] = force_text(filename, charset)

    stream.seek(0)

    payload['file_b64_content'] = force_text(base64.b64encode(stream.read()))

        if status == 200:

            get_logger().info('file %r pushed to portfolio of %r', filename, user.display_name)

        else:

    if get_response():

        get_response().add_after_job(

from django.utils.safestring import mark_safe

from quixote import get_publisher, get_request, get_response

from .admin.emails import EmailsDirectory

from .publisher import get_cfg, get_logger

from .template import Template

def create_smtp_server(emails_cfg, smtp_timeout=None):

    try:

        s = smtplib.SMTP(emails_cfg.get('smtp_server', None) or 'localhost', timeout=smtp_timeout)

        raise errors.EmailError('Failed to connect to SMTP server (timeout)')

    except OSError:

        # XXX: write message in a queue somewhere?

        raise errors.EmailError('Failed to connect to SMTP server')

    if not s.sock:

        raise errors.EmailError('Failed to connect to SMTP server')

    rc_code, ehlo_answer = s.ehlo()

    if rc_code != 250:

        raise errors.EmailError('Failed to EHLO to SMTP server (%s)' % rc_code)

    if b'STARTTLS' in ehlo_answer:

        rc_code = s.starttls()[0]

        if rc_code != 220:

            raise errors.EmailError('Failed to STARTTLS to SMTP server (%s)' % rc_code)

    if emails_cfg.get('smtp_login'):

        try:

            s.login(emails_cfg.get('smtp_login') or '', emails_cfg.get('smtp_password') or '')

            raise errors.EmailError('Failed to authenticate to SMTP server')

            raise errors.EmailError('Failed to authenticate to SMTP server, unknown error.')

    return s

from wcs.formdata import flatten_dict

from wcs.workflows import WorkflowStatusItem

from ..backoffice.menu import html_top

from ..form import (

    CompositeWidget,

        return False

    def get_access_token(self, code):

        session = get_session()

        fc_cfg = get_cfg('fc', {})

        client_id = fc_cfg.get('client_id')

            },

        )

        if status != 200:

            return None

        result = json_loads(data)

        if 'error' in result:

            return None

        # check id_token nonce

        id_token = result['id_token']

        payload = json_loads(base64url_decode(force_bytes(payload)))

        nonce = hashlib.sha256(force_bytes(session.id)).hexdigest()

        if payload['nonce'] != nonce:

            return None

        return access_token, id_token

    def get_user_info(self, access_token):

        dummy, status, data, dummy = http_get_page(

            self.get_user_info_url(),

            headers={

            },

        )

        if status != 200:

            )

            return None

        return json_loads(data)

        pub = get_publisher()

        request = get_request()

        session = get_session()

        state = request.form.get('state', '')

        next_url = (session.extra_user_variables or {}).pop(

            'fc_next_url_' + state, ''

            if error:

                # we log only errors whose user is not responsible

                msg = self.AUTHORIZATION_REQUEST_ERRORS.get(error)

            return redirect(next_url)

        access_token, id_token = self.get_access_token(request.form['code'])

        if not access_token:

        if not (user.name and user.email):

            # we didn't get useful attributes, forget it.

            return redirect(next_url)

        user.store()

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from ..admin.menu import command_icon

from ..backoffice.menu import html_top

from ..form import (

        idps = get_cfg('idp', {})

        if not lasso:

            raise Exception("lasso is missing, idp method cannot be used")

        if len(idps) == 0:

from wcs.qommon.admin.texts import TextsDirectory

from .. import storage as st

from .. import template, tokens

from ..admin.emails import EmailsDirectory

        if identities_cfg.get('email-confirmation', False):

            if not user.email:

                    _(

                        'Accounts are configured to require confirmation but accounts can be created without emails'

                    )

        if passwords_cfg.get('generate', True):

            if not user.email:

                    _(

                        'Accounts are configured to have a generated password '

                        'but accounts can be created without emails'

        try:

            return method(*args, **kwargs)

        except Exception as e:

            fault = lasso.SoapFault.newFull('Internal Server Error', str(e))

            body = lasso.SoapBody()

            body.any = [fault]

    def _q_traverse(self, path):

        # if lasso is not installed, hide the saml endpoints

        if lasso is None:

            raise errors.TraversalError()

        return Directory._q_traverse(self, path)

            method = ident_methods[0]

            try:

                return ident.login(method)

                return errors.TraversalError(msg)

        else:

            form = Form(enctype='multipart/form-data')

                else:

                    try:

                        return ident.login(method)

                        return errors.TraversalError()

            else:

                template.html_top(_('Login'))

            method = ident_methods[0]

            try:

                return ident.register(method)

                return errors.TraversalError()

        else:

            form = Form(enctype='multipart/form-data')

                        }

                    )

                except UploadStorageError as e:

                    results.append({'error': _('failed to store file (system error)')})

        get_response().set_content_type('application/json')

    template_on_formdata,

)

from ..qommon.form import (

    CheckboxWidget,

    ComputedExpressionWidget,

                )

            )

        except TemplateError as e:

            raise TemplatingError(_('Error in template: %s') % str(e))

    def apply_od_template_to_formdata(self, formdata):

from wcs.workflows import WorkflowStatusItem, register_item_class, template_on_formdata

from ..qommon.form import ComputedExpressionWidget, SingleSelectWidget, StringWidget, TextWidget, WidgetList

from ..qommon.template import TemplateError

from .wscall import WebserviceCallStatusItem

        try:

            title = template_on_formdata(formdata, self.compute(self.title, render=False), autoescape=False)

        except TemplateError as e:

            )

            return

        try:

            body = template_on_formdata(formdata, self.compute(self.body, render=False), autoescape=False)

        except TemplateError as e:

            )

            return

from ..qommon.form import CompositeWidget, ComputedExpressionWidget, SingleSelectWidget, WidgetListAsTable

from ..qommon.ident.idp import is_idp_managing_user_attributes

from ..qommon.misc import JSONEncoder, http_patch_request

def user_ws_url(user_uuid):

                url, payload, headers={'Content-type': 'application/json'}

            )

            if status != 200:

        if get_request():

            get_response().add_after_job(_('Updating user profile'), after_job)

    template_on_formdata,

)

from ..qommon.form import SingleSelectWidget, TextWidget, WidgetList

from ..qommon.template import TemplateError

            formdata.evolution[-1].add_part(JournalEvolutionPart(formdata, self.comment, self.to))

            formdata.store()

        except TemplateError as e:

            )

from ..qommon.form import SingleSelectWidgetWithOther

from ..qommon.ident.idp import is_idp_managing_user_attributes

from ..qommon.misc import http_delete_request, http_post_request

def roles_ws_url(role_uuid, user_uuid):

            signed_url = sign_ws_url(url)

            dummy, status, dummy, dummy = http_post_request(signed_url)

            if status != 201:

        if get_request():

            get_response().add_after_job(_('Adding role'), after_job)

            # pylint: disable=unused-variable

            response, status, data, auth_header = http_delete_request(signed_url)

            if status != 200:

        if get_request():

            get_response().add_after_job(_('Removing role'), after_job)

from .formdata import Evolution

from .formdef import FormDef, FormdefImportError

from .mail_templates import MailTemplate

from .qommon.form import (

    CheckboxWidget,

    ComputedExpressionWidget,

        if not (self.subject and self.body) and not self.mail_template:

            return

        body = self.body

        subject = self.subject

        extra_attachments = None

                formdata, self.compute(body, render=False), autoescape=body.startswith('<')

            )

        except TemplateError as e:

            )

            return

                formdata, self.compute(subject, render=False), autoescape=False

            )

        except TemplateError as e:

            )

            return

        try:

            sms_body = template_on_formdata(formdata, self.compute(self.body, render=False))

        except TemplateError as e:

            return

        from .qommon import sms

        try:

            sms.SMS.get_sms_class().send(sender, destinations, sms_body)

        except errors.SMSError as e:

register_item_class(SendSMSWorkflowStatusItem)