Produits Entr'ouvert » Passerelle

import base64

import hashlib

import os

import pytest

import requests

SPECIAL_CHARS = '!#$%&+-^_`;[]{}+='

    orig_file = tmpdir.join(file_name)

    with orig_file.open('wb') as f:

        f.write(os.urandom(1024))

    with orig_file.open('rb') as f:

        file_b64_content = base64.b64encode(f.read())

    response = requests.post(

def test_uploadfile_conflict(cmisclient, cmis_connector, cmis_tmpdir, tmpdir, monkeypatch):

    file_b64_content = base64.b64encode('file_content')

    response = requests.post(

        url,

import pprint

import random

import requests

def test_main(conn):

    # get days

        {'start_days': 1, 'end_days': 90, 'start_time': '10:00', 'end_time': '11:00', 'display': 'date'}

    )

    url = conn + '/getfreegaps?%s' % query_string

    assert data

    # get places

        {'start_days': 1, 'end_days': 90, 'start_time': '10:00', 'end_time': '11:00', 'display': 'place'}

    )

    url = conn + '/getfreegaps?%s' % query_string

    place = data[random.randint(0, len(data) - 1)]['id']

    # get days on one place

        {

            'start_days': 1,

            'end_days': 90,

from __future__ import unicode_literals

import contextlib

import os

import stat

import tempfile

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.conversion import ensure_encoding

from passerelle.utils.jsonresponse import APIError

    @endpoint(perm='can_access', methods=['post'], description=_('Create demand'))

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

        try:

        except (ValueError,):

            raise APIError('Invalid payload format: json expected')

   https://entreprise.api.gouv.fr

'''

import requests

from django.core import signing

from django.db import models

from django.urls import reverse

from django.utils.timezone import datetime, make_aware, timedelta

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

        params['recipient'] = kwargs.get('recipient') or self.recipient

        if kwargs.get('non_diffusables'):

            params['non_diffusables'] = 'true'

        try:

            response = self.requests.get(url, data=params, cache_duration=300)

        except requests.RequestException as e:

from django.contrib.postgres.fields import ArrayField

from django.core.cache import cache

from django.db import models

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

                data={

                    'code': 'connection-error',

                    'platform': self.platform,

                },

            )

        try:

                data={

                    'code': 'non-json',

                    'status_code': response.status_code,

                    'platform': self.platform,

                    'content': content,

                },

from urllib import parse as urlparse

from django.db import models

from django.utils.dateparse import parse_date, parse_time

from django.utils.translation import ugettext_lazy as _

from requests import RequestException

        if result.get('Data'):

            if 'AccessToken' not in result['Data']:

                raise APIError('Error on LoginParSubOIDC: missing Data/AccessToken')

                raise APIError('Error on LoginParSubOIDC: Data/AccessToken is not string')

            return result['Data']['AccessToken']

        raise APIError('%s (%s)' % (result.get('LibErreur'), result.get('CodErreur')))

import requests

from django.contrib.postgres.fields import JSONField

from django.db import models

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource, HTTPResource

            response = self.requests.get(url, *args, **kwargs)

            response.raise_for_status()

        except requests.RequestException as e:

        try:

            root = ET.fromstring(response.content)

        except ET.ParseError as e:

        if root.tag != 'return':

            raise APIError('root XML node is not return', data={'content': response.text[:1024]})

        return root, response

from django.core.cache import cache

from django.db import transaction

from passerelle.utils.jsonresponse import APIError

        if self.row:

            keys.append(str(self.row.pk))

        for arg in args:

                keys.append(arg)

            else:

                keys.append(hash(arg))

import datetime

import gzip

from urllib import parse as urlparse

from django.contrib.postgres.fields import JSONField

from django.db import connection, models

from django.db.models import Q

from django.utils.http import urlencode

from django.utils.translation import ugettext_lazy as _

from requests import RequestException

from passerelle.address.models import AddressResource

from passerelle.utils.api import endpoint

from passerelle.utils.conversion import simplify

from passerelle.utils.jsonresponse import APIError

            if ban_gz.status_code != 200:

                continue

            line = _not_found = object()

            for line in ban_file:

                if street_info['type'] != 'street':

                    continue

                ban_id = street_info.get('id')

                    continue

                for key in ('postcode', 'name', 'city'):

                    if isinstance(street_info[key], list):

                if not street_info['postcode'] or not street_info['postcode'].startswith(zipcodes):

                    continue

                citycode = ban_id.split('_', 1)[0]

        super().save(*args, **kwargs)

class StreetModel(UnaccentNameMixin, models.Model):

    ban_id = models.CharField(_('BAN Identifier'), max_length=32, blank=True)

        return self.name

class RegionModel(UnaccentNameMixin, models.Model):

    name = models.CharField(_('Region name'), max_length=150)

        return '%s %s' % (self.code, self.name)

class DepartmentModel(UnaccentNameMixin, models.Model):

    name = models.CharField(_('Department name'), max_length=100)

        return '%s %s' % (self.code, self.name)

class CityModel(UnaccentNameMixin, models.Model):

    name = models.CharField(_('City name'), max_length=150)

from django.http import Http404

from django.views.generic.base import View

from django.views.generic.detail import DetailView, SingleObjectMixin

from passerelle import utils

from .models import Bdp

    @utils.protected_api('can_access')

    @utils.to_json()

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

        date_de_naissance = data['fields'].get('date_de_naissance')

        # force 1973-04-18T00:00:00Z

        date_de_naissance = date_de_naissance[:10] + 'T00:00:00Z'

import requests

from django.db import models

from django.utils.translation import ugettext_lazy as _

from passerelle.sms.models import SMSResource

                        results.append('Choosit error: %s' % output['error'])

                    else:

                        results.append(output)

            raise APIError('Choosit error: some destinations failed', data=list(zip(destinations, results)))

        # credit consumed is unknown

import stat

from django.core.files.storage import default_storage

from django.utils.dateparse import parse_date

from django.utils.encoding import force_bytes

from lxml import etree

            attr = getattr(self, subelt, None)

            if not attr:

                continue

                tag.append(self.make_element(subelt, attr, namespace=self.namespace))

            else:

                xml = attr.xml

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

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

import os

from django.core.files.storage import default_storage

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

    @endpoint(perm='can_access', methods=['post'], description=_('Create a demand'))

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

        # check mandatory keys

        for key in ('application_id', 'application_time', 'certificate_type'):

            if key not in payload:

from django.views.generic.base import View

from django.views.generic.detail import DetailView, SingleObjectMixin

from passerelle import utils

from passerelle.apps.clicrdv.models import ClicRdv

class ClicRdvDetailView(DetailView):

    def post(self, request, intervention_id=None, *args, **kwargs):

        if intervention_id is None:

            intervention_id = self.request.GET.get('intervention')

        return {

            'data': self.get_object().create_appointment(

                intervention_id, self.request.GET.get('websource'), data

import functools

import re

from contextlib import contextmanager

from urllib import error as urllib2

import httplib2

)

from django.db import models

from django.utils.functional import cached_property

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from collections import OrderedDict

import pytz

from django.conf import settings

from django.contrib.postgres.fields import JSONField

from django.core.exceptions import ValidationError

        options = {}

        for k, v in self._dialect_options.items():

                v = force_str(v.encode('ascii'))

            options[force_str(k.encode('ascii'))] = v

import csv

import datetime

from decimal import Decimal

from django.core.exceptions import ValidationError

from django.utils.encoding import force_text

from django.utils.translation import ugettext_lazy as _

    def load(self, archive):

        archive_files = archive.namelist()

        fd = archive.open('data_full.csv')

        csvreader = csv.reader(csvfile, delimiter='\t')

        first_row = next(csvreader)

        csvfile.seek(0)

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

import csv

import os

from decimal import Decimal

from django.core.exceptions import ValidationError

from django.core.files.storage import DefaultStorage

from django.utils.encoding import force_text

from django.utils.translation import ugettext_lazy as _

    def csvread(self, filename):

        fd = self.archive.open(filename)

        reader = csv.reader(fd, Dialect)

        # pylint: disable=stop-iteration-return

import csv

import datetime

from decimal import Decimal

from django.core.exceptions import ValidationError

from django.utils.encoding import force_text

from django.utils.translation import ugettext_lazy as _

    def load(self, archive):

        archive_files = archive.namelist()

        fd = archive.open('publipostage.csv')

        csvreader = csv.reader(csvfile, delimiter=';')

        first_row = next(csvreader)

        csvfile.seek(0)

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

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

import os

import sys

import zipfile

from django.core.files.storage import default_storage

from django.db import models, transaction

from django.http import Http404, HttpResponse

from django.utils.timezone import datetime, make_aware, now

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

SEXES = (

            adults = []

            for f in family_files:

                families.append(family_data['id'])

                address = family_data.get('address') or {}

                family_data.update(address)

        name='regie', methods=['post'], perm='can_access', pattern=r'^invoice/(?P<invoice_id>\w+)/pay/$'

    )

    def pay_invoice(self, request, invoice_id, **kwargs):

        invoice = self.get_invoice(invoice_id)

        if not invoice:

            return {'data': False}

        return self.external_id

class Person(models.Model):

    family = models.ForeignKey('Family', on_delete=models.CASCADE)

    external_id = models.CharField(_('Person\'s external id'), max_length=32, db_index=True)

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

from django.utils.encoding import force_text

from django.views.generic.base import View

from django.views.generic.detail import DetailView, SingleObjectMixin

from passerelle import utils

from passerelle.utils.conversion import normalize

from .models import Gdc, phpserialize, phpserialize_loads

        #   <wsdl:part name='voie_id' type='xsd:string'></wsdl:part>

        #   <wsdl:part name='voie_num' type='xsd:string'></wsdl:part>

        # </wsdl:message>

        voie_id = data['fields'].get('voie_raw')

        voie_str = data['fields'].get('voie')

        insee = data['fields'].get('commune_raw')

from django.contrib.postgres.fields import JSONField

from django.db import IntegrityError, models, transaction

from django.http import Http404

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

                if not csv_file.startswith(self.input_files_prefix):

                    continue

                with client.open(csv_file, 'rb') as fd:

                    for row in csv.reader(content, delimiter=CSV_DELIMITER):

                        data.append(row)

        for card_data in data:

    def send(self):

        with self.resource.outcoming_sftp.client() as client:

            with client.open(self.get_filename(), mode='wb') as fd:

                writer = csv.writer(fd, delimiter=CSV_DELIMITER)

                for row in self.demand_data:

                    writer.writerow(row)

        self.status = 'sent'

        self.save()

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

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

import uuid

from django.contrib.postgres.fields import JSONField

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import APIError, endpoint

from passerelle.utils.conversion import simplify

def clean_json_data(data):

    try:

        if not isinstance(payload, dict):

            raise APIError('payload must be a dict')

        return payload

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

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

import os

from django.db import models

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils import SFTPField

from passerelle.utils.api import endpoint

from passerelle.utils.files import atomic_write

    @endpoint(perm='can_access', methods=['post'])

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

        """Create a demand"""

        extra = formdata.pop('extra', {})

        fields = formdata.pop('fields', {})

            self.get_response_files()

class Demand(models.Model):

    created_at = models.DateTimeField(auto_now_add=True)

    updated_at = models.DateTimeField(auto_now=True)

from django.db import IntegrityError, models, transaction

from django.http import HttpResponse

from django.urls import reverse

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource, SkipJob

            return

class Demand(models.Model):

    STATUS_PENDING = 'pending'

    STATUS_PUSHED = 'pushed'

import xmlschema

from django.db import models

from django.utils.translation import ugettext_lazy as _

from passerelle.utils.api import endpoint

                else:

                    del d['filiationInconnu']

            # convert codeNationalite to array of strings

                d['codeNationalite'] = [d['codeNationalite']]

            for key in d:

                if key in ('anneeNaissance', 'jourNaissance', 'moisNaissance'):

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

    @endpoint(name='subscriber', methods=['post'], perm='can_access')

    def create_subscriber(self, request):

        try:

        except ValueError:

            raise APIError('payload must be a JSON object', http_status=400)

        if not isinstance(payload, dict):

        qrcode = self.request('subscribers/%s/qrcode' % subscriber_id, result_is_json=False)

        content_type = qrcode.headers.get('Content-Type')

        if not (content_type and content_type.startswith('image/')):

            raise APIError(response['message'], http_status=response['status'], err=response['code'])

        return HttpResponse(qrcode.content, content_type=content_type)

    @endpoint(name='subscription', methods=['post'], perm='can_access')

    def create_subscription(self, request):

        try:

        except ValueError:

            raise APIError('payload must be a JSON object', http_status=400)

        if not isinstance(payload, dict):

import xml.etree.ElementTree as ET

import pyproj

from django.contrib.postgres.fields import JSONField

from django.core.cache import cache

from django.db import models, transaction

            for attribute, properties in self.attributes_mapping:

                for field in properties:

                    if closest_feature['properties'].get(field):

                        break

            return result

        raise APIError('Unable to geocode')

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

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

from urllib.parse import parse_qsl, urlsplit, urlunsplit

from django.core.cache import cache

from requests import RequestException

from passerelle.base.models import BaseQuery, BaseResource, HTTPResource

from passerelle.utils.api import endpoint

from passerelle.utils.http_authenticators import HttpBearerAuth

from passerelle.utils.json import unflatten

    )

    def create(self, request, uri, publish=False):

        try:

        except ValueError as e:

            raise ParameterTypeError(str(e))

        post_data = unflatten(post_data)

    )

    def update(self, request, uid, uri=''):

        try:

        except ValueError as e:

            raise ParameterTypeError(str(e))

        post_data = unflatten(post_data)

import base64

import copy

from django.db import models

from django.template.loader import get_template

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.conversion import simplify, to_pdf

from passerelle.utils.jsonresponse import APIError

    )

    def apa_link(self, request):

        try:

        except ValueError:

            raise APIError('payload is not a JSON dict')

        if not isinstance(data, dict):

    )

    def apa_unlink(self, request):

        try:

        except ValueError:

            raise APIError('payload is not a JSON dict')

        if not isinstance(data, dict):

    )

    def apa_integration(self, request):

        try:

        except ValueError:

            raise APIError('payload is not a JSON object', http_status=400)

        if not isinstance(payload, dict):

    )

    def rsa_link(self, request):

        try:

        except ValueError:

            raise APIError('payload is not a JSON dict')

        if not isinstance(data, dict):

    )

    def rsa_unlink(self, request):

        try:

        except ValueError:

            raise APIError('payload is not a JSON dict')

        if not isinstance(data, dict):

from django.db import models, transaction

from django.template import engines

from django.urls import reverse

from django.utils.translation import ugettext

from django.utils.translation import ugettext_lazy as _

from lxml import etree as ET

    '''Simplify XML node tag names because XSD from DGME are garbage'''

    if not s:

        return ''

    s = normalize(s)

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

    s = s.replace('-', '_')

    return {}

class Mapping(models.Model):

    resource = models.ForeignKey(

        Resource, verbose_name=_('Resource'), related_name='mappings', on_delete=models.CASCADE

import datetime

import isodate

from lxml import etree as ET

from zeep.utils import qname_attr

TYPE_CASTER = {

    BOOLEAN: parse_bool,

    DATE: parse_date,

    INT: int,

    INTEGER: int,

    def qname_display(self, name):

        if name.namespace in self.reverse_nsmap:

            name = '%s:%s' % (self.reverse_nsmap[name.namespace], name.localname)

    def paths(self):

        roots = sorted(self.elements.keys())

                yield path

class Path:

    def __init__(self, path, xsd_type):

        assert path

        try:

            self.caster = TYPE_CASTER[xsd_type]

        except KeyError:

    def resolve(self, root):

        def helper(node, path):

            return self.caster(child.text)

    def __str__(self):

from django.forms.widgets import ClearableFileInput

from django.test import override_settings

from django.urls import reverse

from django.utils.encoding import force_text

from django.utils.log import AdminEmailHandler

from django.utils.text import slugify

)

class ApiUser(models.Model):

    username = models.CharField(max_length=128, verbose_name=_('Username'), unique=True)

    fullname = models.CharField(max_length=50, verbose_name=_('Full Name'))

        return self.filter(Q(users=None) | Q(users=apiuser))

class BaseResource(models.Model):

    title = models.CharField(max_length=50, verbose_name=_('Title'))

    slug = models.SlugField(verbose_name=_('Identifier'), unique=True)

        ).exists()

class AccessRight(models.Model):

    codename = models.CharField(max_length=100, verbose_name='codename')

    resource_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)

    def set_after_timestamp(self, value):

        if isinstance(value, datetime.datetime):

            self.after_timestamp = value

            self.after_timestamp = timezone.now() + datetime.timedelta(seconds=value)

        elif isinstance(value, datetime.timedelta):

            self.after_timestamp = timezone.now() + value

        self.save()

class ResourceLog(models.Model):

    timestamp = models.DateTimeField(auto_now_add=True)

    appname = models.CharField(max_length=128, verbose_name='appname', null=True)

        abstract = True

class BaseQuery(models.Model):

    """Base for building custom queries.

import random

from urllib import parse as urlparse

from django.utils.encoding import smart_bytes

from django.utils.http import quote, urlencode

def sign_string(s, key, algo='sha256'):

    digestmod = getattr(hashlib, algo)

        key = key.encode('utf-8')

    hash = hmac.HMAC(smart_bytes(key), digestmod=digestmod, msg=smart_bytes(s))

    return hash.digest()

    if len(signature2) != len(signature):

        return False

    res = 0

    return res == 0

from django.utils.translation import ugettext_lazy as _

from django.views.generic import CreateView, DeleteView, DetailView, FormView, ListView, UpdateView, View

from ..utils import ImportSiteError, export_site, get_trusted_services, import_site

from ..views import GenericConnectorMixin

from .forms import AccessRightForm, ApiUserForm, AvailabilityParametersForm, ImportSiteForm

    def form_valid(self, form):

        try:

        except ValueError:

            form.add_error('site_json', _('File is not in the expected JSON format.'))

            return self.form_invalid(form)

import base64

import datetime

import pytz

from django.conf import settings

from django.core.cache import cache

from django.db import models

from django.utils.translation import ugettext_lazy as _

from zeep.exceptions import Fault as WebFault

from zeep.helpers import serialize_object

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.conversion import to_pdf

from passerelle.utils.jsonresponse import APIError

    return instance.soap_client()

class DPark(BaseResource):

    log_requests_errors = False

    @endpoint(perm='can_access', methods=['post'], description=_('Register a subscription application'))

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

        is_erroneous(

            data,

            (

    @endpoint(perm='can_access', methods=['post'], description=_('Link user to a subscription'))

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

        if 'nameid' not in data:

            raise WrongParameter(['nameid'], [])

        result = self.check_file_exists(data)

    @endpoint(perm='can_access', methods=['post'], description=_('Unlink user to subscription'))

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

        is_erroneous(data, ('nameid',))

        pairings = Pairing.objects.filter(**data)

        if pairings.exists() is False:

    @endpoint(name='notify-payment', perm='can_access', methods=['post'], description=_('Notify a payment'))

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

        is_erroneous(

            data,

            (

    )

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

        try:

        except ValueError as exc:

            raise APIError(str(exc), http_status=400)

        return {'data': True}

class Pairing(models.Model):

    INFO_CACHE_DURATION = 5 * 60

    PAYMENT_INFO_CACHE_DURATION = 20 * 60

from django.db import models

from django.utils.dateparse import parse_date, parse_datetime

from django.utils.timezone import get_fixed_timezone, is_naive, make_aware, utc

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

def normalize(value):

    '''convert /Date()/ to datetime, integers to strings'''

        datetime = parse_gdema_datetime(value)

        if datetime:

            return datetime

    )

    def create_request(self, request):

        try:

        except ValueError:

            raise APIError('payload must be a JSON object', http_status=400)

        if not isinstance(payload, dict):

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

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

import re

from django.db import models

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

COMMUNE_EXTRA_MAPPING = {'Vaulx-en-Velin': 'VAULX'}

        sections = self.requests.get(

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

        ).content

            if not value.get('codefuv') or not value.get('codetroncon'):

                continue

            section, dummy = StreetSection.objects.get_or_create(

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

import base64

import re

from email.mime.base import MIMEBase

from email.mime.multipart import MIMEMultipart

from suds.transport.http import HttpAuthenticated

from passerelle.base.models import BaseResource

from passerelle.soap import sudsobject_to_dict

from passerelle.utils.api import APIError, endpoint

    def create(self, request):

        # get creation fields from payload

        try:

        except ValueError as e:

            raise ParameterTypeError(str(e))

        # create suds object from formdata

    )

    def add_information(self, request, iddemande=None, idgreco=None, information=None):

        if request.body:

            if not isinstance(payload, dict):

                raise ParameterTypeError('payload must be a dict')

            idgreco = payload.get('idgreco') or idgreco

    )

    def update(self, request, iddemande=None, idgreco=None, comment=None):

        if request.body:

            if not isinstance(payload, dict):

                raise ParameterTypeError('payload must be a dict')

            idgreco = payload.get('idgreco') or idgreco

        display_order=7,

    )

    def add_confirmation(self, request):

        if not isinstance(payload, dict):

            raise ParameterTypeError('payload must be a dict')

        idgreco = payload.get('idgreco')

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

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

import re

from urllib import parse as urlparse

from lxml import etree

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

from passerelle.views import WrongParameter

    @endpoint(name='create-demand', perm='can_access', methods=['post'], description=_('Create a demand'))

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

        try:

        except (KeyError, ValueError) as e:

            raise APIError(e)

        response = self.request('ws_creation_demande.php', payload)

        pattern=r'(?P<demand_id>[\w-]+)/add-attachment/$',

    )

    def add_attachment_to_demand(self, request, demand_id, **kwargs):

        if 'file' not in data:

            raise WrongParameter(['file'], [])

        file_data = data['file']

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

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

import re

from urllib.parse import urljoin

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.utils.api import endpoint

from passerelle.utils.http_authenticators import HttpBearerAuth

from passerelle.utils.jsonresponse import APIError

    @endpoint(perm='can_access', description=_('Card Request'), methods=['post'])

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

        self.preprocess_card_request_data(data)

        self.preprocess_contact_data(data)

        self.preprocess_service_data(data)

    @endpoint(perm='can_access', description=_('Add new subscriptions'), methods=['post'])

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

        self.preprocess_card_request_data(data)

        self.preprocess_contact_data(data)

        self.preprocess_service_data(data)

    @endpoint(perm='can_access', description=_('Code Change'), methods=['post'])

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

        response = self.requests.post(

            urljoin(self.base_url, '/clu/ws/modifierCodeSecret'),

            json=data,

    @endpoint(perm='can_access', description=_('Code check'), methods=['post'])

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

        if 'password' in data:

            data['code_secret'] = data.pop('password')

        response = self.requests.get(

    @endpoint(perm='can_access', description=_('Card Revocation'), methods=['post'])

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

        self.preprocess_contact_data(data)

        response = self.requests.post(

            urljoin(self.base_url, '/clu/ws/revoquerCarte'), json=data, auth=HttpBearerAuth(self.get_token())

    @endpoint(perm='can_access', description=_('Subscription Revocation'), methods=['post'])

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

        self.preprocess_contact_data(data)

        self.preprocess_service_data(data)

        response = self.requests.post(

    @endpoint(perm='can_access', description=_('Subscription Renewal'), methods=['post'])

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

        self.preprocess_contact_data(data)

        response = self.requests.post(

            urljoin(self.base_url, '/clu/ws/renouvelerAbonnements'),

import requests

from django.db import models, transaction

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource, HTTPResource

                'traitée et expédiée': 'historique',

                'traitée non expédiée': 'historique',

            }

                raise APIError('typologie-must-be-a-string', data=content)

            if not all(demande['typologie'].lower() in typologies for demande in demandes):

                unknowns = set([demande['typologie'].lower() for demande in demandes]) - set(

        def check(value, path):

            if path[-1].startswith('date_'):

                    errors.append('%s is not a date string' % '.'.join(path))

        json_walker(data, check)

                    raise

                file_data.update(to_json().err_to_response(e))

            # do it later as get_filter() can modify str(link)

            data.append(file_data)

        if link_id:

            return {'data': data[0] if data else None}

        return {'data': data}

class Link(models.Model):

    resource = models.ForeignKey(MDPH13Resource, on_delete=models.CASCADE)

    name_id = models.CharField(verbose_name=_('NameID'), max_length=256)

import csv

from django.db import models

from django.utils.encoding import force_text

from django.utils.translation import ugettext_lazy as _

        content = self.csv_file.read()

        if not content:

            raise APIError('No content found')

        reader = csv.reader(content.splitlines())

        next(reader)

import calendar

from datetime import datetime

ENCODE_TOKENS = {

    'integer': 16,

    'real': 19,

        if ref is not None:

            self._push_token_type('ref')

            self._push(ref)

            self._encode_string(obj)

        elif obj is None:

            self._encode_nil()

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.contrib.solis_apa import conciliation, integration, suivi

from passerelle.utils.jsonresponse import APIError

        uri = 'importFlow?flow=ImportIntegrationDemande&application=%s' % APPLICATION

        url = self.get_resource_url(uri)

        data = json.dumps(data)

        self.logger.debug('Demande APA: %s' % data, extra={'solis_apa_demande': data})

        response = self.requests.post(url, data=data, headers=HEADERS)

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

import datetime

from urllib import parse as urlparse

from django.db import models

from requests import RequestException

from passerelle.base.models import BaseResource

from passerelle.utils.api import APIError, endpoint

            if name_id is None:

                raise APIError('missing name_id')

            # expected content: {"interests": ["123", "456"]}

            if 'error ' in response:

                return {'err': 1, 'err_desc': response.get('error')}

            interests = response.get('interests')

        else:

            # expected content: {"title": ..., "description": ..., "url": ...,

            # ...}, cf https://strasbourgeurometropole.github.io/slate/#ajout-d-39-une-notification

            notification['userId'] = name_id

            url = urlparse.urljoin(self.liferay_api_url, 'jsonws/notification.notification/add-notification')

            try:

        else:

            # expected content: {"title": ..., "url": ...,  ...},

            # cf https://strasbourgeurometropole.github.io/slate/?shell#ajout-d-39-un-favori

            # change type to typeId

            types_url = urlparse.urljoin(self.liferay_api_url, 'jsonws/favorite.favorite/get-types')

            try:

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

import base64

import logging

import xml.etree.ElementTree as ET

from datetime import datetime

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.soap import client_to_jsondict

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

        pattern=r'^(?P<regie_id>\w+)/invoice/(?P<invoice_id>[\w,-]+)/pay/$',

    )

    def pay_invoice(self, request, regie_id, invoice_id, **kwargs):

        transaction_id = data.get('transaction_id')

        transaction_date = data.get('transaction_date')

        email = data.get('email')

# borrowed from https://pypi.python.org/pypi/suds_requests

# and https://docs.oracle.com/cd/E50245_01/E50253/html/vmprg-soap-example-authentication-python.html

from suds.client import Client

from suds.transport import Reply

from suds.transport.http import HttpAuthenticated

import base64

import datetime

import logging

import os

from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource

from passerelle.contrib.utils import axel

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

        },

    )

    def pay_invoice(self, request, regie_id, invoice_id, **kwargs):

        dui, invoice_id = invoice_id.rsplit('-', 1)

        invoice = self.get_invoice(regie_id=regie_id, dui=dui, invoice_id=invoice_id)

import datetime

from collections import OrderedDict

from passerelle.utils.conversion import normalize

situation_familiale_mapping = OrderedDict(

    if isinstance(data, list):

        for i, val in enumerate(data):

            data[i] = upperize(val)

        data = normalize(data).upper()

    return data

from django.core.validators import RegexValidator

from django.db import models

from django.urls import reverse

from django.utils.module_loading import import_string

from django.utils.translation import ugettext_lazy as _

        abstract = True