Produits Entr'ouvert » Passerelle

        return query.q(request, q=None, full=full, **kwargs)

    def export_json(self):

        d['queries'] = [query.export_json() for query in self.queries.all()]

        return d

    def format_field(self, value, format_spec):

        if format_spec and format_spec[-1].isalpha() and format_spec[-1] == 'd':

            value = int(value)

        if not format_spec or not format_spec[-1].isalpha() or format_spec[-1] == 's':

            formatted = "'%s'" % formatted.replace("'", "''")

        return formatted

        return self.resource.mapservice_query(request, q=q, full=full, **kwargs)

    def as_endpoint(self):

        mapservice_endpoint = self.resource.mapservice_query.endpoint_info

        endpoint.func = mapservice_endpoint.func

    form_class = QueryForm

    def get_form_kwargs(self):

        kwargs['instance'] = self.model(resource=self.resource)

        return kwargs

            self.add_job('update_streets_data')

    def hourly(self):

        self.clean_addresses_cache()

    def daily(self):

        self.update_streets_data()

        self.update_api_geo_data()

class UnaccentNameMixin(object):

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

        self.unaccent_name = simplify(self.name)

@six.python_2_unicode_compatible

        return self.wsdl_base_url + service_type + '.svc?singleWsdl'

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

        if CartaDSDataCache.objects.count() == 0:

            # don't wait for daily job to get initial data

            self.add_job('update_data_cache')

    def soap_client(self, **kwargs):

        # fix URL that should have been changed by reverse proxy

        parsed_wsdl_address = urlparse.urlparse(client.service._binding_options['address'])

        parsed_real_address = urlparse.urlparse(self.wsdl_base_url)

            self.sync_subscribers_role(dossier)

    def hourly(self):

        self.update_dossier_cache()

    def daily(self):

        self.update_data_cache()

    @endpoint(description=_('Get list of collectivities'))

    sequence = ('nomDeFamille', 'nomUsgae', 'typeUsage')

    def __init__(self, data):

        if self.data.get('lastname'):

            self.nomDeFamille = self.data['lastname']

            self.nomUsage = self.data.get('usual_name', '')

    sequence = ('ville', 'province', 'pays')

    def __init__(self, data):

        if self.data.get('city'):

            self.ville = self.data['city']

            self.province = self.data.get('county', '')

    pattern = 'address_'

    def __init__(self, data):

        self.ligneAdr1 = self.data.get('street', '')

        self.ligneAdr2 = self.data.get('complement', '')

        self.codePostal = self.data.get('zipcode', '')

    pattern = 'birth_'

    def __init__(self, data):

        birthdate = self.data.get('date', None)

        if birthdate:

            self.date = BirthDate(birthdate)

    sequence = ('dateDebut', 'dateFin')

    def __init__(self, data):

        self.dateDebut = StartDate(self.data['event_date_start'])

        if data.get('event_date_end', None):

            self.dateFin = EndDate(self.data['event_date_end'])

    sequence = ('noms', 'prenoms', 'genre', 'adresse', 'sexe', 'pere', 'mere', 'naissance')

    def __init__(self, data):

        self.noms = Names(self.data)

        self.prenoms = self.data.get('firstnames', '')

        if self.data.get('title', None):

    def __init__(self, data, pattern):

        self.pattern = pattern

        sex = self.data.get('sex')

        if sex:

            if sex == 'M':

    sequence = ('noms', 'prenoms', 'genre', 'sexe', 'parent1', 'parent2', 'naissance')

    def __init__(self, data):

        self.parent1 = Parent(self.data, 'parent1_')

        self.parent2 = Parent(self.data, 'parent2_')

                raise Http404(_('Cmis type not found.'))

        else:

            self.current_type = None

    def get_context_data(self, **kwargs):

        ctx['object'] = self.connector

        if self.current_type:

            ctx['current_type'] = self.current_type

            self.get_rows()

        except Exception as e:

            raise ValidationError(_('Invalid CSV file: %s') % e)

    def _detect_dialect_options(self):

        content = self.get_content_without_bom()

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

        cache = kwargs.pop('cache', True)

        if cache:

            self.cache_data()

        return result

            return {'data': list(data[0].values())[0]}

    def export_json(self):

        d['queries'] = [query.export_json() for query in Query.objects.filter(resource=self)]

        return d

    template_name = 'csvdatasource/query_form.html'

    def get_context_data(self, **kwargs):

        ctx['resource'] = CsvDataSource.objects.get(slug=self.kwargs['connector_slug'])

        return ctx

    template_name = 'csvdatasource/query_form.html'

    def get_context_data(self, **kwargs):

        ctx['resource'] = CsvDataSource.objects.get(slug=self.kwargs['connector_slug'])

        return ctx

    model = Query

    def get_context_data(self, **kwargs):

        ctx['resource'] = CsvDataSource.objects.get(slug=self.kwargs['connector_slug'])

        return ctx

                module = sys.modules[modname]

                module.Loader(self).clean(archive)

    @transaction.atomic

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

        if not zipfile.is_zipfile(self.archive.path):

            return

    template_name = 'gdc/gdc_detail.html'

    def get_context_data(self, **kwargs):

        if phpserialize is None:

            context['missing_phpserialize'] = True

        return context

                    form.save()

    def hourly(self):

        self.get_responses()

    def send_demand(self, form_id):

            template = Template(text_value_template)

            context = Context(self.content)

            self.text = template.render(context).strip()

    def to_json(self):

        return {

        self.flow_type = args[0]

        self.num = args[1]

        self.doc = kwargs.get('doc')

    def save(self, folder):

    @property

    def code(self):

        doc=None,

    ):

        etree._namespace_map[self.ns_uri] = self.ns_prefix

        user_comment=None,

    ):

        self.step = step

        root = ElementFactory('EnteteMetierEnveloppe', attrib={'xmlns': self.xmlns})

        return '%s-doc-.xml' % self.demand_id

    def save(self, folder):

    def data_validator(self, data):

        """Checks if required keys are present"""

        # only possible value : vol as 'Inscription Volontaire'

        data['inscription_type'] = 'vol'

class AECData(Data):

        self.root_element = 'EnveloppeMetierType'

        self.root_attributes = {'canal_utilise': '0'}

def json_to_xml(path, value, parent):

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

        self.demand_id = '%s-%s' % (self.num, self.flow_type)

    @property

    def name(self):

        text = kwargs.pop('text', None)

        namespace = kwargs.pop('namespace', None)

        if namespace:

            self.namespace = namespace

        else:

        if text:

            self.text = text

            if found is not None:

                return self

        return self

    def extend(self, elements):

        return self

        self.text = kwargs.pop('text', None)

        namespace = kwargs.pop('namespace', None)

        if namespace:

            self.namespace = namespace

        else:

    def append(self, element, allow_new=True):

            if found is not None:

                return self

        return self

    def extend(self, elements):

        return self

        verbose_name = _('OpenDataSoft Web Service')

    def export_json(self):

        data['queries'] = [query.export_json() for query in self.queries.all()]

        return data

        )

    def as_endpoint(self):

        search_endpoint = self.resource.search.endpoint_info

        endpoint.func = search_endpoint.func

    template_name = "passerelle/manage/resource_child_form.html"

    def get_form_kwargs(self):

        kwargs['instance'] = self.model(resource=self.resource)

        return kwargs

        return query.q(request, bbox, q, circle, **kwargs)

    def export_json(self):

        d['queries'] = [query.export_json() for query in self.queries.all()]

        return d

        return instance

    def daily(self):

        self.update_queries()

    def update_queries(self, query_id=None):

        return reverse('opengis-query-new', kwargs={'slug': self.slug})

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

        if self.queries.exists():

            self.add_job('update_queries')

    def as_endpoint(self):

        resource_endpoint = self.resource.query.endpoint_info

        # use parameters added by resource endpoint

        endpoint.func = resource_endpoint.func

        endpoint.show_undocumented_params = False

            FeatureCache.objects.bulk_create(features)

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

        self.resource.add_job('update_queries', query_id=self.pk)

        return context

    def get_form_kwargs(self):

        kwargs['instance'] = self.model(resource=self.resource)

        return kwargs

        }

    def hourly(self):

        # close unfinished long calls

        maximal_time = now() - timedelta(minutes=self.max_call_duration)

        Call.objects.filter(resource=self, end_timestamp=None, start_timestamp__lt=maximal_time).update(

        )

    def daily(self):

        # remove finished old calls

        maximal_time = now() - timedelta(days=self.data_retention_period)

        Call.objects.filter(

        verbose_name = _('Plone REST API Web Service')

    def export_json(self):

        data['queries'] = [query.export_json() for query in self.queries.all()]

        return data

        )

    def as_endpoint(self):

        search_endpoint = self.resource.search.endpoint_info

        endpoint.func = search_endpoint.func

    template_name = "passerelle/manage/resource_child_form.html"

    def get_form_kwargs(self):

        kwargs['instance'] = self.model(resource=self.resource)

        return kwargs

            forms.Select,

            forms.TextInput,

        ]

    def decompress(self, value):

        if not value:

            forms.ChoiceField(choices=choices, required=required),

            forms.CharField(required=False, validators=[validate_django_template]),

        ]

            fields=fields,

            required=required,

            widget=widget,

class MappingForm(forms.ModelForm):

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

        if self.instance.procedure and self.instance and self.instance.formdef:

            choices = [('', '--------')] + [(v, v) for v in self.instance.variables]

            for i, field in enumerate(self.schema_fields()):

            value['label'] = self.fields[key].label

            fields[real_key] = value

        self.instance.rules['fields'] = fields

    class Meta:

        model = models.Mapping

            self.archive.delete()

        except Exception:

            self.resource.logger.error('could not delete %s', self.archive)

    @property

    def message_xml(self):

    def form_valid(self, form):

        if set(form.changed_data) & set(['procedure', 'formdef']):

            self.has_changed = True

    def get_success_url(self):

        if self.has_changed:

            return self.get_changed_url()

    def get_changed_url(self):

        return ''

    def form_valid(self, form):

        form.instance.resource = self.resource

    def get_changed_url(self):

        return self.object.get_absolute_url()

        return self.resource_class.objects.get(slug=self.kwargs['slug'])

    def get_queryset(self):

        return qs.filter(resource=self.resource)

    def get_success_url(self):

        pass

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

        self.logger = ProxyLogger(connector=self, transaction_id=str(uuid.uuid4()))

    def __str__(self):

class SkipJob(Exception):

    def __init__(self, after_timestamp=None):

        self.after_timestamp = after_timestamp

class Job(models.Model):

        raise PermissionDenied

    def get_context_data(self, slug=None, **kwargs):

        context['site_base_uri'] = '%s://%s' % (

            'https' if self.request.is_secure() else 'http',

            self.request.get_host(),

    ordering = 'id'

    def get_context_data(self, slug=None, **kwargs):

        context['trusted_services'] = get_trusted_services()

        return context

    template_name = 'passerelle/manage/accessright_confirm_delete.html'

    def get_object(self):

        self.resource = object.resource

        return object

        if not form.cleaned_data['apiuser'].key and not form.allow_open_access:

            form.add_confirmation_checkbox()

            return self.form_invalid(form)

    def get_success_url(self):

        return self.object.resource.get_absolute_url()

    template_name = 'passerelle/manage/logging_parameters_form.html'

    def get_context_data(self, **kwargs):

        context['connector'] = self.get_resource()

        return context

        parameters.responses_max_size = form.cleaned_data['responses_max_size']

        parameters.log_retention_days = form.cleaned_data['log_retention_days']

        parameters.save()

class ManageAvailabilityView(UpdateView):

        return self.get_resource().availability_parameters

    def get_context_data(self, **kwargs):

        context['connector'] = self.get_resource()

        context['availability_status'] = self.get_resource().get_availability_status()

        return context

            if form.instance.run_check:

                resource.availability()

class GenericViewJobsConnectorView(GenericConnectorMixin, ListView):

    paginate_by = 25

    def get_context_data(self, **kwargs):

        connector = self.get_object()

        context['object'] = connector

        context['query'] = self.request.GET.get('q') or ''

    template_name = 'passerelle/manage/job.html'

    def get_context_data(self, **kwargs):

        try:

            context['job'] = Job.objects.get(pk=self.kwargs['job_pk'])

        except Job.DoesNotExist:

        except ImportSiteError as e:

            form.add_error('site_json', e)

            return self.form_invalid(form)

class ExportSiteView(View):

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

        if not self.jsondatabase:

            self.jsondatabase = default_database()

    @classmethod

    def get_verbose_name(cls):

        return {'err': 1}

    def daily(self):

        update_start = timezone.now()

        sections = self.requests.get(

            'https://download.data.grandlyon.com/ws/grandlyon/adr_voie_lieu.adraxevoie/all.json?maxfeatures=1000000'

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

        if self.nom:

            self.normalized_name = normalize_street(self.nom)

    @method_decorator(csrf_exempt)

    def dispatch(self, request, *args, **kwargs):

    @utils.protected_api('can_access')

    @utils.to_json()

            self.stop(None, stop_object.id)

    def daily(self):

        start_update = timezone.now()

        with transaction.atomic():

        else:

            raise Exception('unknown TCL line %r' % self.code_titan)

class Stop(models.Model):

        self.message = message

        self.xml_request = xml_request

        self.xml_response = xml_response

    def __str__(self):

        return self.message

    def save(self, commit=True):

        if not self.instance.slug:

            self.instance.slug = slugify(self.instance.title)

class ResourceLogSearchForm(forms.Form):

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

        from passerelle.sms.models import SMSResource

        self.fields['authorized'] = forms.MultipleChoiceField(

            choices=SMSResource.AUTHORIZED,

            widget=forms.CheckboxSelectMultiple,

        return ', '.join(result)

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

        self.get_authorized_display = self._get_authorized_display

    def clean_numbers(self, destinations):

            messages.error(self.request, _('Sending SMS fails: %s' % exc))

        else:

            messages.success(self.request, _('An SMS was just sent'))

class SmsStatisticsView(View):

class DecoratedURLPattern(URLPattern):

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

        if result:

            result.func = self._decorate_with(result.func)

        return result

class DecoratedURLResolver(URLResolver):

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

        if result:

            result.func = self._decorate_with(result.func)

        return result

        self.logger = kwargs.pop('logger')

        self.resource = kwargs.pop('resource', None)

        timeout = kwargs.pop('timeout', None)

        if self.resource:

            timeout = timeout if timeout is not None else getattr(self.resource, 'requests_timeout', None)

            http_adapter_init_kwargs = {}

            if kwargs.get('verify') is False:

                # disable urllib3 warnings

                warnings.simplefilter(action='ignore', category=InsecureRequestWarning)

        if method == 'GET' and cache_duration and (response.status_code // 100 == 2):

            cache.set(

    def send(self, request, **kwargs):

        start_time = time.time()

        try:

            duration = time.time() - start_time

        except Exception as exc:

            duration = time.time() - start_time

        self.log_error = kwargs.pop('log_error', False)

        self.http_status = kwargs.pop('http_status', 200)

        self.__dict__.update(kwargs)

class JSONEncoder(DjangoJSONEncoder):

    def default(self, o):

        if isinstance(o, time.struct_time):

            o = datetime.datetime(*tuple(o)[:6])

class to_json(object):

            forms.Textarea,

            forms.TextInput,

        ]

    def decompress(self, value):

        if not value:

            forms.CharField(required=False),

            forms.CharField(required=False),

        ]

    def compress(self, data_list):

        if not data_list:

    def __init__(self, **kwargs):

        kwargs.setdefault('default', None)

    def get_internal_type(self):

        return 'TextField'

            'form_class': SFTPFormField,

        }

        defaults.update(**kwargs)

        transport = transport_class(

            resource, wsdl_url, session=resource.requests, cache=InMemoryCache(), **transport_kwargs

        )

class ResponseFixContentWrapper:

        self.wsdl_host = urlparse.urlparse(wsdl_url).netloc

        # fix content for servers returning unexpected characters before XML document start

        self.remove_first_bytes_for_xml = remove_first_bytes_for_xml

    def _load_remote_data(self, url):

        try:

                response = self.session.get(url, timeout=self.load_timeout, auth=None, cert=None)

                response.raise_for_status()

                return response.content

        except RequestException as e:

            raise SOAPError(

                'SOAP service is down, location %r cannot be loaded: %s' % (url, e), exception=e, url=url

    fields = None

    def __init__(self, wcs_api, **kwargs):

        if self.status is not None:

            self.status = BaseObject(wcs_api, **self.status)

        self.fields = self.fields or {}

    parts = None

    def __init__(self, wcs_api, **kwargs):

        self.time = isodate.parse_datetime(self.time)

        if self.parts:

            self.parts = [BaseObject(wcs_api, **part) for part in self.parts]

    def __init__(self, wcs_api, forms, **kwargs):

        self.forms = forms

        self.receipt_time = isodate.parse_datetime(self.receipt_time)

        if self.submissions:

            self.submission = BaseObject(wcs_api, **self.submission)

    fields = None

    def __init__(self, wcs_api, **kwargs):

        self.statuses = [BaseObject(wcs_api, **v) for v in (self.statuses or [])]

        assert not hasattr(self.statuses[0], 'startpoint'), 'startpoint is exported by w.c.s. FIXME'

        for status in self.statuses:

    geolocations = None

    def __init__(self, wcs_api, **kwargs):

        self.workflow = Workflow(wcs_api, **self.workflow)

        self.fields = [Field(wcs_api, **f) for f in self.fields]

        self.geolocations = sorted((k, v) for k, v in (self.geolocations or {}).items())

class FormDefFormField(forms.TypedChoiceField):

    def __init__(self, **kwargs):

    def get_formdef_choices(self):

        requests = getattr(self, 'requests', None)

            'form_class': FormDefFormField,

        }

        defaults.update(kwargs)

class TransformConverter(xmlschema.UnorderedConverter):

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

        self.transformer = kwargs.pop('transformer', None)

    def copy(self, **kwargs):

        transformer = kwargs.pop('transformer', self.transformer)

        new.transformer = transformer

        return new

                mapped = self.transformer.type_map[xsd_element.type.name]

                if hasattr(self.transformer, 'decode_%s' % mapped):

                    data = getattr(self.transformer, 'decode_%s' % mapped)(data)

    def element_encode(self, obj, xsd_element, *args):

        if self.transformer:

                mapped = self.transformer.type_map[xsd_element.type.name]

                if hasattr(self.transformer, 'encode_%s' % mapped):

                    obj = getattr(self.transformer, 'encode_%s' % mapped)(obj)

class JSONSchemaFromXMLSchema(object):

            return HttpResponseRedirect(

                resolve_url('mellon_login') + '?next=' + quote(request.GET.get('next'))

            )

login = LoginView.as_view()

    template_name = 'passerelle/manage.html'

    def get_context_data(self, **kwargs):

        # get all app instances

        context['apps'] = []

        for app in get_all_apps():

    template_name = 'passerelle/manage_add.html'

    def get_context_data(self, **kwargs):

        context['apps'] = [x for x in get_all_apps() if not x.is_legacy()]

        context['apps'].sort(key=lambda x: x.get_verbose_name())

        return context

    def dispatch(self, request, *args, **kwargs):

        self.init_stuff(request, *args, **kwargs)

class GenericConnectorView(GenericConnectorMixin, DetailView):

    def get_context_data(self, slug=None, **kwargs):

        context['has_check_status'] = not hasattr(context['object'].check_status, 'not_implemented')

        return context

    def form_valid(self, form):

        with transaction.atomic():

        self.object.availability()

        return response

    def init_stuff(self, request, *args, **kwargs):

        # tell JS to prepopulate 'slug' field using the 'title' field

        self.get_form_class().base_fields['title'].widget.attrs['data-slug-sync'] = 'slug'

    def form_valid(self, form):

        with transaction.atomic():

        self.object.availability()

        return response

    paginator_class = InfinitePaginator

    def get_context_data(self, **kwargs):

        context['object'] = self.get_object()

        context['form'] = self.form

        if self.request.GET.get('log_id'):

    template_name = 'passerelle/manage/log.html'

    def get_context_data(self, **kwargs):

        try:

            context['logline'] = ResourceLog.objects.get(

                pk=self.kwargs['log_pk'], appname=self.kwargs['connector'], slug=self.kwargs['slug']

        if kwargs.get('endpoint') == 'up' and hasattr(self.connector.check_status, 'not_implemented'):

            # hide automatic up endpoint if check_status method is not implemented

            raise Http404()

    def _allowed_methods(self):

        return [x.upper() for x in self.endpoint.endpoint_info.methods]

class ReplyDataClass(dict):

    def __init__(self, **kwargs):

        self.__dict__.update(kwargs)

class WebFaultHavingLatin1(WebFault):

    BAR_SCHEMA = copy.deepcopy(FOO_SCHEMA)

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

        self.logger = ProxyLogger(connector=self)

    @property