Produits Entr'ouvert » Passerelle

import lxml.etree

from django.db import models

from django.utils import dateformat, dateparse

from django.utils.translation import gettext_lazy as _

from zeep import helpers

from zeep.exceptions import Fault

        try:

            return getattr(client.service, method)(**kwargs)

        except Fault as e:

    def _basic_ref(self, wsdl, method):

        soap_res = self._soap_call(wsdl=wsdl, method=method)

from django.db import models

from django.http import HttpResponse

from django.urls import reverse

from django.utils.timezone import now

from django.utils.translation import gettext_lazy as _

        data_pad = AES.block_size - len(token_data_str) % AES.block_size

        aes = AES.new(self.secret_key.encode(), AES.MODE_CBC, self.iv.encode())

        token = aes.encrypt((token_data_str + (chr(data_pad) * data_pad)).encode())

    def check_status(self):

        self.soap_client().service.GetCommunes(self.get_token(), {})

            try:

                pdf = pdfrw.PdfReader(request.FILES['files[]'])

                if not any(pdfrw.findobjs.find_objects(pdf, valid_subtypes=(pdfrw.PdfName.Form,))):

            except (pdfrw.PdfParseError, ValueError):

        else:

            if request.FILES['files[]'].content_type not in ('application/pdf', 'image/jpeg'):

        if request.FILES['files[]'].size > 25 * 1024 * 1024:

        file_upload = CartaDSFile(

            tracking_code=tracking_code, id_piece=id_piece, uploaded_file=request.FILES['files[]']

        )

from django.core.files.base import ContentFile

from django.db import models, transaction

from django.urls import reverse

from django.utils.timezone import make_aware, now

from django.utils.translation import gettext_lazy as _

        if self.skip_header:

            rows = rows[1:]

        titles = [t.strip() for t in self.columns_keynames.split(',')]

        indexes = [titles.index(t) for t in titles if t]

        captions = [titles[i] for i in indexes]

    @property

    def titles(self):

    @endpoint(perm='can_access', methods=['get'], name='data')

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

                except (TypeError, SyntaxError) as e:

                    data = {

                        'expr': expr,

                    }

                    if titles:

                        data['name'] = titles[i]

                        data = {

                            'expr': expr,

                            'row': repr(row),

                        }

                        if titles:

                            data['name'] = titles[i]

        if 'id' in request.GET and not model_filters_id:

            # always provide a ?id= filter.

            data = [row for new_row, row in stream_expressions(filters, data, kind='filters') if new_row[0]]

        # allow jsonp queries by select2

from decimal import Decimal

from django.core.exceptions import ValidationError

from django.utils.translation import gettext_lazy as _

from ..models import Invoice

def u(s):

class Loader:

from django.core.exceptions import ValidationError

from django.core.files.storage import DefaultStorage

from django.utils import timezone

from django.utils.translation import gettext_lazy as _

from ..models import Adult, Child, Family, Invoice, dict_cherry_pick, get_date, get_datetime

        # pylint: disable=stop-iteration-return

        titles = [x.lower() for x in next(reader)]

        for row in reader:

            yield dict(zip(titles, row))

    def build_families(self):

from decimal import Decimal

from django.core.exceptions import ValidationError

from django.utils.translation import gettext_lazy as _

from ..models import Invoice

def u(s):

class Loader:

    phpserialize = None

from django.db import models

from django.utils.translation import gettext_lazy as _

from passerelle.base.models import BaseResource

    if isinstance(obj, dict):

        new_d = {}

        for k, v in obj.items():

        return new_d

    return obj

    def call_soap(self, action, *args, **kwargs):

        def escape(s):

        params = []

        for i, arg in enumerate(args):

        soap_result = phpserialize_loads(resp.findall('.//listeCommune')[0].text)

        result = []

        for k, v in soap_result.items():

        result.sort(key=lambda x: x['id'])

        return result

        soap_result = phpserialize_loads(resp.findall('.//listeObjet')[0].text)

        result = []

        for k, v in soap_result.items():

        result.sort(key=lambda x: x['id'])

        return result

import json

from django.views.generic.base import View

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

        except IOError:

            result = {'result': 'gdc soap crash'}

        else:

            result = phpserialize_loads(resp.findall('.//listeInfo')[0].text)

            result = {

                'result': code_retour,

from django.db import models

from django.template.loader import render_to_string

from django.utils import timezone

from django.utils.translation import gettext_lazy as _

from passerelle.base.models import SkipJob

        if not self.password:

            raise APIError('Improperly configured, empty keys or password fields.')

        to = ','.join(destinations)

        params = {

            'account': self.account.encode('utf-8'),

import requests

from django.db import models

from django.utils.translation import gettext_lazy as _

from passerelle.sms.models import SMSResource

                results.append('OXYD error: POST failed, %s' % e)

            else:

                code = r.content and r.content.split()[0]

                    results.append('OXYD error: response is not 200')

                else:

                    results.append(0)

from django.db import models, transaction

from django.db.models import Q

from django.http import HttpResponse

from django.utils.timezone import now

from django.utils.translation import gettext_lazy as _

        for row in reader:

            if not row:

                continue  # do not consider empty lines

            row = {caption: get_cell(row, index) for caption, index in zip(captions, indexes)}

            if row['sector_id']:

from django.db import models

from django.template.loader import get_template

from django.utils.http import urlencode

from django.utils.translation import gettext_lazy as _

        try:

            value = self.request(endpoint)

        except APIError as e:  # do not raise on linked informations

        link['content'] = value

    def rsa_get_links(self, information, links):

from django.test import override_settings

from django.urls import reverse

from django.utils import timezone

from django.utils.log import AdminEmailHandler

from django.utils.text import slugify

from django.utils.timezone import now

                if value:

                    d[field.name] = {

                        'name': os.path.basename(value.name),

                    }

                else:

                    d[field.name] = None

import csv

from django.db import models

from django.utils.translation import gettext_lazy as _

from passerelle.base.models import BaseResource

def to_unicode(value):

def upload_to(instance, filename):

        content = self.csv_file.read()

        if not content:

            raise APIError('No content found')

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

        next(reader)

from urllib import parse as urlparse

from django.db import models

from django.utils.translation import gettext_lazy as _

from requests import RequestException

                notification['parsedPublicationDate'] = None

                for date_format in ('%Y-%m-%d %H:%M:%S', '%a %b %d %H:%M:%S %Z %Y'):

                    try:

                            datetime.datetime.strptime(notification['publicationDate'], date_format)

                        )

                        break

from django.contrib.postgres.fields import JSONField

from django.db import models

from django.http import HttpResponse, HttpResponseNotFound

from django.utils.translation import gettext_lazy as _

from passerelle.base.models import BaseResource

        portail = ET.Element('PORTAIL')

        portail.append(args)

        streamId = operation

        user = ''

        logger.debug('getData(streamId=%s, xmlParams=%s, user=%s)', streamId, xmlParams, user)

        xml_result = ET.fromstring(result)

        if xml_result.find('RESULTAT/STATUS').text != 'OK':

            msg = xml_result.find('RESULTAT/COMMENTAIRES').text

import pytz

import xmlschema

from passerelle.utils.xml import JSONSchemaFromXMLSchema

            except xmlschema.XMLSchemaValidationError as e:

                raise AxelError('invalid request %s' % str(e))

            indent(serialized_request)

            try:

                self.request_converter.xml_schema.validate(serialized_request)

            except xmlschema.XMLSchemaValidationError as e:

        xml_result = ET.fromstring(result.encode('utf-8'))

        indent(xml_result)

        if xml_result.find('RESULTAT/STATUS').text != 'OK':

            msg = xml_result.find('RESULTAT/COMMENTAIRES').text

            raise AxelError(msg, xml_request=serialized_request, xml_response=pretty_result)

import suds.sudsobject

def client_to_jsondict(client):

        d['types'] = {}

        for t in sd.types:

            ft = client.factory.create(sd.xlate(t[0]))

        res[sd.service.name] = d

    return res

from django.core.exceptions import PermissionDenied

from django.db import transaction

from django.http import HttpResponse, HttpResponseBadRequest

from django.utils.functional import lazy

from django.utils.html import mark_safe

from django.utils.translation import ngettext_lazy

        if scheme == 'basic' and len(http_authorization) > 1:

            param = http_authorization[1]

            try:

                username, password = decoded.split(':', 1)

            except (TypeError, ValueError):

                pass

def make_headers_safe(headers):

    """Convert dict of HTTP headers to text safely, as some services returns 8-bits encoding in headers."""

    return {

    }

from io import BytesIO

import unidecode

from PIL import Image

def to_ascii(s):

def exception_to_text(e):

    """

    if not s:

        return ''

    s = normalize(s)

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

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

from urllib import parse as urlparse

from uuid import uuid4

from requests.auth import AuthBase

        p_hash.update(force_bytes(req.headers.get('Content-Type', '') + '\n'))

        p_hash.update(force_bytes(req.body or ''))

        p_hash.update(force_bytes('\n'))

    def get_authorization_header(self, req):

        url_parts = urlparse.urlparse(req.url)

        ]

        digestmod = getattr(hashlib, self.algorithm)

        result = hmac.new(force_bytes(self.key), force_bytes('\n'.join(data)), digestmod)

        authorization = 'Hawk id="%s", ts="%s", nonce="%s", hash="%s", mac="%s"' % (

            self.timestamp,

            self.nonce,

            hash,

from django.core.serializers.json import DjangoJSONEncoder

from django.http import Http404, HttpResponse, HttpResponseBadRequest

from django.http.response import HttpResponseBase

from django.utils.log import log_response

from requests import HTTPError, RequestException

        err_class = err_module + err.__class__.__name__

        response = {

            "err": 1,

from django import forms

from django.core import validators

from django.db import models

from django.utils.translation import gettext_lazy as _

from paramiko.dsskey import DSSKey

from paramiko.ecdsakey import ECDSAKey

        self.hostname = parsed.hostname

        self.port = parsed.port or 22

        self.path = parsed.path.strip('/')

        self.private_key_password = private_key_password

        if private_key_content:

            self.private_key = _load_private_key(private_key_content, private_key_password)

from django.http import Http404, HttpResponse, HttpResponseRedirect

from django.shortcuts import get_object_or_404, resolve_url

from django.urls import reverse

from django.utils.timezone import is_naive, make_aware

from django.utils.translation import gettext_lazy as _

from django.views.decorators.csrf import csrf_exempt

    json_str = json.dumps(

        [

            {

                'slug': 'passerelle',

                'url': request.build_absolute_uri(reverse('manage-home')),

            }

import mock

import pytest

from django.utils.http import urlencode

from requests import Request

from requests.exceptions import ConnectionError

    assert data['StatutTiers'] == 'PROPOSE'

    assert data['Type'] == '*'

    assert data['AdresseTitre'] == 'AdressePrincipale'

    assert data['Sigle'] == 'EO'

    assert data['AdresseIsAdresseDeCommande'] == 'false'

    assert data['AdresseIsAdresseDeFacturation'] == 'false'

)

from django.contrib.contenttypes.models import ContentType

from django.urls import reverse

from mock import Mock, call

from passerelle.apps.cmis.models import CmisConnector

def b64encode(content):

@pytest.fixture()

import pytest

from django.contrib.contenttypes.models import ContentType

from django.core.exceptions import ValidationError

import tests.utils

from passerelle.apps.cryptor.models import CryptedFile, Cryptor

    # encrypt

    endpoint = tests.utils.generic_endpoint_url('cryptor', 'file-encrypt', slug=cryptor.slug)

    payload = {"file": {"filename": "foo.txt", "content_type": "text/plain", "content": content}}

    resp = app.post_json(endpoint, params=payload, status=200)

from django.core.management import call_command

from django.test import Client, override_settings

from django.urls import reverse

from django.utils.timezone import now

from passerelle.apps.csvdatasource.models import CsvDataSource, Query, TableRow, upload_to

216352;38;Dupont;Benoît;H

"""

pytestmark = pytest.mark.django_db

import httmock

import mock

import pytest

from zeep.exceptions import Fault as WebFault

from zeep.exceptions import TransportError

</SOAP-ENV:Envelope>"""

    )

    resp = app.post_json(url, params=params)

    assert resp.json['data']['numerodossier'] == 22334

    assert resp.json['data']['numerodemande'] == 59492

    params['justif_domicile'] = {

        'filename': 'address_proof.pDf',

        'content_type': 'application/pdf',

    }

    params['cartegrise,1'] = {

        'filename': 'cartegrise.pdf',

        'content_type': 'application/pdf',

    }

    params['toto,6'] = {

        'filename': 'cartegrisetoto.jpg',

        'content_type': 'application/pdf',

    }

    params['cartegrise,6'] = {

        'filename': 'cartegrise2.pdf',

        'content_type': 'application/pdf',

    }

    params['taxe_habitat'] = {

        'filename': 'cartegrise2.pdf',

    assert len(pj_node.findall('Bloc_Fichiers')) == 4

    assert pj_node.findall('Bloc_Fichiers')[0].find('TypeDocument').text == '6'

    assert pj_node.findall('Bloc_Fichiers')[0].find('NomFichier').text == 'cartegrise.pdf'

        base64.b64encode(b'%PDF carte grise 1')

    )

    assert pj_node.findall('Bloc_Fichiers')[1].find('TypeDocument').text == '6'

    assert pj_node.findall('Bloc_Fichiers')[1].find('NomFichier').text == 'cartegrise2.pdf'

        base64.b64encode(b'%PDF carte grise 2')

    )

    assert pj_node.findall('Bloc_Fichiers')[2].find('TypeDocument').text == '2'

    assert pj_node.findall('Bloc_Fichiers')[2].find('NomFichier').text == 'address_proof.pDf'

        base64.b64encode(b'%PDF this is my proof of address')

    )

    from passerelle.utils.conversion import to_pdf

    assert pj_node.findall('Bloc_Fichiers')[3].find('NomFichier').text == 'cartegrisetoto.jpg.pdf'

        base64.b64encode(to_pdf(JPEG_CONTENT))

    )

    assert base64.b64decode(pj_node.findall('Bloc_Fichiers')[3].find('Fichier').text).startswith(b'%PDF')

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

import pytest

from django.utils.timezone import now

from passerelle.apps.gesbac.models import Gesbac

    assert resource.form_set.filter(form_id='42-43', filename=response_filename, status='closed').count() == 0

    # files are encoded in latin-1

    with sftpserver.serve_content({'input': {response_filename: content}}):

        resource.hourly()

from django.test import Client

from django.urls import reverse

from django.utils import timezone

from passerelle.apps.base_adresse.models import BaseAdresse

from passerelle.apps.bdp.models import Bdp

216352;38;Dupont;Benoît;H

"""

SECTOR_CSV = """street_id,street_name,parity,min_housenumber,max_housenumber,sector_id,sector_name

75114_1912,rue du Château,P,,, gs-moulin, Groupe Scolaire Moulin"""

import httmock

import pytest

from django.contrib.contenttypes.models import ContentType

from passerelle.apps.orange.models import OrangeError, OrangeSMSGateway

from passerelle.base.models import AccessRight, ApiUser, Job

@httmock.urlmatch(netloc=NETLOC, path='/api/v1.2/groups/gid2/diffusion-requests', method='POST')

def response_diffusion_ok(url, request):

    assert request.headers['authorization'] == 'Bearer my_token'

    assert request_body['smsParam']['body'] == PAYLOAD['message']

    assert 'senderName' not in request_body['smsParam'].keys()

    assert '33688888888' in request_body['msisdns'][0]

    # sender name not allowed

    @httmock.urlmatch(netloc=NETLOC)

    def mocked_response2(url, request):

        assert request_body['smsParam']['senderName'] == 'john'

        error_response = [

            {

from django.core.files import File

from django.core.management import call_command

from django.urls import reverse

from django.utils.timezone import now

import tests.utils

75114_1915,  ,,,,ecole-hugo2 , École Hugo 2

"""

CSV_NO_FIRST_LINE = """75114_1912,rue du Château,P,,, gs-moulin, Groupe Scolaire Moulin

75114_1912,rue du Château,I,0,999999,gs-zola,Groupe Scolaire Zola

import mock

import pytest

import tests.utils

from passerelle.contrib.solis_afi_mss.models import SolisAfiMss

        'document': {

            'filename': '201x201.jpg',

            'content_type': 'image/jpeg',

        },

    }

        'document': {

            'filename': '201x201.jpg',

            'content_type': 'image/jpeg',

        },

    }

    resp = app.post_json(endpoint + '?email=foo@dummy.org', params=payload)

import pytest

from django.db import connection

from django.db.migrations.executor import MigrationExecutor

from requests.exceptions import ReadTimeout

import tests.utils

    'files/0': {

        'filename': '201x201.jpg',

        'content_type': 'image/jpeg',

    },

    'files/1': None,

}

import pytest

from django.core.files.uploadedfile import SimpleUploadedFile

from django.db import models

from passerelle.utils.sftp import SFTP, SFTPField, SFTPFormField

        with form.cleaned_data['sftp'].client() as sftp:

            assert sftp.listdir() == ['a.zip']

        assert form.is_valid()

        sftp = form.cleaned_data['sftp']

        assert isinstance(sftp, SFTP)

        with form.cleaned_data['sftp'].client() as sftp:

            assert sftp.listdir() == ['a.zip']

        assert not form.is_valid()

        assert 'key invalid' in str(form.errors)

        form = Form(

            data={

                'sftp_0': url,

                'sftp_3': 'coucou',

            }

        )