Produits Entr'ouvert » w.c.s.

import random

from quixote.html import htmltext, TemplateIO

        CheckboxWidget, SingleSelectWidget

from wcs.fields import WidgetField, register_field_class

from pyvotecore import schulze_method, irv, ranked_pairs, schulze_pr, \

from quixote import get_publisher

from wcs.fields import WidgetField, register_field_class

class VoteAnonymityWidget(CheckboxWidget):

    vote_anonymity = 'anonymous'

import random

from quixote.html import htmltext, TemplateIO

from wcs.fields import WidgetField, register_field_class

class RankedItemsWidget(CompositeWidget):

from wcs.qommon import errors, sessions

from wcs.qommon.form import UploadedFile

from wcs.qommon.http_request import HTTPRequest

from wcs.qommon.template import get_current_theme

from wcs.qommon.bounces import Bounce

    resp = resp.forms[0].submit() # confirm delete

    assert len(pub.cfg['idp']) == 0

        idp_metadata_filename = os.path.join(os.path.dirname(__file__), 'idp_metadata.xml')

        urlopen.side_effect = lambda *args: open(idp_metadata_filename)

        resp = app.get('/backoffice/settings/identification/idp/idp/')

    formdef.workflow_id = workflow.id

    formdef.store()

        urlopen.side_effect = lambda *args: StringIO('''\

{"data": [{"id": 0, "text": "zéro", "foo": "bar"}, \

{"id": 1, "text": "uné", "foo": "bar1"}, \

    formdata.status = 'wf-new'

    formdata.evolution[-1].status = 'wf-new'

    from wcs.qommon.form import PicklableUpload as PicklableUpload3

    upload.receive(['test'])

    upload2 = PicklableUpload3('test.txt', 'text/plain', 'ascii')

    upload2.receive(['test'])

    assert orig == 'example.net'

def test_reverse_geocoding(pub):

        urlopen.side_effect = lambda *args: StringIO(json.dumps({'address': 'xxx'}))

        get_app(pub).get('/api/reverse-geocoding', status=400)

        resp = get_app(pub).get('/api/reverse-geocoding?lat=0&lon=0')

            '?format=json&orig=coucou&email=%s' % urllib.quote(local_user.email), '1234')

        return signed_url[len('http://example.net'):]

        urlopen.side_effect = lambda *args: StringIO('''\

{"data": [{"id": 0, "text": "zéro", "foo": "bar"}, \

{"id": 1, "text": "uné", "foo": "bar1"}, \

def test_geocoding(pub):

        urlopen.side_effect = lambda *args: StringIO(json.dumps([{'lat': 0, 'lon': 0}]))

        get_app(pub).get('/api/geocoding', status=400)

        resp = get_app(pub).get('/api/geocoding?q=test')

    xlwt = None

from quixote import cleanup, get_publisher

from wcs.api_utils import sign_url

from wcs.qommon import errors, sessions

from wcs.qommon.form import PicklableUpload

from wcs.qommon.http_request import HTTPRequest

from wcs.roles import Role

from wcs.workflows import (Workflow, CommentableWorkflowStatusItem,

    app = login(get_app(pub))

        data = {'data': [{'id': 'A', 'text': 'hello'}, {'id': 'B', 'text': 'world'}]}

        def side_effect(url, *args):

            assert '?name_id=admin' in url

    app = get_app(pub)

        data1 = {'data': [{'id': 'A', 'text': 'hello'}, {'id': 'B', 'text': 'world'}]}

        data2 = {'data': [{'id': 'C', 'text': 'hello'}, {'id': 'D', 'text': 'world'}]}

        def side_effect(url, *args):

    data_source2 = NamedDataSource.select()[0]

    assert data_source2.data_source == data_source.data_source

        urlopen.side_effect = lambda *args: StringIO(

                '{"data": [{"id": 0, "text": "zéro"}, {"id": 1, "text": "uné"}, {"id": 2, "text": "deux"}]}')

        assert data_sources.get_items({'type': 'foobar'}) == [

    data_source.data_source = {'type': 'json', 'value': "https://api.example.com/json"}

    data_source.store()

        urlopen.side_effect = lambda *args: StringIO(

                '{"data": [{"id": 0, "text": "zero"}]}')

        assert len(data_sources.get_items({'type': 'foobar'})) == 1

    data_source.data_source = {'type': 'json', 'value': "https://api.example.com/json?foo=bar"}

    data_source.store()

        urlopen.side_effect = lambda *args: StringIO(

                '{"data": [{"id": 0, "text": "zero"}]}')

        assert len(data_sources.get_items({'type': 'foobar'})) == 1

    data_source.data_source = {'type': 'json', 'value': "https://no-secret.example.com/json"}

    data_source.store()

        urlopen.side_effect = lambda *args: StringIO(

                '{"data": [{"id": 0, "text": "zero"}]}')

        assert len(data_sources.get_items({'type': 'foobar'})) == 1

    datasource.data_source = {'type': 'json', 'value': 'http://whatever/'}

    datasource.store()

        urlopen.side_effect = lambda *args: StringIO(

            json.dumps({'data': [{'id': '1', 'text': 'foo'}, {'id': '2', 'text': 'bar'}]}))

    }

    assert pub.user_class.count() == 0

        http_post_request.return_value = (None, 200, json.dumps(token_result), None)

        http_get_page.return_value = (None, 200, json.dumps(user_info_result), None)

        resp = app.get('/ident/fc/callback?%s' % urllib.urlencode({

        id_token['nonce'] = qs['nonce'][0]

        token_result['id_token'] = '.%s.' % base64url_encode(json.dumps(id_token))

            http_post_request.return_value = (None, 200, json.dumps(token_result), None)

            http_get_page.return_value = (None, 200, json.dumps(user_info_result), None)

            resp = app.get('/ident/fc/callback?%s' % urllib.urlencode({

        'family_name': 'Deux',

        # 'email': 'john.deux@example.com',  # missing

    }

        http_post_request.return_value = (None, 200, json.dumps(token_result), None)

        http_get_page.return_value = (None, 200, json.dumps(bad_user_info_result), None)

        resp = app.get('/ident/fc/callback?%s' % urllib.urlencode({

from quixote import cleanup

from quixote.http_request import Upload

from wcs.qommon import sessions

from wcs import fields

from wcs.qommon.form import Form

    formdef.store()

    formdef.data_class().wipe()

        resp = get_app(pub).get('/test/')

        call_count = invalidate_cache.call_count

    formdef.store()

    # check the cache doesn't get invalidated for every page

        resp = get_app(pub).get('/test/')

        assert invalidate_cache.call_count == call_count

        data_source=ds, display_disabled_items=True,

        prefill={'type': 'formula', 'value': '["2"]'})]

        data = {'data': [{'id': '1', 'text': 'hello'}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

        data_source=ds, display_disabled_items=True)]

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello'}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

    formdef.data_class().wipe()

        data = {'data': [{'id': '1', 'text': 'hello', 'disabled': True}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

        display_disabled_items=False)]

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello', 'disabled': True}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

        data_source=ds, display_mode='radio', display_disabled_items=True)]

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello'}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

    formdef.data_class().wipe()

        data = {'data': [{'id': '1', 'text': 'hello', 'disabled': True}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

        data_source=ds, display_disabled_items=True)]

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello'}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

    formdef.data_class().wipe()

        data = {'data': [{'id': '1', 'text': 'hello', 'disabled': True}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

        data_source=ds, display_disabled_items=False)]

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello', 'disabled': True}, {'id': '2', 'text': 'world'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = get_app(pub).get('/test/')

    ]

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'},

                         {'id': '2', 'text': 'world', 'extra': 'bar'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

    # check hint is displayed within

    formdef.fields[0].hint = 'help text'

    formdef.store()

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'},

                         {'id': '2', 'text': 'world', 'extra': 'bar'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

    formdef.data_class().wipe()

    app = get_app(pub)

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'},

                         {'id': '2', 'text': 'world', 'extra': 'bar'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        pq = resp.pyquery.remove_namespaces()

        select2_url = pq('select').attr['data-select2-url']

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

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

    resp.form['f0'].force_value('1')

    resp.form.fields['f0_display'].force_value('hello')

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = resp.form.submit('submit') # -> validation page

        assert resp.form['f0'].value == '1'

        assert resp.form['f0_label'].value == 'hello'

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = resp.form.submit('submit') # -> submit

''')

    app = get_app(pub)

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'},

                         {'id': '2', 'text': 'world', 'extra': 'bar'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        pq = resp.pyquery.remove_namespaces()

        select2_url = pq('select').attr['data-select2-url']

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

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

    resp.form['f0'].force_value('1')

    resp.form.fields['f0_display'].force_value('hello')

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = resp.form.submit('submit') # -> validation page

        assert resp.form['f0'].value == '1'

        assert resp.form['f0_label'].value == 'hello'

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

        resp = resp.form.submit('submit') # -> submit

    formdef.store()

    app = get_app(pub)

        data = {'data': [{'id': '1', 'text': 'hello', 'extra': 'foo'},

                         {'id': '2', 'text': 'world', 'extra': 'bar'}]}

        urlopen.side_effect = lambda *args: StringIO.StringIO(json.dumps(data))

    formdef.store()

    app = get_app(pub)

        resp = app.get('/test/')

        assert urlopen.call_count == 0

        pq = resp.pyquery.remove_namespaces()

    resp.form['f0'].force_value('1')

    resp.form['f0_display'].force_value('hello')

        resp = resp.form.submit('submit') # -> validation page

        assert urlopen.call_count == 0

        assert resp.form['f0'].value == '1'

        assert resp.form['f0_label'].value == 'hello'

        resp = resp.form.submit('submit') # -> submit

        assert urlopen.call_count == 0

        assert formdef.data_class().select()[0].data['0'] == '1'

from quixote import cleanup

from quixote.http_request import Upload

from wcs.qommon.http_request import HTTPRequest

from wcs import fields, formdef

from wcs.categories import Category

from wcs.formdef import FormDef, fields, FormdefImportError

from wcs.workflows import Workflow

from wcs.roles import Role

from utilities import create_temporary_pub

    # simulate another locked cron

    import tempfile

    lockfile = os.path.join(tempfile.gettempdir(), 'wcs-cron-in-progress.lock')

    with locket.lock_file(lockfile, timeout=0):

        with mock.patch('wcs.qommon.management.commands.cron.cron_worker') as cron_worker:

from utilities import create_temporary_pub, clean_temporary_pub

from wcs.roles import Role, get_user_roles

def setup_module(module):

from django.test import override_settings

from quixote import cleanup

from wcs.conditions import Condition

from wcs.variables import LazyFormData

from wcs.roles import Role

from wcs.fields import StringField

from utilities import create_temporary_pub, clean_temporary_pub

from django.utils.six import StringIO

from quixote import cleanup, get_response

from quixote.http_request import Upload as QuixoteUpload

from wcs.qommon.http_request import HTTPRequest

from wcs.formdef import FormDef

from wcs import sessions

    item.body = 'my message'

    with mock.patch('wcs.wscalls.get_secret_and_orig') as mocked_secret_and_orig:

        mocked_secret_and_orig.return_value = ('secret', 'localhost')

            mocked_http_post.return_value = ('response', '200', 'data', 'headers')

            item.perform(formdata)

            url = mocked_http_post.call_args[0][0]

from wcs.tracking_code import TrackingCode

import wcs.qommon.emails

import wcs.qommon.sms

import wcs.middleware

    def __enter__(self):

        self.wcs_create_smtp_server = sys.modules['wcs.qommon.emails'].create_smtp_server

        sys.modules['wcs.qommon.emails'].create_smtp_server = self.create_smtp_server

        self.emails = {}

        return self

    def __exit__(self, exc_type, exc_value, tb):

        del self.emails

        sys.modules['wcs.qommon.emails'].create_smtp_server = self.wcs_create_smtp_server

class MockSubstitutionVariables(object):

    def __enter__(self):

        import wcs.qommon.misc

        self.wcs_qommon_misc_http_request = wcs.qommon.misc._http_request

        wcs.qommon.misc._http_request = self.http_request

        return self

    def __exit__(self, exc_type, exc_value, tb):

        import wcs.qommon.misc

        wcs.qommon.misc._http_request = self.wcs_qommon_misc_http_request

        del self.wcs_qommon_misc_http_request

    def http_request(self, url, method='GET', body=None, headers={},

            cert_file=None, timeout=None, raise_on_http_errors=False):

    def __enter__(self):

        self.sms = []

        self.wcs_get_sms_class = wcs.qommon.sms.SMS.get_sms_class

        wcs.qommon.sms.SMS.get_sms_class = self.get_sms_class

        return self

    def __exit__(self, exc_type, exc_value, tb):

        del self.sms

        wcs.qommon.sms.SMS.get_sms_class = self.wcs_get_sms_class

import os

sys.path.insert(0, os.path.dirname(__file__))

# 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.directory import Directory

from quixote.html import htmltext, TemplateIO

def get_email_type_label(type):

    from settings import EmailsDirectory

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.categories import Category

from wcs.formdef import FormDef

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.data_sources import (NamedDataSource, DataSourceSelectionWidget,

        get_structured_items)

from wcs.formdef import FormDef

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext, htmlescape

from wcs import fields

from wcs.formdef import FormDef

from quixote.directory import Directory, AccessControlled

from quixote.html import TemplateIO, htmltext

from wcs.formdef import FormDef, FormdefImportError, FormdefImportRecoverableError

from wcs.categories import Category

from wcs.workflows import Workflow

from wcs.forms.root import qrcode

from .categories import CategoriesDirectory

from .data_sources import NamedDataSourcesDirectory

from .logged_errors import LoggedErrorsDirectory

from quixote import get_response, get_publisher, redirect

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.logged_errors import LoggedError

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.roles import Role, get_user_roles

from wcs.formdef import FormDef

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.qommon.admin.texts import TextsDirectory

from wcs.formdef import FormDef

from wcs.carddef import CardDef

    def _q_lookup(self, component):

        get_response().breadcrumb.append( ('identification/', _('Identification')) )

class UserFieldDefPage(FieldDefPage):

        self.publisher.cfg['users'] = users_cfg

        self.publisher.write_cfg()

        if self.publisher.is_using_postgresql():

            sql.do_user_table()

            sql.do_tracking_code_table()

            sql.do_session_table()

        if path[1] in ('backoffice', 'admin') or \

                get_request().get_method() == 'POST':

            output = base_error_page(_("The theme preview doesn't support this."))

        else:

            output = root_directory._q_traverse(path[1:])

        if isinstance(output, template.QommonTemplateResponse):

            output = template.render(output.templates, output.context)

        theme_preview = decorate(output, response)

            identification_cfg = get_cfg('identification', {})

            for method in identification_cfg.get('methods', []):

                try:

                except AttributeError:

                    continue

            r += htmltext('<a rel="popup" href="install_theme">%s</a>') % _('Install New Theme')

            r += htmltext('<form action="themes" enctype="multipart/form-data" method="post">')

            r += htmltext('<ul class="biglist themes">')

            for theme, theme_dict in sorted(themes.items()):

                label = theme_dict.get('label')

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

            return r.getvalue()

        else:

            if themes.has_key(str(request.form['theme'])):

                branding_cfg = get_cfg('branding', {})

                branding_cfg[str('theme')] = str(request.form['theme'])

        if not theme_id:

            return redirect('themes')

        if not theme_directory:

            return redirect('themes')

            get_session().message = ('error', _('Theme is missing a desc.xml file.'))

            return redirect('themes')

        desc_xml = z.read('%s/desc.xml' % theme_name)

        if theme_dict.get('name') != theme_name:

            get_session().message = ('error', _('desc.xml is missing a name attribute.'))

            return redirect('themes')

        return self.install_theme_from_file(StringIO(fp.read()))

    def template(self):

        default_template_ezt = get_default_ezt_template()

        branding_cfg = get_cfg('branding', {})

        template = branding_cfg.get('template', default_template_ezt)

        return r.getvalue()

    def template_submit(self, form = None):

        theme_default_template_ezt = get_default_ezt_template()

        get_publisher().reload_cfg()

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

import wcs.qommon.storage as st

from wcs.roles import Role

class UserUI(object):

    def __init__(self, user):

                        'render_br': False,

                        'options': [(None, '---', None)] + [(x.id, x.name, x.id) for x in roles]})

            if klass.method_admin_widget:

                value = klass().get_value(self.user)

                form.add(klass.method_admin_widget, 'method_%s' % klass.key, required = False,

        self.user.store()

        ident_methods = get_cfg('identification', {}).get('methods', [])

            widget = form.get_widget('method_%s' % klass.key)

            if widget:

                klass().submit(self.user, widget)

        for method in ident_methods:

            try:

                                method, self.user).get_actions()

            except AttributeError:

                continue

            return r.getvalue()

        else:

            ident_methods = get_cfg('identification', {}).get('methods', [])

                if hasattr(klass, str('delete')):

                    klass().delete(self.user)

            self.user.remove_self()

        ident_methods = get_cfg('identification', {}).get('methods', [])

        if component in ident_methods:

            get_response().breadcrumb.append((component + '/', None))

class UsersDirectory(Directory):

    _q_exports = ['', 'new']

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.workflows import *

from wcs.carddef import CardDef

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.wscalls import NamedWsCall, WsCallRequestWidget

class NamedWsCallUI(object):

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

from django.http import HttpResponse, HttpResponseBadRequest

    UnknownNameIdAccessForbiddenError, RequestError)

from wcs.categories import Category

from wcs.conditions import Condition, ValidationError

import wcs.qommon.storage as st

from wcs.api_utils import sign_url_auto_orig, is_url_signed, get_user_from_api_query_string

def posted_json_data_to_formdata_data(formdef, data):

    # remap fields from varname to field id

        if get_publisher().is_using_postgresql() and not get_request().form.get('full') == 'on':

            from wcs import sql

            order_by = 'receipt_time'

            if get_request().form.get('sort') == 'desc':

                order_by = '-receipt_time'

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

from quixote import get_request, get_publisher

import qommon.misc

DEFAULT_DURATION = 30

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

from quixote.html import TemplateIO, htmltext

from wcs.carddef import CardDef

from wcs.roles import Role

from quixote import get_request, get_response, get_session, redirect

from quixote.html import TemplateIO, htmltext, htmlescape

from wcs.carddef import CardDef

from .management import ManagementDirectory, FormPage, FormFillPage, FormBackOfficeStatusPage

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext, htmlescape

        Intersects, ILike, FtsMatch, Contains, Null)

from wcs.api_utils import get_user_from_api_query_string

        if get_publisher().use_sms_feature:

            sms_cfg = get_cfg('sms', {})

            mode = sms_cfg.get('mode', 'none')

            if sms_class:

                form.add(StringWidget, 'sms', title=_('SMS Number'), required=False)

                form.add(RadiobuttonsWidget, 'method',

from quixote import get_publisher, get_request, get_response, redirect

from quixote.html import TemplateIO, htmltext

from wcs.formdef import FormDef

        return r.getvalue()

    def get_sidebar(self):

        r = TemplateIO(html=True)

        r += htmltext('<div class="bo-block">')

from quixote import get_publisher

from quixote.directory import Directory

class StudioDirectory(Directory):

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.formdata import FormData

from wcs.formdef import FormDef

import sys

from quixote import get_publisher

from wcs.carddata import CardData

from wcs.formdef import FormDef

from quixote import get_publisher, get_response

from quixote.html import htmltext

class Category(XmlStorableObject):

    _names = 'categories'

from quixote import get_publisher

from django.template import Context, Template, TemplateSyntaxError

class ValidationError(ValueError):

import time

import os

class CmdBackup(Command):

import hashlib

from quixote import cleanup

from wcs.admin.settings import UserFieldsFormDef

from wcs.fields import StringField, EmailField, DateField

        # initialize service provider side

        if not pub.cfg['sp'].get('publickey'):

            spconfig = pub.cfg['sp']

            spconfig['saml2_base_url'] = str(service.get('base_url')) + '/saml'

            spconfig['saml2_providerid'] = spconfig['saml2_base_url'] + '/metadata'

            (bfd, metadata_pathname) = tempfile.mkstemp('.metadata')

            atomic_write(metadata_pathname, s)

            admin_dir = AdminIDPDir()

            key_provider_id = admin_dir.submit_new_remote(

                    metadata_pathname, None, metadata_url, None)

from datetime import datetime

from shutil import rmtree

class CmdDeleteTenant(Command):

import os

class CmdExportSettings(Command):

    name = 'export_settings'

from quixote import get_publisher

from wcs.roles import Role

from wcs.admin.settings import UserFieldsFormDef

from wcs.qommon.misc import json_encode_helper

from django.core.management.base import BaseCommand, CommandError

class TenantCommand(BaseCommand):

from django.core.management.base import BaseCommand

from django.core.management.base import CommandError

from wcs import sql

from wcs.formdef import FormDef

from django.core.management.base import CommandError

from . import TenantCommand

from Bouncers import BouncerAPI

COMMA_SPACE = ', '

    name = 'process_bounce'

    def execute(self, base_options, sub_options, args):

        try:

            publisher.WcsPublisher.configure(self.config)

import os

def rebuild_vhost_indexes(pub, destroy=False):

    from wcs.formdef import FormDef

import tarfile

import os

class CmdRestore(Command):

import warnings

import sys

class CmdRunScript(Command):

    '''Run a script within a given host publisher context'''

import os.path

class CmdShell(Command):

    '''Launch a shell and initialize a publisher on a given host'''

import os

import sys

class CmdWipeData(Command):

    name = 'wipe-data'

from quixote import get_publisher, get_request, get_session

from quixote.html import TemplateIO

data_source_functions = {}

                ('carddef:%s' % x.url_name, x.name, 'carddef:%s' % x.url_name)

                for x in CardDef.select(lightweight=True, ignore_errors=True)

                if x.digest_template])

        options.insert(0, (None, _('None'), None))

        options.append(('json', _('JSON URL'), 'json'))

        items = [x.get_data_source_structured_item()

                 for x in carddef.data_class().select()

                 if not x.is_draft()]

        return items

    if data_source.get('type') not in ('json', 'jsonp', 'formula'):

                return []

            if len(value) == 0:

                return []

            if isinstance(value[0], list) or isinstance(value[0], tuple):

                if len(value[0]) >= 3:

                    return [{'id': x[0], 'text': x[1], 'key': x[2]} for x in value]

        unsigned_url = url

        url = sign_url_auto_orig(url)

        try:

            if type(entries) is not dict:

                raise ValueError('not a json dict')

            if type(entries.get('data')) is not list:

                cache.set(cache_key, items, cache_duration)

            return items

            get_logger().warn('Error loading JSON data source (%s)' % str(e))

        except ValueError as e:

            get_logger().warn('Error reading JSON data source output (%s)' % str(e))

        super(NamedDataSource, self).store()

    def get_new_slug(self):

        base_new_slug = new_slug

        suffix_no = 0

        while True:

        unsigned_url = url

        url = sign_url_auto_orig(url)

        if hasattr(request, 'datasources_cache'):

            request.datasources_cache[unsigned_url] = resp

        return resp

        value = None

        if self.type == 'json' and self.id_parameter:

            resp = self.load_json(self.id_parameter, option_id)

            if response['data']:

                value = response['data'][0]

        else:

from django.utils.html import urlize

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