Produits Entr'ouvert » w.c.s.

    Image = None

from quixote.http_request import Upload as QuixoteUpload

from wcs.qommon.emails import docutils

from wcs.qommon.form import UploadedFile

from wcs.qommon.ident.password_accounts import PasswordAccount

    assert data.data == {'0': {

        'sha1': hashlib.sha1(password).hexdigest(),

        'md5': hashlib.md5(password).hexdigest(),

        }}

def test_form_password_field_submit(pub):

import time

import email.Parser

from quixote import get_response, redirect

from quixote.directory import Directory

from quixote.html import htmltext, TemplateIO

            subject, charset = email.Header.decode_header(msg['Subject'])[0]

            if charset:

                encoding = get_publisher().site_charset

            else:

                r += subject

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

# 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, get_response, get_request, get_session, redirect

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

        if get_request().form.get('q'):

            q = get_request().form.get('q')

            if type(q) is not unicode:

            r += htmltext('<input name="q" value="%s">') % q.encode(get_publisher().site_charset)

        else:

            r += htmltext('<input name="q">')

from quixote import get_request, get_publisher, get_response, get_session

from quixote.directory import Directory

from django.utils.six.moves.urllib import parse as urllib

from django.http import HttpResponse, HttpResponseBadRequest

                # anonymous API call, mark authentication as required

                authentication_required = True

                        'slug': formdef.url_name,

                        'url': formdef.get_url(),

                        'description': formdef.description or '',

                formdict['functions'][wf_role_id] = workflow_function

            if formdef.category:

                formdict['category_position'] = (formdef.category.position or 0)

            else:

                formdict['category_position'] = sys.maxint

        all_formdefs = FormDef.select(order_by='name', ignore_errors=True, lightweight=True)

        for category in categories:

            d = {}

            d['slug'] = category.url_name

            d['url'] = category.get_url()

            if category.description:

            formdefs = ApiFormdefsDirectory(category).get_list_forms(user,

                    formdefs=all_formdefs, list_all_forms=list_all_forms,

                    backoffice_submission=backoffice_submission)

except ImportError:

    xlwt = None

from django.utils.six.moves.urllib import parse as urllib

from django.utils.six import StringIO

        if get_request().form.get('q'):

            q = get_request().form.get('q')

            if type(q) is not unicode:

            r += htmltext('<input name="q" value="%s">') % q.encode(get_publisher().site_charset)

        else:

            r += htmltext('<input name="q">')

            if get_request().form.get('q'):

                q = get_request().form.get('q')

                if type(q) is not unicode:

                r += htmltext('<input class="inline-input" name="q" value="%s">') % q.encode(get_publisher().site_charset)

            else:

                r += htmltext('<input class="inline-input" name="q">')

                            get_request().get_server().lower(),

                            formdef.url_name,

                            formdata.id)

                    vevent.add('dtstart').value = make_datetime(formdata.data[start_date_field_id])

                    if end_date_field_id and formdata.data.get(end_date_field_id):

                        vevent.add('dtend').value = make_datetime(formdata.data[end_date_field_id])

                    vevent.dtstart.value_param = 'DATE'

                    backoffice_url = formdata.get_url(backoffice=True)

                    vevent.add('url').value = backoffice_url

                    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

                    if formdata.user:

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

                    cal.add(vevent)

        def safe(v):

            if isinstance(v, str):

                try:

                except UnicodeDecodeError:

                    v = repr(v)

            else:

                try:

                except:

                    v = repr(v)

            return v

import urlparse

import hashlib

from quixote import cleanup

from ..qommon import misc

from ..qommon.ctl import Command, make_option

            if not admin_attribute:

                admin_attribute = 'is_superuser=true'

            else:

            admin_attribute_dict = dict([admin_attribute.split('=')])

            pub.cfg['idp'][key_provider_id]['admin-attributes'] = admin_attribute_dict

            pub.cfg['idp'][key_provider_id]['nameidformat'] = 'unspecified'

            if not 'variables' in config.sections():

                config.add_section('variables')

            for key, value in variables.items():

                config.set('variables', key, value)

        if not 'api-secrets' in config.sections():

import hashlib

import xml.etree.ElementTree as ET

from django.utils.six.moves.urllib import parse as urllib

from django.utils.six.moves.urllib import parse as urlparse

    def export_data_source_to_xml(self, element, attribute_name, charset):

        data_source = getattr(self, attribute_name)

        ET.SubElement(element, 'type').text = data_source.get('type')

    def import_data_source_from_xml(self, element, charset):

        return {

from quixote import get_request, get_publisher

from quixote.html import htmltext, TemplateIO

from django.utils.formats import date_format as django_date_format

from django.utils.html import urlize

from django.utils.six.moves.html_parser import HTMLParser

    @property

    def unhtmled_label(self):

        charset = get_publisher().site_charset

            re.sub('<.*?>', ' ', self.label), charset)).strip().encode(charset)

    def get_admin_attributes(self):

                if type(val) is dict:

                    for k, v in val.items():

                        if isinstance(v, str):

                        else:

                            # field having non str value in dictionnary field must overload

                            # import_to_xml to handle import

                        ET.SubElement(el, k).text = text_value

                elif type(val) is list:

                    if attribute[-1] == 's':

                    else:

                        atname = 'item'

                    for v in val:

                elif type(val) in (str, unicode):

                    if type(val) is unicode:

                        el.text = val

                    else:

                else:

                    el.text = str(val)

        return field

        value = value or ''

        if value.startswith('http://') or value.startswith('https://'):

            charset = get_publisher().site_charset

            return htmltext(urlize(value, nofollow=True, autoescape=True).encode(charset))

        return str(value)

        for post_condition in self.post_conditions:

            post_condition_node = ET.SubElement(conditions_node, 'post_condition')

            condition_node = ET.SubElement(post_condition_node, 'condition')

    def fill_admin_form(self, form):

        form.add(StringWidget, 'label', title = _('Label'), value = self.label,

import xml.etree.ElementTree as ET

import datetime

from quixote import get_request, get_publisher

from quixote.http_request import Upload

    def export_to_json(self, include_id=False, indent=None, anonymise=True):

        charset = get_publisher().site_charset

        root = {}

        if include_id and self.id:

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

        if self.category:

            root['category_id'] = str(self.category.id)

        if self.workflow:

            root['workflow'] = self.workflow.get_json_export_dict(include_id=include_id)

        for text_attribute in list(self.TEXT_ATTRIBUTES):

            if not hasattr(self, text_attribute) or not getattr(self, text_attribute):

                continue

                    getattr(self, text_attribute), charset)

        for boolean_attribute in self.BOOLEAN_ATTRIBUTES:

            if not hasattr(self, boolean_attribute):

        if self.category:

            elem = ET.SubElement(root, 'category')

            if include_id:

                elem.attrib['category_id'] = str(self.category.id)

        if self.workflow:

            elem = ET.SubElement(root, 'workflow')

            if include_id:

                elem.attrib['workflow_id'] = str(self.workflow.id)

                    continue

                role_id = str(role_id)

                if role_id.startswith('_') or role_id == 'logged-users':

                else:

                    try:

                    except KeyError:

                sub = ET.SubElement(roles, 'role')

                if include_id:

                    sub.attrib['role_id'] = role_id

                    continue

                role_id = str(role_id)

                if role_id.startswith('_') or role_id == 'logged-users':

                else:

                    try:

                    except KeyError:

                sub = ET.SubElement(roles, 'role')

                sub.attrib['role_key'] = role_key

                if include_id:

            element.attrib['varname'] = option

            option_value = self.workflow_options.get(option)

            if isinstance(option_value, basestring):

            elif hasattr(option_value, 'base_filename'):

                ET.SubElement(element, 'filename').text = option_value.base_filename

                ET.SubElement(element, 'content_type').text = (

        for geoloc_key, geoloc_label in (self.geolocations or {}).items():

            element = ET.SubElement(geolocations, 'geolocation')

            element.attrib['key'] = geoloc_key

        if self.required_authentication_contexts:

            element = ET.SubElement(root, 'required_authentication_contexts')

            for auth_context in self.required_authentication_contexts:

        return root

import urllib

import base64

from django.utils.six.moves.urllib import parse as urlparse

from .qommon import get_logger

    charset = get_publisher().site_charset

    payload = {}

    if user.name_identifiers:

    elif user.email:

    payload['origin'] = urlparse.urlparse(get_publisher().get_frontoffice_url()).netloc

    stream.seek(0)

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

    async_post = fargo_post_json_async('/api/documents/push/', payload)

import django.apps

from django.conf import settings

from django.utils.six.moves import configparser as ConfigParser

from quixote import get_publisher

    pub = get_publisher()

    if pub is None:

        return message

def ngettext(*args):

    pub = get_publisher()

    if pub is None:

        return message

from .publisher import get_cfg, get_logger, get_publisher_class

from . import publisher

from quixote.html import htmltext, htmltag, htmlescape, TemplateIO

from quixote.util import randbytes

from django.utils.six.moves.html_parser import HTMLParser

from django.utils.six import StringIO

                    self.error = _('invalid address domain')

                    return

                if not type(domain) is unicode:

                try:

                    domain = domain.encode('idna')

                except UnicodeError:

            parser = HTMLParser()

            charset = get_publisher().site_charset

            def unquote_django(matchobj):

            self.value = re.sub('{[{%](.*?)[%}]}', unquote_django, self.value)

    def add_media(self):

from django.conf import settings

from django.utils import datetime_safe

from django.utils.html import strip_tags

from django.template import engines, TemplateSyntaxError, VariableDoesNotExist

from django.utils.six.moves.html_parser import HTMLParser

        return ''

    if not isinstance(s, unicode):

        if get_publisher() and get_publisher().site_charset:

        else:

    s = unicodedata.normalize('NFKD', s).encode('ascii', 'ignore')

    s = re.sub(r'[^\w\s\'_\-%s]' % space, '', s).strip().lower()

    s = re.sub(r'[\s\'_\-%s]+' % space, space, s)

    if isinstance(s, str):

        return s

    if not isinstance(s, unicode):

    return s.encode(get_publisher().site_charset)

def ellipsize(s, length = 30):

    if type(s) is not unicode:

    if not s or len(s) < length:

        return s.encode(get_publisher().site_charset)

    return s[:length-5].encode(get_publisher().site_charset) + ' (...)'

def html2text(text):

    if isinstance(text, (htmltext, str)):

    return site_encode(HTMLParser().unescape(strip_tags(text)))

import xml.etree.ElementTree as ET

import zipfile

from .misc import date_format, datetime_format, strftime

from .evalutils import make_date, make_datetime

        if value is None:

            value = ''

        if type(value) is not unicode:

        self.worksheet = worksheet

        for i in range(0x20):  # remove control characters

            char = chr(i)

from django.conf import settings

from django.http import Http404

from django.utils import translation

from django.utils.translation import gettext, ngettext

from quixote.publish import Publisher, get_request, get_response, get_publisher, redirect

    def _generate_plaintext_error(self, request, original_response,

                                  exc_type, exc_value, tb, limit = None):

        if exc_value:

        if not self.USE_LONG_TRACES:

            if not request:

                # this happens when an exception is raised by an afterjob

        error_summary = traceback.format_exception_only(exc_type, exc_value)

        error_summary = error_summary[0][0:-1] # de-listify and strip newline

        plain_error_msg = self._generate_plaintext_error(request,

                                                         original_response,

except ImportError:

    lasso = None

from django.utils.six.moves.urllib import parse as urlparse

from quixote import get_request, get_response, redirect, get_field, get_publisher

    def metadata(self):

        try:

                            get_cfg('sp')['saml2_metadata'])).read(), 'utf-8')

        except KeyError:

            raise errors.TraversalError()

                             TemplateSyntaxError as DjangoTemplateSyntaxError,

                             VariableDoesNotExist as DjangoVariableDoesNotExist)

from django.template.loader import render_to_string

from django.utils.safestring import SafeString, SafeUnicode

from quixote import get_session, get_request, get_response, get_publisher

    publisher = get_publisher()

    def encode_string(x):

        if publisher:

        return x

    name = encode_string(tree.attrib['name'])

    version = tree.attrib.get('version')

    if isinstance(value, SafeString):

        return SafeUnicode(value, 'utf-8')

    if isinstance(value, str):

    return value

if not getattr(django.template.base.Variable, 'monkey_patched', False):

from django import template

from django.template import defaultfilters

from django.utils import dateparse

from django.utils.safestring import mark_safe

from wcs.qommon import evalutils

from wcs.qommon import tokens

@register.filter

def startswith(string, substring):

@register.filter

def split(string, separator=' '):

    if not string:

        return []

@register.filter

def strip(string, chars=None):

    if not string:

        return ''

    if chars:

    else:

@register.filter

def parse_date(date_string):

@register.filter

def token_check(token1, token2):

def get_latlon(obj):

import datetime

import xml.etree.ElementTree as ET

from quixote import get_publisher

from .misc import indent_xml

        return root

    def export_str_to_xml(self, element, attribute_name, charset):

    def export_int_to_xml(self, element, attribute_name, charset):

        element.text = str(getattr(self, attribute_name))

# 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 .qommon import _, misc

    def get_json_export_dict(self):

        charset = get_publisher().site_charset

        return {

            'allows_backoffice_access': self.allows_backoffice_access,

            'emails_to_members': self.emails_to_members,

            'id': self.id}

    @classmethod

import re

import cPickle

from quixote import get_publisher

from . import qommon

from .qommon.storage import _take, parse_clause as parse_storage_clause

def site_unicode(value):

    if not isinstance(value, basestring):

    if isinstance(value, unicode):

        return value

def get_connection(new=False):

    if new:

                elif field.key == 'password':

                    d = {}

                    for fmt, val in value:

                    value = d

                if sql_type == 'date':

                    value = value.timetuple()

import warnings

from django.utils.functional import SimpleLazyObject

from quixote import get_publisher, get_request

        if self._field.convert_value_to_str:

            return self._field.convert_value_to_str(value)

        if isinstance(value, str):

        return value

    def __str__(self):

        return value in self.get_value()

    def __unicode__(self):

    def __eq__(self, other):

    def __ne__(self, other):

    def __getitem__(self, key):

        if isinstance(key, (int, slice)):

import tempfile

import shutil

from django.utils.six import StringIO

from quixote import get_response, get_request, get_publisher

                if isinstance(t, unicode):

                    t = t.encode(get_publisher().site_charset)

                t = template_on_context(context, t, autoescape=False)

            for node in root.iter():

                got_blank_lines = False

                # apply template to user-field-decl and update user-field-get

import mimetypes

from StringIO import StringIO

from quixote.html import TemplateIO, htmltext

from ..qommon import _

            if type(key) is unicode:

                ET.SubElement(item, 'name').text = key

            elif type(key) is str:

            else:

                raise AssertionError('unknown type for key (%r)' % key)

            if type(value) is unicode:

                ET.SubElement(item, 'value').text = value

            elif type(value) is str:

            else:

                raise AssertionError('unknown type for value (%r)' % key)

import time

import uuid

from django.utils.six import StringIO

from quixote import get_request, get_response, redirect

        root = ET.Element('workflow')

        if include_id and self.id and not str(self.id).startswith('_'):

            root.attrib['id'] = str(self.id)

        roles_node = ET.SubElement(root, 'roles')

        if self.roles:

            for role_id, role_label in self.roles.items():

                role_node = ET.SubElement(roles_node, 'role')

                role_node.attrib['id'] = role_id

        if self.last_modification_time:

            elem = ET.SubElement(root, 'last_modification')

    def get_json_export_dict(self, include_id=False):

        charset = get_publisher().site_charset

        root = {}

        if include_id and self.id:

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

        if self.last_modification_time:

                                                           self.last_modification_time)

        roles = root['functions'] = {}

        for role, label in self.roles.iteritems():

        statuses = root['statuses'] = []

        endpoint_status_ids = [s.id for s in self.get_endpoint_status()]

        waitpoint_status_ids = [s.id for s in self.get_waitpoint_status()]

        for status in self.possible_status:

            statuses.append({

                'id': status.id,

                'forced_endpoint': status.forced_endpoint,

                'endpoint': status.id in endpoint_status_ids,

                'waitpoint': status.id in waitpoint_status_ids,

                val = getattr(self, attribute)

                if type(val) is dict:

                    for k, v in val.items():

                elif type(val) is list:

                    if attribute[-1] == 's':

                        atname = attribute[:-1]

                    else:

                        atname = 'item'

                    for v in val:

                elif type(val) in (str, unicode):

                    if type(val) is unicode:

                        el.text = val

                    else:

                else:

                    el.text = str(val)

        return node

                continue

            role_id = str(role_id)

            if role_id.startswith('_') or role_id == 'logged-users':

            else:

                try:

                except KeyError:

            sub = ET.SubElement(el, 'item')

            sub.attrib['role_id'] = role_id

            sub.text = role

            return

        role_id = str(getattr(self, attribute))

        if role_id.startswith('_') or role_id == 'logged-users':

        else:

            try:

            except KeyError:

        sub = ET.SubElement(item, attribute)

        if include_id:

            sub.attrib['role_id'] = role_id

    def export_to_xml(self, charset, include_id=False):

        status = ET.Element('action')

        if self.backoffice_info_text:

                    self.backoffice_info_text, charset)

        items = ET.SubElement(status, 'items')

    def export_to_xml(self, charset, include_id=False):

        level = ET.Element('criticality-level')

        if self.colour:

        return level

    def init_with_xml(self, elem, charset, include_id=False):

    def export_to_xml(self, charset, include_id=False):

        status = ET.Element('status')

        if self.extra_css_class:

        if self.forced_endpoint:

            ET.SubElement(status, 'forced_endpoint').text = 'true'

        if self.backoffice_info_text:

                    self.backoffice_info_text, charset)

        visibility_node = ET.SubElement(status, 'visibility')

            if type(self.button_label) is unicode:

                el.text = self.button_label

            elif type(self.button_label) is str:

            else:

                raise AssertionError('unknown type for button_label (%r)' % self.button_label)

import sys

import xml.etree.ElementTree as ET

from django.utils.six.moves.urllib import parse as urllib

from django.utils.six.moves.urllib import parse as urlparse

    def export_request_to_xml(self, element, attribute_name, charset):

        request = getattr(self, attribute_name)

        for attr in ('url', 'request_signature_key', 'method'):

        for attr in ('qs_data', 'post_data'):

            data_element = ET.SubElement(element, attr)

            for k, v in (request.get(attr) or {}).items():

                sub = ET.SubElement(data_element, 'param')

        if request.get('post_formdata'):

            ET.SubElement(element, 'post_formdata')