Produits Entr'ouvert » Passerelle

        with zipfile.ZipFile(zip_filename, mode='w') as zip_file:

            liste_pdf = self.liste_pdf(None, dossier.type_dossier_id)

            cerfa_id = liste_pdf['data'][0]['id']

            for cerfa in liste_pdf['data']:

                if cerfa['id'] == 'AUTRES_DEMANDEURS':

                cerfa_id = cerfa['id']

                break

            cerfa_id = cerfa_id.replace('*', '-')

            pieces = self.pieces(

                None, dossier.type_dossier_id, dossier.objet_demande_id, dossier.tracking_code

            )

            for piece in pieces['data']:

                cnt = 1

                for file in piece['files']:

                    if not file.get('id'):

                        continue

                    cartads_file = CartaDSFile.objects.get(id=file['id'])

                    if piece['id'] == 'cerfa-%s-%s' % (dossier.type_dossier_id, dossier.objet_demande_id):

                        zip_file.write(cartads_file.uploaded_file.path, '%s.pdf' % cerfa_id)

                    elif piece['id'].startswith('cerfa-autres-'):

                        zip_file.write(

                            cartads_file.uploaded_file.path,

                            'Fiches_complementaires/Cerfa_autres_demandeurs_%d.pdf' % cnt,

                        )

                    else:

                        zip_file.write(

                            cartads_file.uploaded_file.path,

                            'Pieces/%s-%s%s%s'

                            % (

                                piece['id'],

                                piece['codePiece'],

                                cnt,

                                os.path.splitext(cartads_file.uploaded_file.path)[-1],

                            ),

                        )

                    cnt += 1

        with open(zip_filename, 'rb') as fd:

            ftp.storbinary('STOR %s' % os.path.basename(zip_filename), fd)

            ftp.quit()

        with open(content_filename, 'rb') as fd:

            content = read_decrypt(fd, self.private_key)

        with open(metadata_filename, 'r') as fd:

            metadata = json.load(fd)

            fd = open(lock_filename, 'w')  # pylint: disable=consider-using-with

            with open(options['archive_file'], 'rb') as archive_fd:

                connector.archive.save(archive_name, File(archive_fd))

                with zipfile.ZipFile(self.archive) as archive:

                    if self.file_format != 'native':

                        modname = 'passerelle.apps.family.loaders.%s' % self.file_format

                        __import__(modname)

                        module = sys.modules[modname]

                        module.Loader(self).clean(archive)

        with zipfile.ZipFile(self.archive.path) as archive:

            if self.file_format != 'native':

                modname = 'passerelle.apps.family.loaders.%s' % self.file_format

                __import__(modname)

                module = sys.modules[modname]

                module.Loader(self).load(archive)

                return

            archive_files = archive.namelist()

            family_files = [d for d in archive_files if d.endswith('.json')]

            families = []

            invoices = []

            children = []

            adults = []

            for f in family_files:

                family_data = json_loads(archive.read(f))

                families.append(family_data['id'])

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

                family_data.update(address)

                    family_data,

                        'login',

                        'password',

                        'family_quotient',

                family, dummy = Family.objects.update_or_create(

                    external_id=family_data['id'], resource=self, defaults=data

                for adult in family_data.get('adults') or []:

                    adults.append(adult['id'])

                    adult_address = adult.get('address') or {}

                    adult.update(adult_address)

                    data = dict_cherry_pick(

                        adult,

                        (

                            'first_name',

                            'last_name',

                            'phone',

                            ('mobile', 'cellphone'),

                            'sex',

                            ('number', 'street_number'),

                            ('postal_code', 'zipcode'),

                            ('street', 'street_name'),

                            ('complement', 'address_complement'),

                            'country',

                        ),

                    )

                    Adult.objects.update_or_create(family=family, external_id=adult['id'], defaults=data)

                # cleanup adults

                Adult.objects.exclude(external_id__in=adults).delete()

                for child in family_data.get('children') or []:

                    children.append(child['id'])

                    data = dict_cherry_pick(child, ('first_name', 'last_name', 'sex', 'birthdate'))

                    Child.objects.get_or_create(family=family, external_id=child['id'], defaults=data)

                # cleanup children

                Child.objects.exclude(external_id__in=children).delete()

                for invoice in family_data['invoices']:

                    invoices.append(invoice['id'])

                    data = dict_cherry_pick(

                        invoice,

                        (

                            'label',

                            ('created', 'issue_date'),

                            'pay_limit_date',

                            'litigation_date',

                            'total_amount',

                            'payment_date',

                            'amount',

                            'autobilling',

                        ),

                    )

                    for date_attribute in data.keys():

                        if not date_attribute.endswith('_date'):

                            continue

                        if date_attribute == 'payment_date':

                            data[date_attribute] = get_datetime(data[date_attribute])

                        else:

                            data[date_attribute] = get_date(data[date_attribute])

                    data['paid'] = bool(data.get('payment_date'))

                    Invoice.objects.update_or_create(

                        resource=self, family=family, external_id=invoice['id'], defaults=data

                    )

                    if 'invoices/%s.pdf' % invoice['id'] in archive_files:

                        with open(os.path.join(invoices_dir, '%s.pdf' % invoice['id']), 'wb') as fp:

                            fp.write(archive.read('invoices/%s.pdf' % invoice['id']))

        with open(self.pdf_filename(), 'rb') as fd:

            response = HttpResponse(fd.read(), content_type='application/pdf')

                with zipfile.ZipFile(fd) as archive:

                    # sort files

                    doc_files = []

                    ent_files = []

                    attachments = {}

                    for name in archive.namelist():

                        if ENT_PATTERN.match(name):

                            ent_files.append(name)

                    if len(ent_files) != 1:

                        return False, 'too many/few ent files found: %s' % ent_files

                    ent_file = ent_files[0]

                    with archive.open(ent_file) as fd:

                        document = ET.parse(fd)

                    for pj_node in PIECE_JOINTE_XPATH(document):

                        code = CODE_XPATH(pj_node)[0].text

                        code = 'pj_' + code.lower().replace('-', '_')

                        fichier = FICHIER_XPATH(pj_node)[0].text

                        attachments.setdefault(code, []).append(fichier)

                    for doc_node in DOCUMENTS_XPATH(document):

                        code = CODE_XPATH(doc_node)[0].text

                        code = 'doc_' + code.lower().replace('-', '_')

                        fichier = FICHIER_DONNEES_XPATH(doc_node)[0].text

                        attachments.setdefault(code, []).append(fichier)

                    doc_files = [

                        value for l in attachments.values() for value in l if value.lower().endswith('.xml')

                    ]

                    if len(doc_files) != 1:

                        return False, 'too many/few doc files found: %s' % doc_files

                    for key in attachments:

                        if len(attachments[key]) > 1:

                            return False, 'too many attachments of kind %s: %r' % (key, attachments[key])

                        name = attachments[key][0]

                        with archive.open(attachments[key][0]) as zip_fd:

                            content = zip_fd.read()

                        attachments[key] = {

                            'filename': name,

                            'content': base64.b64encode(content).decode('ascii'),

                            'content_type': 'application/octet-stream',

                        }

                    if self.procedure == PROCEDURE_RCO and not attachments:

                        return False, 'no attachments but RCO requires them'

                    doc_file = doc_files[0]

                    insee_codes = ROUTAGE_XPATH(document)

                    if len(insee_codes) != 1:

                        return False, 'too many/few insee codes found: %s' % insee_codes

                    insee_code = insee_codes[0]

                    email = EMAIL_XPATH(document)

                    email = email[0] if email else ''

                    data = {

                        'insee_code': insee_code,

                        'email': email,

                    }

                    data.update(attachments)

                    with archive.open(doc_file) as fd:

                        document = ET.parse(fd)

                        data.update(self.extract_data(document))

                        if hasattr(self, 'update_data_%s' % self.procedure):

                            getattr(self, 'update_data_%s' % self.procedure)(data)

            except zipfile.BadZipfile:

            with open(options['output'], 'w') as output:

                json.dump(export_site(slugs=options['slugs']), output, indent=4)

                return

        output = sys.stdout

    def run(one, two):

        differences = []

        with zipfile.ZipFile(one) as one_zip, zipfile.ZipFile(two) as two_zip:

            one_nl = set(one_zip.namelist())

            two_nl = set(two_zip.namelist())

            for name in one_nl - two_nl:

                differences.append('File %s only in %s' % (name, one))

            for name in two_nl - one_nl:

                differences.append('File %s only in %s' % (name, two))

            for name in one_nl & two_nl:

                with one_zip.open(name) as fd_one:

                    with two_zip.open(name) as fd_two:

                        difference = compute_diff(name, name, fd_one, fd_two)

                        if difference:

                            differences.append(difference)

            if not differences:

                # check file order in zip

                one_zip_files = [zi.filename for zi in one_zip.infolist()]

                two_zip_files = [zi.filename for zi in two_zip.infolist()]

                if one_zip_files != two_zip_files:

                    differences.append('Files are not in the same order')

        return differences

        with open(one, mode='rb') as one:

            if not hasattr(two, 'read'):

                with open(two, 'rb') as two:

                    return run(one, two)

            with two:

                return run(one, two)

            with open(two, 'rb') as two:

                return run(one, two)

            return run(one, two)

    with open(os.path.join(os.path.dirname(__file__), 'data', 'genesys_select_codifications.xml')) as fd:

        response = fd.read()

with open(os.path.join(os.path.dirname(__file__), 'data', 'genesys_select_usager.xml')) as fd:

    RESPONSE_SELECT_USAGER = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'minimal.pdf'), 'rb') as fd:

        pdf_contents = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'pdf-form.pdf'), 'rb') as fd:

        pdf_contents = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'pdf-form.pdf'), 'rb') as fd:

        pdf_contents = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'pdf-form.pdf'), 'rb') as fd:

        pdf_contents = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'pdf-form.pdf'), 'rb') as fd:

        pdf_contents = fd.read()

    with open(os.path.join(get_test_base_dir('cityweb'), 'cityweb.xsd')) as fd:

        schema = etree.XMLSchema(etree.parse(fd))

    with open(filename) as fd:

        content = fd.read()

            with open('%s/tests/data/cmis/cmis1.out.xml' % os.getcwd(), 'rb') as fd:

                content = fd.read()

            with open('%s/tests/data/cmis/cmis2.out.xml' % os.getcwd(), 'rb') as fd:

                content = fd.read()

            with open('%s/tests/data/cmis/cmis3.in.xml' % os.getcwd(), 'r') as fd:

                expected_input = fd.read()

            with open('%s/tests/data/cmis/cmis3.out.xml' % os.getcwd(), 'rb') as fd:

                content = fd.read()

    with open(filepath) as fd:

        resource.archive = File(fd, 'family_data.zip')

        with pytest.raises(ValidationError):

            resource.clean()

    with open(filepath, 'rb') as fd:

        resource = GenericFamily(

            title='test orleans',

            slug='test-orleans',

            archive=File(fd, 'family_data_orleans.zip'),

            file_format='concerto_orleans',

        )

        from passerelle.apps.family.loaders.concerto_orleans import Loader

        loader = Loader(resource)

        with zipfile.ZipFile(filepath) as z:

            loader.archive = z

            families = loader.build_families()

        assert len(families) == 18

        for family in families.values():

            assert family['external_id']

            assert family['adults']

            assert family['login']

            assert family['password']

            assert family['zipcode']

            assert family['city']

            assert len(family['adults']) > 0

            for adult in family['adults']:

                assert adult['first_name']

                assert adult['last_name']

                assert adult['sex']

                assert adult['external_id']

                assert adult['zipcode']

                assert adult['city']

            assert len(family['children']) >= 1

            for child in family['children']:

                assert child['external_id']

                assert child['first_name']

                assert child['last_name']

                assert child['sex']

                assert 'birthdate' in child

            assert 'invoices' in family

            if family['invoices']:

                for invoice in family['invoices']:

                    assert invoice['external_id']

                    assert invoice['label']

                    assert invoice['issue_date']

                    assert invoice['online_payment']

                    assert 'autobilling' in invoice

                    assert 'amount' in invoice

                    assert 'total_amount' in invoice

        # there are 4 families with invoices in test data

        assert len([f for f in families.values() if f['invoices']]) == 4

        # and 14 families with no invoices

        assert len([f for f in families.values() if not f['invoices']]) == 14

        resource.save()

    with open(filepath, 'rb') as fd:

        GenericFamily.objects.create(

            title='test orleans',

            slug='test-orleans',

            archive=File(fd, 'family_incorrect_data_orleans.zip'),

            file_format='concerto_orleans',

        )

    with open(filename) as fd:

        payload = json.load(fd)

    with open(os.path.join(os.path.dirname(__file__), 'data', 'nancy_arcgis', 'sigresponse.json')) as fd:

        payload = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'nancy_arcgis', 'sigresponse.json')) as fd:

        payload = fd.read()

    with open(filename) as fd:

        payload = json.load(fd)

        with open(types_filename) as fd:

            types = fd.read()

        with open(types_filename) as fd:

            response.content = fd.read()

    with open(types_filename) as fd:

        types = fd.read()

        with open(os.path.join(os.path.dirname(__file__), 'data', 'grenoble_gru_pavs.json')) as fd:

            json_response.return_value = json.load(fd)

        with open(f.name) as fd:

            import_site(json.load(fd), overwrite=True)

    with open(target_file, 'rb') as fd:

        response._content = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data/iparapheur_get_file_response.xml'), 'rb') as fd:

        soap_response = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data/iparapheur_get_file_response.xml'), 'rb') as fd:

        soap_response = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data/iparapheur_get_file_response.xml'), 'rb') as fd:

        soap_response = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data/iparapheur_get_file_response.xml'), 'rb') as fd:

        soap_response = fd.read()

    with open(wsdl_file(), 'rb') as fd:

        assert resp.content == fd.read()

    with open(xmlmime(), 'rb') as fd:

        response_xmlmime._content = fd.read()

    with open(wsdl_file(), 'rb') as fd:

        mocked_load.return_value = fd.read()

    with zipfile.ZipFile(zipdir, 'r') as zipres:

        files = [f.filename for f in zipres.infolist()]

    with open(os.path.join(os.path.dirname(__file__), 'data', 'minimal.pdf'), 'rb') as fd:

        pdf = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'minimal_bom.pdf'), 'rb') as fd:

        pdf = fd.read()

    with open(os.path.join(os.path.dirname(__file__), 'data', 'minimal_bomutf8.pdf'), 'rb') as fd:

        pdf = fd.read()

            with zi.open('coucou-10-part1.xml') as zfd:

                assert zfd.read().decode('utf-8') == '<?xml version="1.0"?><body>blabla</body>'

            with zi.open('coucou-10-dôc.xml') as zfd:

                assert zfd.read().decode('utf-8') == '<a>Héllo World!</a>'

            with zi.open('coucou-10-part1.xml') as zfd:

                assert zfd.read().decode('utf-8') == '<?xml version="1.0"?><body>blabla</body>'

            with zi.open('coucou-10-dôc.xml') as zfd:

                assert zfd.read().decode('utf-8') == '<a>Héllo World!</a>'