Produits Entr'ouvert » Passerelle

                    result['address']['road'] = value

        return result

    def streets(self, request, zipcode=None, q=None, page_limit=None):

        result = []

        streets = StreetModel.objects.all()

                           'citycode': street.citycode,

                           'zipcode': street.zipcode})

    def daily(self):

        super(BaseAdresse, self).daily()

        req = self.get_request(uri)

        return json.load(urllib2.urlopen(req))

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

        records = self.get_json('interventionsets').get('records')

        records.sort(lambda x,y: cmp(x['sort'], y['sort']))

        for record in records:

            if record.get('publicname'):

                ret.append({'id': record['id'], 'text': record['publicname'], 'details': record})

    def get_interventions(self, request, set, **kwargs):

        ret = []

        records = self.get_json('interventions?interventionset_id=%s' % set).get('records')

        for record in records:

            if record.get('publicname'):

                ret.append({'id': record['id'], 'text': record['publicname'], 'details': record})

    def get_available_timeslots(self, intervention, date_start=None, date_end=None):

        timeslots = []

        fields = super(CmisConnector, self).get_description_fields()

        return [(x[0], x[1]) for x in fields if x[0].name != 'password']

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

        try:

            data = json.loads(request.body)

        except UpdateConflictException:

            raise CMISError('the document already exists on platform.')

    def cmis_connection_repository(self, repo_name):

        try:

    def titles(self):

        return [smart_text(t.strip()) for t in self.columns_keynames.split(',')]

              name='query', pattern='^(?P<query_name>[\w-]+)/$')

    def select(self, request, query_name, **kwargs):

        try:

                    if new_row[0]]

        if query.structure == 'array':

        elif query.structure == 'dict':

        elif query.structure == 'tuples':

        elif query.structure == 'onerow':

            if len(data) != 1:

                raise APIError('more or less than one row', data=data)

        elif query.structure == 'one':

            if len(data) != 1:

                raise APIError('more or less than one row', data=data)

            if len(data[0]) != 1:

                raise APIError('more or less than one column', data=data)

    def export_json(self):

        d = super(CsvDataSource, self).export_json()

        except FamilyLink.DoesNotExist:

            return None

    def family_link(self, request, NameID=None, login=None, password=None, **kwargs):

        """

        Links a NameID to a person

        try:

            f = Family.objects.get(login=login, password=password, resource=self)

        except Family.DoesNotExist:

        FamilyLink.objects.get_or_create(resource=self, name_id=NameID, family=f)

    def family_unlink(self, request, NameID=None, **kwargs):

        """

        Unlinks a NameID from a person

        print "Unlink"

        try:

            FamilyLink.objects.get(resource=self, name_id=NameID).delete()

        except FamilyLink.DoesNotExist:

    def family_infos(self, request, NameID, **kwargs):

        """

        Displays the information of person's family

        """

        family = self.get_family_by_nameid(NameID)

        if not family:

        data = {'id': family.get_display_id(), 'adults': [], 'children': []}

        for adult in family.adult_set.all():

            data['adults'].append(format_person(adult))

        for child in family.child_set.all():

            data['children'].append(format_person(child))

    def adults_infos(self, request, NameID):

        data = self.family_infos(request, NameID)

    def children_infos(self, request, NameID, **kwargs):

        data = self.family_infos(request, NameID)

    def get_invoices(self, NameID, paid=False):

        family = self.get_family_by_nameid(NameID)

            invoices.append(format_invoice(i))

        return invoices

    def active_invoices(self, request, NameID):

    def invoices_history(self, request, NameID, **kwargs):

    def get_invoice(self, invoice_id):

        try:

        except Invoice.DoesNotExist:

            return None

              pattern='^invoice/(?P<invoice_id>\w+)/$')

    def get_invoice_details(self, request, invoice_id, NameID=None, email=None, **kwargs):

        invoice = self.get_invoice(invoice_id)

        if not invoice:

              pattern='^invoice/(?P<invoice_id>\w+)/pdf/$')

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

        invoice = self.get_invoice(invoice_id)

            raise FileNotFoundError

        return invoice.get_pdf()

              perm='can_access', pattern='^invoice/(?P<invoice_id>\w+)/pay/$')

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

        data = json.loads(request.body)

        invoice = self.get_invoice(invoice_id)

        if not invoice:

        transaction_date = get_datetime(data['transaction_date'])

        invoice.paid = True

        invoice.payment_date = transaction_date

        invoice.amount = 0

        invoice.payment_transaction_id = data['transaction_id']

        invoice.save()

class FamilyLink(models.Model):

        else:

            return result

    def cities(self, request):

        okina_cities = self.request('cities')

        cities = []

            city['text'] = '%(nameCity)s (%(zipCode)s)' % city

            cities.append(city)

        cities.sort(lambda x,y: cmp(x['text'], y['text']))

    def classes(self, request):

            'id': '%s' % item['id'],

            'text': item['label']

    def get_institutions(self, endpoint=''):

        okina_institutions = self.request('institutions' + endpoint)

        institutions.sort(lambda x,y: cmp(x['text'], y['text']))

        return institutions

    def institutions(self, request):

    def institutions_from_city(self, request, city_insee_code):

    @endpoint(name='stop-areas',

    def stop_areas(self, request, city_insee_code, institution_id):

        stops = self.request('stop-areas/subscriberCity/%s/institution/%s' % (city_insee_code,

                                                                              institution_id))

        for stop in stops:

            stop['id'] = '%s' % stop['id']

            stop['text'] = stop['commercial_name']

    def get_ods(self, endpoint=''):

        # ods = origin/destinations

                    'object_id': journey['okinaVehicleJourney']['objectId'],

                    'identifier': identifier

                })

    def origin_destinations(self, request):

        return self.get_ods()

    @endpoint(name='origin-destinations',

    def origin_destinations_to_institution(self, request, institution_id):

        return self.get_ods('/institution/%s' % institution_id)

    @endpoint(name='origin-destinations',

    def origin_destinations_from_stop_to_institution(self, request, stop_area_id, institution_id):

        endpoint = 'ods/institution/%s/stop-area/%s' % (institution_id, stop_area_id)

        okina_journeys = self.request(endpoint)

                    } for line in okina_journey],

            }

            journeys.append(journey)

    @endpoint(name='origin-destinations',

    def origin_destinations_from_city_to_institution(self, request, city_insee_code, institution_id):

        return self.get_ods('/institution/%s/subscriberCity/%s' % (institution_id, city_insee_code))

    @endpoint(name='origin-destinations',

    def origin_destinations_from_city(self, request, city_insee_code):

        return self.get_ods('/subscriberCity/%s' % city_insee_code)

    def topology(self, request, kind):

            'id': '%s' % item['id'],

            'text': item['name']

    def create_subscriber(self, request):

        try:

            payload = json.loads(request.body)

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

        if not isinstance(payload, dict):

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

    @endpoint(name='subscriber', pattern='^(?P<subscriber_id>\d+)/*$',

    def get_subscriber(self, request, subscriber_id):

    @endpoint(name='subscriber', pattern='^(?P<subscriber_id>\d+)/qrcode/*$',

    def get_subscriber_qrcode(self, request, subscriber_id):

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

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

                           err=response['code'])

        return HttpResponse(qrcode.content, content_type=content_type)

    def create_subscription(self, request):

        try:

            payload = json.loads(request.body)

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

        if not isinstance(payload, dict):

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

    @endpoint(name='subscription', pattern='^(?P<subscription_id>\d+)/*$',

    def get_subscription(self, request, subscription_id):

    def get_icon_class(cls):

        return 'gis'

    def district(self, request, lon=None, lat=None):

        if lon and lat:

            try:

            {'id': feature['attributes'].get('NUMERO'), 'text': feature['attributes'].get('NOM')} for feature in features]

        if len(data) == 1:

        return Client(url=self.wsdl_url, transport=Transport(self))

    def ping(self, request):

    def create(self, request):

        # get creation fields from payload

        try:

        fill_sudsobject_with_dict(creation, formdata.fields)

        # send it to "creer"

        resp = client.service.creer(creation)

    @classmethod

    def creation_fields(cls):

        '''used in greco_detail.html template'''

        return list_schema_fields(CREATION_SCHEMA)

    def status(self, request, iddemande, idgreco):

        resp = self.get_client().service.consulter({

            'idgreco': idgreco,

            'iddemande': iddemande,

        })

              methods=['get', 'post', 'put', 'patch'])

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

        if request.body:

            'iddemande': iddemande,

            'complementInfo': information,

        })

              methods=['get', 'post', 'put', 'patch'])

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

        if request.body:

            'iddemande': iddemande,

            'commentaire': comment,

        })

    def get_verbose_name(cls):

        return cls._meta.verbose_name

    def types(self, request):

        c = get_client(self)

    def ping(self, request):

        c = get_client(self)

    def subtypes(self, request, type=None):

        c = get_client(self)

        if type:

    def files(self, request, status=None):

        c = get_client(self)

        if status:

    def create_file(self, request, email=None):

        data = json.loads(request.body)

        title = data['title']

        r = c.service.CreerDossier(**d)

        if r.MessageRetour.codeRetour == 'KO':

            raise FileError(r.MessageRetour.message)

    def get_file(self, request, file_id):

        client = get_client(self)

        resp = client.service.GetDossier(file_id)

        return HttpResponse(base64.b64decode(fichier['value']),

                content_type=fichier['_contentType'])

    def get_file_status(self, request, file_id):

        c = get_client(self)

        resp = c.service.GetHistoDossier(file_id)

                raise Http404(resp.MessageRetour.message)

            raise FileError(resp.MessageRetour.message)

        last = resp.LogDossier[-1]

            'status': last.status, 'timestamp': last.timestamp

    def get_verbose_name(cls):

        return cls._meta.verbose_name

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

        """Create a demand

        """

        demand.save()

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

        """Return demand's statutes

        """

        status = demand.get_status()

        demand.save()

    def applicants(self, request, without=''):

    def certificates(self, request):

    def certificate_types(self, request, without=''):

class Demand(models.Model):

    def get_icon_class(cls):

        return 'grid'

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

        street_no = request.GET.get('street_no')

        street_name = request.GET.get('street_name')

            if row[idx_side] == 'P' and int(street_no) % 2 == 1:

                continue

                'id': row[titles.index('id')],

                'text': row[titles.index('text')],

                'code': row[titles.index('code')],

                'address': row[titles.index('address')],

                'canton': row[titles.index('canton')],

        raise APIError('Polling Station Not Found')

            numbers.append(number)

        return numbers

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

        try:

            data = json.loads(request.body)

        logging.info('sending message %r to %r with sending number %r',

                     data['message'], data['to'], data['from'])

        if 'nostop' in request.GET:

class endpoint(object):

        self.perm = perm

        self.methods = methods

        self.serializer_type = serializer_type

            d.update({"data": obj})

            return d

        else:

            return obj

    def err_to_response(self, err):

def test_base_adresse_search_qs_parameters_error(app, base_adresse,

                                                 mock_api_adresse_data_gouv_fr_search):

    # json-api serializer

    resp = app.get('/base-adresse/%s/streets?zipcode=13400&coin=zz' % base_adresse.slug, status=400)

    assert resp.json['err'] == 1

def test_jsondatastore(app, jsondatastore, jsondatastore2):

    resp = app.get('/jsondatastore/foobar/data/')

    resp = app.post_json('/jsondatastore/foobar/data/create', params={'foo': 'bar'})

    uuid = resp.json['id']

def test_jsondatastore_name_id(app, jsondatastore):

    resp = app.get('/jsondatastore/foobar/data/')

    resp = app.post_json('/jsondatastore/foobar/data/create?name_id=xxx', params={'foo': 'bar'})

    uuid = resp.json['id']

        return {"foo": "bar"}

    result = test_func(req)

    data = json.loads(result.content)

def test_jsonresponse_with_callback():

    request = RequestFactory()