1 | # -*- coding: utf-8 -*- |
||
2 | ''' |
||
3 | This module contains an opionated gateway for the crab webservice. |
||
4 | |||
5 | .. versionadded:: 0.3.0 |
||
6 | ''' |
||
7 | |||
8 | from __future__ import unicode_literals |
||
9 | import six |
||
10 | import math |
||
11 | import json |
||
12 | import os |
||
13 | |||
14 | from io import open |
||
15 | |||
16 | import logging |
||
17 | log = logging.getLogger(__name__) |
||
18 | |||
19 | from crabpy.client import crab_request |
||
20 | |||
21 | from suds import WebFault |
||
22 | |||
23 | from crabpy.gateway.exception import ( |
||
24 | GatewayRuntimeException, |
||
25 | GatewayResourceNotFoundException |
||
26 | ) |
||
27 | |||
28 | from dogpile.cache import make_region |
||
29 | |||
30 | parent_dir = os.path.dirname(__file__) |
||
31 | data_dir = os.path.join(os.path.dirname(__file__), '..', 'data') |
||
32 | deelgemeenten_json = json.load( |
||
33 | open(os.path.join(data_dir, "deelgemeenten.json"), |
||
34 | encoding='utf-8') |
||
35 | ) |
||
36 | |||
37 | |||
38 | def crab_gateway_request(client, method, *args): |
||
39 | ''' |
||
40 | Utility function that helps making requests to the CRAB service. |
||
41 | |||
42 | This is a specialised version of :func:`crabpy.client.crab_request` that |
||
43 | allows adding extra functionality for the calls made by the gateway. |
||
44 | |||
45 | :param client: A :class:`suds.client.Client` for the CRAB service. |
||
46 | :param string action: Which method to call, eg. `ListGewesten` |
||
47 | :returns: Result of the SOAP call. |
||
48 | ''' |
||
49 | try: |
||
50 | return crab_request(client, method, *args) |
||
51 | except WebFault as wf: |
||
52 | err = GatewayRuntimeException( |
||
53 | 'Could not execute request. Message from server:\n%s' % wf.fault['faultstring'], |
||
54 | wf |
||
55 | ) |
||
56 | raise err |
||
57 | |||
58 | |||
59 | class CrabGateway(object): |
||
60 | ''' |
||
61 | A gateway to the CRAB webservice. |
||
62 | ''' |
||
63 | caches = {} |
||
64 | |||
65 | provincies = [ |
||
66 | (10000, 'Antwerpen', 2), |
||
67 | (20001, 'Vlaams-Brabant', 2), |
||
68 | (30000, 'West-Vlaanderen', 2), |
||
69 | (40000, 'Oost-Vlaanderen', 2), |
||
70 | (70000, 'Limburg', 2), |
||
71 | (20002, 'Waals-Brabant', 3), |
||
72 | (50000, 'Henegouwen', 3), |
||
73 | (60000, 'Luik', 3), |
||
74 | (80000, 'Luxemburg', 3), |
||
75 | (90000, 'Namen', 3) |
||
76 | ] |
||
77 | |||
78 | def __init__(self, client, **kwargs): |
||
79 | self.client = client |
||
80 | cache_regions = ['permanent', 'long', 'short'] |
||
81 | for cr in cache_regions: |
||
82 | self.caches[cr] = make_region(key_mangler=str) |
||
83 | if 'cache_config' in kwargs: |
||
84 | for cr in cache_regions: |
||
85 | if ('%s.backend' % cr) in kwargs['cache_config']: |
||
86 | log.debug('Configuring %s region on CrabGateway', cr) |
||
87 | self.caches[cr].configure_from_config( |
||
88 | kwargs['cache_config'], |
||
89 | '%s.' % cr |
||
90 | ) |
||
91 | self.deelgemeenten = { |
||
92 | dg['deelgemeente_id']: { |
||
93 | 'id': dg['deelgemeente_id'], |
||
94 | 'naam': dg['deelgemeente_naam'], |
||
95 | 'gemeente_niscode': int(dg['gemeente_id']) |
||
96 | } for dg in deelgemeenten_json |
||
97 | } |
||
98 | |||
99 | def list_gewesten(self, sort=1): |
||
100 | ''' |
||
101 | List all `gewesten` in Belgium. |
||
102 | |||
103 | :param integer sort: What field to sort on. |
||
104 | :rtype: A :class`list` of class: `Gewest`. |
||
105 | ''' |
||
106 | def creator(): |
||
107 | res = crab_gateway_request(self.client, 'ListGewesten', sort) |
||
108 | tmp = {} |
||
109 | for r in res.GewestItem: |
||
110 | if r.GewestId not in tmp: |
||
111 | tmp[r.GewestId] = {} |
||
112 | tmp[r.GewestId][r.TaalCodeGewestNaam] = r.GewestNaam |
||
113 | return[ |
||
114 | Gewest( |
||
115 | k, |
||
116 | v |
||
117 | )for k, v in tmp.items() |
||
118 | ] |
||
119 | if self.caches['permanent'].is_configured: |
||
120 | key = 'ListGewesten#%s' % sort |
||
121 | gewesten = self.caches['permanent'].get_or_create(key, creator) |
||
122 | else: |
||
123 | gewesten = creator() |
||
124 | for g in gewesten: |
||
125 | g.set_gateway(self) |
||
126 | return gewesten |
||
127 | |||
128 | def get_gewest_by_id(self, id): |
||
129 | ''' |
||
130 | Get a `gewest` by id. |
||
131 | |||
132 | :param integer id: The id of a `gewest`. |
||
133 | :rtype: A :class:`Gewest`. |
||
134 | ''' |
||
135 | def creator(): |
||
136 | nl = crab_gateway_request( |
||
137 | self.client, 'GetGewestByGewestIdAndTaalCode', id, 'nl' |
||
138 | ) |
||
139 | fr = crab_gateway_request( |
||
140 | self.client, 'GetGewestByGewestIdAndTaalCode', id, 'fr' |
||
141 | ) |
||
142 | de = crab_gateway_request( |
||
143 | self.client, 'GetGewestByGewestIdAndTaalCode', id, 'de' |
||
144 | ) |
||
145 | if nl == None: |
||
146 | raise GatewayResourceNotFoundException() |
||
147 | return Gewest( |
||
148 | nl.GewestId, |
||
149 | { |
||
150 | 'nl': nl.GewestNaam, |
||
151 | 'fr': fr.GewestNaam, |
||
152 | 'de': de.GewestNaam |
||
153 | }, |
||
154 | (nl.CenterX, nl.CenterY), |
||
155 | (nl.MinimumX, nl.MinimumY, nl.MaximumX, nl.MaximumY), |
||
156 | ) |
||
157 | if self.caches['permanent'].is_configured: |
||
158 | key = 'GetGewestByGewestId#%s' % id |
||
159 | gewest = self.caches['long'].get_or_create(key, creator) |
||
160 | else: |
||
161 | gewest = creator() |
||
162 | gewest.set_gateway(self) |
||
163 | return gewest |
||
164 | |||
165 | View Code Duplication | def list_provincies(self, gewest=2): |
|
0 ignored issues
–
show
Duplication
introduced
by
Loading history...
|
|||
166 | ''' |
||
167 | List all `provincies` in a `gewest`. |
||
168 | |||
169 | :param gewest: The :class:`Gewest` for which the \ |
||
170 | `provincies` are wanted. |
||
171 | :param integer sort: What field to sort on. |
||
172 | :rtype: A :class:`list` of :class:`Provincie`. |
||
173 | ''' |
||
174 | try: |
||
175 | gewest_id = gewest.id |
||
176 | except AttributeError: |
||
177 | gewest_id = gewest |
||
178 | |||
179 | def creator(): |
||
180 | return [Provincie(p[0], p[1], Gewest(p[2])) for p in self.provincies if p[2] == gewest_id] |
||
181 | |||
182 | if self.caches['permanent'].is_configured: |
||
183 | key = 'ListProvinciesByGewestId#%s' % gewest_id |
||
184 | provincies = self.caches['permanent'].get_or_create(key, creator) |
||
185 | else: |
||
186 | provincies = creator() |
||
187 | for p in provincies: |
||
188 | p.set_gateway(self) |
||
189 | return provincies |
||
190 | |||
191 | View Code Duplication | def get_provincie_by_id(self, niscode): |
|
0 ignored issues
–
show
|
|||
192 | ''' |
||
193 | Retrieve a `provincie` by the niscode. |
||
194 | |||
195 | :param integer niscode: The niscode of the provincie. |
||
196 | :rtype: :class:`Provincie` |
||
197 | ''' |
||
198 | def creator(): |
||
199 | for p in self.provincies: |
||
200 | if p[0] == niscode: |
||
201 | return Provincie(p[0], p[1], Gewest(p[2])) |
||
202 | |||
203 | if self.caches['permanent'].is_configured: |
||
204 | key = 'GetProvincieByProvincieNiscode#%s' % niscode |
||
205 | provincie = self.caches['permanent'].get_or_create(key, creator) |
||
206 | else: |
||
207 | provincie = creator() |
||
208 | if provincie == None: |
||
209 | raise GatewayResourceNotFoundException() |
||
210 | provincie.set_gateway(self) |
||
211 | return provincie |
||
212 | |||
213 | View Code Duplication | def list_gemeenten_by_provincie(self, provincie): |
|
0 ignored issues
–
show
|
|||
214 | ''' |
||
215 | List all `gemeenten` in a `provincie`. |
||
216 | |||
217 | :param provincie: The :class:`Provincie` for which the \ |
||
218 | `gemeenten` are wanted. |
||
219 | :rtype: A :class:`list` of :class:`Gemeente`. |
||
220 | ''' |
||
221 | try: |
||
222 | gewest = provincie.gewest |
||
223 | prov = provincie |
||
224 | except AttributeError: |
||
225 | prov = self.get_provincie_by_id(provincie) |
||
226 | gewest = prov.gewest |
||
227 | gewest.clear_gateway() |
||
228 | |||
229 | def creator(): |
||
230 | gewest_gemeenten = self.list_gemeenten(gewest.id) |
||
231 | return[ |
||
232 | Gemeente( |
||
233 | r.id, |
||
234 | r.naam, |
||
235 | r.niscode, |
||
236 | gewest |
||
237 | )for r in gewest_gemeenten if str(r.niscode)[0] == str(prov.niscode)[0] |
||
238 | ] |
||
239 | |||
240 | if self.caches['permanent'].is_configured: |
||
241 | key = 'ListGemeentenByProvincieId#%s' % prov.id |
||
242 | gemeente = self.caches['long'].get_or_create(key, creator) |
||
243 | else: |
||
244 | gemeente = creator() |
||
245 | for g in gemeente: |
||
246 | g.set_gateway(self) |
||
247 | return gemeente |
||
248 | |||
249 | View Code Duplication | def list_gemeenten(self, gewest=2, sort=1): |
|
0 ignored issues
–
show
|
|||
250 | ''' |
||
251 | List all `gemeenten` in a `gewest`. |
||
252 | |||
253 | :param gewest: The :class:`Gewest` for which the \ |
||
254 | `gemeenten` are wanted. |
||
255 | :param integer sort: What field to sort on. |
||
256 | :rtype: A :class:`list` of :class:`Gemeente`. |
||
257 | ''' |
||
258 | try: |
||
259 | gewest_id = gewest.id |
||
260 | except AttributeError: |
||
261 | gewest_id = gewest |
||
262 | gewest = self.get_gewest_by_id(gewest_id) |
||
263 | gewest.clear_gateway() |
||
264 | |||
265 | def creator(): |
||
266 | res = crab_gateway_request( |
||
267 | self.client, 'ListGemeentenByGewestId', gewest_id, sort |
||
268 | ) |
||
269 | return[ |
||
270 | Gemeente( |
||
271 | r.GemeenteId, |
||
272 | r.GemeenteNaam, |
||
273 | r.NISGemeenteCode, |
||
274 | gewest |
||
275 | )for r in res.GemeenteItem if r.TaalCode == r.TaalCodeGemeenteNaam |
||
276 | ] |
||
277 | if self.caches['permanent'].is_configured: |
||
278 | key = 'ListGemeentenByGewestId#%s#%s' % (gewest_id, sort) |
||
279 | gemeenten = self.caches['permanent'].get_or_create(key, creator) |
||
280 | else: |
||
281 | gemeenten = creator() |
||
282 | for g in gemeenten: |
||
283 | g.set_gateway(self) |
||
284 | return gemeenten |
||
285 | |||
286 | View Code Duplication | def get_gemeente_by_id(self, id): |
|
0 ignored issues
–
show
|
|||
287 | ''' |
||
288 | Retrieve a `gemeente` by the crab id. |
||
289 | |||
290 | :param integer id: The CRAB id of the gemeente. |
||
291 | :rtype: :class:`Gemeente` |
||
292 | ''' |
||
293 | def creator(): |
||
294 | res = crab_gateway_request( |
||
295 | self.client, 'GetGemeenteByGemeenteId', id |
||
296 | ) |
||
297 | if res == None: |
||
298 | raise GatewayResourceNotFoundException() |
||
299 | return Gemeente( |
||
300 | res.GemeenteId, |
||
301 | res.GemeenteNaam, |
||
302 | res.NisGemeenteCode, |
||
303 | Gewest(res.GewestId), |
||
304 | res.TaalCode, |
||
305 | (res.CenterX, res.CenterY), |
||
306 | (res.MinimumX, res.MinimumY, res.MaximumX, res.MaximumY), |
||
307 | Metadata( |
||
308 | res.BeginDatum, |
||
309 | res.BeginTijd, |
||
310 | self.get_bewerking(res.BeginBewerking), |
||
311 | self.get_organisatie(res.BeginOrganisatie) |
||
312 | ) |
||
313 | ) |
||
314 | if self.caches['long'].is_configured: |
||
315 | key = 'GetGemeenteByGemeenteId#%s' % id |
||
316 | gemeente = self.caches['long'].get_or_create(key, creator) |
||
317 | else: |
||
318 | gemeente = creator() |
||
319 | gemeente.set_gateway(self) |
||
320 | return gemeente |
||
321 | |||
322 | View Code Duplication | def get_gemeente_by_niscode(self, niscode): |
|
0 ignored issues
–
show
|
|||
323 | ''' |
||
324 | Retrieve a `gemeente` by the NIScode. |
||
325 | |||
326 | :param integer niscode: The NIScode of the gemeente. |
||
327 | :rtype: :class:`Gemeente` |
||
328 | ''' |
||
329 | |||
330 | def creator(): |
||
331 | res = crab_gateway_request( |
||
332 | self.client, 'GetGemeenteByNISGemeenteCode', niscode |
||
333 | ) |
||
334 | if res == None: |
||
335 | raise GatewayResourceNotFoundException() |
||
336 | return Gemeente( |
||
337 | res.GemeenteId, |
||
338 | res.GemeenteNaam, |
||
339 | res.NisGemeenteCode, |
||
340 | Gewest(res.GewestId), |
||
341 | res.TaalCode, |
||
342 | (res.CenterX, res.CenterY), |
||
343 | (res.MinimumX, res.MinimumY, res.MaximumX, res.MaximumY), |
||
344 | Metadata( |
||
345 | res.BeginDatum, |
||
346 | res.BeginTijd, |
||
347 | self.get_bewerking(res.BeginBewerking), |
||
348 | self.get_organisatie(res.BeginOrganisatie) |
||
349 | ) |
||
350 | ) |
||
351 | if self.caches['long'].is_configured: |
||
352 | key = 'GetGemeenteByNISGemeenteCode#%s' % niscode |
||
353 | gemeente = self.caches['long'].get_or_create(key, creator) |
||
354 | else: |
||
355 | gemeente = creator() |
||
356 | gemeente.set_gateway(self) |
||
357 | return gemeente |
||
358 | |||
359 | View Code Duplication | def list_deelgemeenten(self, gewest=2): |
|
0 ignored issues
–
show
|
|||
360 | ''' |
||
361 | List all `deelgemeenten` in a `gewest`. |
||
362 | |||
363 | :param gewest: The :class:`Gewest` for which the \ |
||
364 | `deelgemeenten` are wanted. Currently only Flanders is supported. |
||
365 | :rtype: A :class:`list` of :class:`Deelgemeente`. |
||
366 | ''' |
||
367 | try: |
||
368 | gewest_id = gewest.id |
||
369 | except AttributeError: |
||
370 | gewest_id = gewest |
||
371 | |||
372 | if gewest_id != 2: |
||
373 | raise ValueError('Currently only deelgemeenten in Flanders are known.') |
||
374 | |||
375 | def creator(): |
||
376 | return [Deelgemeente(dg['id'], dg['naam'], dg['gemeente_niscode']) for dg in self.deelgemeenten.values()] |
||
377 | |||
378 | if self.caches['permanent'].is_configured: |
||
379 | key = 'ListDeelgemeentenByGewestId#%s' % gewest_id |
||
380 | deelgemeenten = self.caches['permanent'].get_or_create(key, creator) |
||
381 | else: |
||
382 | deelgemeenten = creator() |
||
383 | for dg in deelgemeenten: |
||
384 | dg.set_gateway(self) |
||
385 | return deelgemeenten |
||
386 | |||
387 | View Code Duplication | def list_deelgemeenten_by_gemeente(self, gemeente): |
|
0 ignored issues
–
show
|
|||
388 | ''' |
||
389 | List all `deelgemeenten` in a `gemeente`. |
||
390 | |||
391 | :param gemeente: The :class:`Gemeente` for which the \ |
||
392 | `deelgemeenten` are wanted. Currently only Flanders is supported. |
||
393 | :rtype: A :class:`list` of :class:`Deelgemeente`. |
||
394 | ''' |
||
395 | try: |
||
396 | niscode = gemeente.niscode |
||
397 | except AttributeError: |
||
398 | niscode = gemeente |
||
399 | |||
400 | def creator(): |
||
401 | return [ |
||
402 | Deelgemeente(dg['id'], dg['naam'], dg['gemeente_niscode']) |
||
403 | for dg in self.deelgemeenten.values() if dg['gemeente_niscode'] == niscode |
||
404 | ] |
||
405 | |||
406 | if self.caches['permanent'].is_configured: |
||
407 | key = 'ListDeelgemeentenByGemeenteId#%s' % niscode |
||
408 | deelgemeenten = self.caches['permanent'].get_or_create(key, creator) |
||
409 | else: |
||
410 | deelgemeenten = creator() |
||
411 | for dg in deelgemeenten: |
||
412 | dg.set_gateway(self) |
||
413 | return deelgemeenten |
||
414 | |||
415 | View Code Duplication | def get_deelgemeente_by_id(self, id): |
|
0 ignored issues
–
show
|
|||
416 | ''' |
||
417 | Retrieve a `deelgemeente` by the id. |
||
418 | |||
419 | :param string id: The id of the deelgemeente. |
||
420 | :rtype: :class:`Deelgemeente` |
||
421 | ''' |
||
422 | def creator(): |
||
423 | if id in self.deelgemeenten: |
||
424 | dg = self.deelgemeenten[id] |
||
425 | return Deelgemeente(dg['id'], dg['naam'], dg['gemeente_niscode']) |
||
426 | else: |
||
427 | return None |
||
428 | |||
429 | if self.caches['permanent'].is_configured: |
||
430 | key = 'GetDeelgemeenteByDeelgemeenteId#%s' % id |
||
431 | deelgemeente = self.caches['permanent'].get_or_create(key, creator) |
||
432 | else: |
||
433 | deelgemeente = creator() |
||
434 | if deelgemeente == None: |
||
435 | raise GatewayResourceNotFoundException() |
||
436 | deelgemeente.set_gateway(self) |
||
437 | return deelgemeente |
||
438 | |||
439 | def _list_codeobject(self, function, sort, returnclass): |
||
440 | def creator(): |
||
441 | res = crab_gateway_request(self.client, function, sort) |
||
442 | return[ |
||
443 | globals()[returnclass]( |
||
444 | r.Code, |
||
445 | r.Naam, |
||
446 | r.Definitie |
||
447 | )for r in res.CodeItem |
||
448 | ] |
||
449 | if self.caches['permanent'].is_configured: |
||
450 | key = function + '#%s' % (sort) |
||
451 | return self.caches['permanent'].get_or_create(key, creator) |
||
452 | else: |
||
453 | return creator() |
||
454 | |||
455 | def list_talen(self, sort=1): |
||
456 | ''' |
||
457 | List all `talen`. |
||
458 | |||
459 | :rtype: A :class:`list` of :class:`Taal` |
||
460 | ''' |
||
461 | return self._list_codeobject('ListTalen', sort, 'Taal') |
||
462 | |||
463 | def list_bewerkingen(self, sort=1): |
||
464 | ''' |
||
465 | List all `bewerkingen`. |
||
466 | |||
467 | :rtype: A :class:`list` of :class:`Bewerking` |
||
468 | ''' |
||
469 | return self._list_codeobject( |
||
470 | 'ListBewerkingen', sort, 'Bewerking' |
||
471 | ) |
||
472 | |||
473 | def list_organisaties(self, sort=1): |
||
474 | ''' |
||
475 | List all `organisaties`. |
||
476 | |||
477 | :rtype: A :class:`list` of :class:`Organisatie` |
||
478 | ''' |
||
479 | return self._list_codeobject( |
||
480 | 'ListOrganisaties', sort, 'Organisatie' |
||
481 | ) |
||
482 | |||
483 | def list_aardsubadressen(self, sort=1): |
||
484 | ''' |
||
485 | List all `aardsubadressen`. |
||
486 | |||
487 | :rtype: A :class:`list` of :class:`Aardsubadres` |
||
488 | ''' |
||
489 | return self._list_codeobject( |
||
490 | 'ListAardSubadressen', sort, 'Aardsubadres' |
||
491 | ) |
||
492 | |||
493 | def list_aardadressen(self, sort=1): |
||
494 | ''' |
||
495 | List all `aardadressen`. |
||
496 | |||
497 | :rtype: A :class:`list` of :class:`Aardadres` |
||
498 | ''' |
||
499 | return self._list_codeobject( |
||
500 | 'ListAardAdressen', sort, 'Aardadres' |
||
501 | ) |
||
502 | |||
503 | def list_aardgebouwen(self, sort=1): |
||
504 | ''' |
||
505 | List all `aardgebouwen`. |
||
506 | |||
507 | :rtype: A :class:`list` of :class:`Aardgebouw` |
||
508 | ''' |
||
509 | return self._list_codeobject( |
||
510 | 'ListAardGebouwen', sort, 'Aardgebouw' |
||
511 | ) |
||
512 | |||
513 | def list_aardwegobjecten(self, sort=1): |
||
514 | ''' |
||
515 | List all `aardwegobjecten`. |
||
516 | |||
517 | :rtype: A :class:`list` of :class:`Aardwegobject` |
||
518 | ''' |
||
519 | return self._list_codeobject( |
||
520 | 'ListAardWegobjecten', sort, 'Aardwegobject' |
||
521 | ) |
||
522 | |||
523 | def list_aardterreinobjecten(self, sort=1): |
||
524 | ''' |
||
525 | List all `aardterreinobjecten`. |
||
526 | |||
527 | :rtype: A :class:`list` of :class:`Aardterreinobject` |
||
528 | ''' |
||
529 | return self._list_codeobject( |
||
530 | 'ListAardTerreinobjecten', sort, 'Aardterreinobject' |
||
531 | ) |
||
532 | |||
533 | def list_statushuisnummers(self, sort=1): |
||
534 | ''' |
||
535 | List all `statushuisnummers`. |
||
536 | |||
537 | :rtype: A :class:`list` of :class:`Statushuisnummer` |
||
538 | ''' |
||
539 | return self._list_codeobject( |
||
540 | 'ListStatusHuisnummers', sort, 'Statushuisnummer' |
||
541 | ) |
||
542 | |||
543 | def list_statussubadressen(self, sort=1): |
||
544 | ''' |
||
545 | List all `statussubadressen`. |
||
546 | |||
547 | :rtype: A :class:`list` of :class:`Statussubadres` |
||
548 | ''' |
||
549 | return self._list_codeobject( |
||
550 | 'ListStatusSubadressen', sort, 'Statussubadres' |
||
551 | ) |
||
552 | |||
553 | def list_statusstraatnamen(self, sort=1): |
||
554 | ''' |
||
555 | List all `statusstraatnamen`. |
||
556 | |||
557 | :rtype: A :class:`list` of :class:`Statusstraatnaam` |
||
558 | ''' |
||
559 | return self._list_codeobject( |
||
560 | 'ListStatusStraatnamen', sort, 'Statusstraatnaam' |
||
561 | ) |
||
562 | |||
563 | def list_statuswegsegmenten(self, sort=1): |
||
564 | ''' |
||
565 | List all `statuswegsegmenten`. |
||
566 | |||
567 | :rtype: A :class:`list` of :class:`Statuswegsegment` |
||
568 | ''' |
||
569 | return self._list_codeobject( |
||
570 | 'ListStatusWegsegmenten', sort, 'Statuswegsegment' |
||
571 | ) |
||
572 | |||
573 | def list_geometriemethodewegsegmenten(self, sort=1): |
||
574 | ''' |
||
575 | List all `geometriemethodewegsegmenten`. |
||
576 | |||
577 | :rtype: A :class:`list` of :class:`Geometriemethodewegsegment` |
||
578 | ''' |
||
579 | return self._list_codeobject( |
||
580 | 'ListGeometriemethodeWegsegmenten', sort, |
||
581 | 'Geometriemethodewegsegment' |
||
582 | ) |
||
583 | |||
584 | def list_statusgebouwen(self, sort=1): |
||
585 | ''' |
||
586 | List all `statusgebouwen`. |
||
587 | |||
588 | :rtype: A :class:`list` of :class:`Statusgebouwen` |
||
589 | ''' |
||
590 | return self._list_codeobject( |
||
591 | 'ListStatusGebouwen', sort, 'Statusgebouw' |
||
592 | ) |
||
593 | |||
594 | def list_geometriemethodegebouwen(self, sort=1): |
||
595 | ''' |
||
596 | List all `geometriegebouwen`. |
||
597 | |||
598 | :rtype: A :class:`list` of :class:`Geometriegebouw` |
||
599 | ''' |
||
600 | return self._list_codeobject( |
||
601 | 'ListGeometriemethodeGebouwen', sort, 'Geometriemethodegebouw' |
||
602 | ) |
||
603 | |||
604 | def list_herkomstadresposities(self, sort=1): |
||
605 | ''' |
||
606 | List all `herkomstadresposities`. |
||
607 | |||
608 | :rtype: A :class:`list` of :class:`Herkomstadrespositie` |
||
609 | ''' |
||
610 | return self._list_codeobject( |
||
611 | 'ListHerkomstAdresposities', sort, 'Herkomstadrespositie' |
||
612 | ) |
||
613 | |||
614 | View Code Duplication | def list_straten(self, gemeente, sort=1): |
|
0 ignored issues
–
show
|
|||
615 | ''' |
||
616 | List all `straten` in a `Gemeente`. |
||
617 | |||
618 | :param gemeente: The :class:`Gemeente` for which the \ |
||
619 | `straten` are wanted. |
||
620 | :rtype: A :class:`list` of :class:`Straat` |
||
621 | ''' |
||
622 | try: |
||
623 | id = gemeente.id |
||
624 | except AttributeError: |
||
625 | id = gemeente |
||
626 | |||
627 | def creator(): |
||
628 | res = crab_gateway_request( |
||
629 | self.client, 'ListStraatnamenWithStatusByGemeenteId', |
||
630 | id, sort |
||
631 | ) |
||
632 | try: |
||
633 | return[ |
||
634 | Straat( |
||
635 | r.StraatnaamId, |
||
636 | r.StraatnaamLabel, |
||
637 | id, |
||
638 | r.StatusStraatnaam |
||
639 | )for r in res.StraatnaamWithStatusItem |
||
640 | ] |
||
641 | except AttributeError: |
||
642 | return [] |
||
643 | if self.caches['long'].is_configured: |
||
644 | key = 'ListStraatnamenWithStatusByGemeenteId#%s%s' % (id, sort) |
||
645 | straten = self.caches['long'].get_or_create(key, creator) |
||
646 | else: |
||
647 | straten = creator() |
||
648 | for s in straten: |
||
649 | s.set_gateway(self) |
||
650 | return straten |
||
651 | |||
652 | def get_straat_by_id(self, id): |
||
653 | ''' |
||
654 | Retrieve a `straat` by the Id. |
||
655 | |||
656 | :param integer id: The id of the `straat`. |
||
657 | :rtype: :class:`Straat` |
||
658 | ''' |
||
659 | def creator(): |
||
660 | res = crab_gateway_request( |
||
661 | self.client, 'GetStraatnaamWithStatusByStraatnaamId', id |
||
662 | ) |
||
663 | if res == None: |
||
664 | raise GatewayResourceNotFoundException() |
||
665 | return Straat( |
||
666 | res.StraatnaamId, |
||
667 | res.StraatnaamLabel, |
||
668 | res.GemeenteId, |
||
669 | res.StatusStraatnaam, |
||
670 | res.Straatnaam, |
||
671 | res.TaalCode, |
||
672 | res.StraatnaamTweedeTaal, |
||
673 | res.TaalCodeTweedeTaal, |
||
674 | Metadata( |
||
675 | res.BeginDatum, |
||
676 | res.BeginTijd, |
||
677 | self.get_bewerking(res.BeginBewerking), |
||
678 | self.get_organisatie(res.BeginOrganisatie) |
||
679 | ) |
||
680 | ) |
||
681 | |||
682 | if self.caches['long'].is_configured: |
||
683 | key = 'GetStraatnaamWithStatusByStraatnaamId#%s' % (id) |
||
684 | straat = self.caches['long'].get_or_create(key, creator) |
||
685 | else: |
||
686 | straat = creator() |
||
687 | straat.set_gateway(self) |
||
688 | return straat |
||
689 | |||
690 | View Code Duplication | def list_huisnummers_by_straat(self, straat, sort=1): |
|
0 ignored issues
–
show
|
|||
691 | ''' |
||
692 | List all `huisnummers` in a `Straat`. |
||
693 | |||
694 | :param straat: The :class:`Straat` for which the \ |
||
695 | `huisnummers` are wanted. |
||
696 | :rtype: A :class: `list` of :class:`Huisnummer` |
||
697 | ''' |
||
698 | try: |
||
699 | id = straat.id |
||
700 | except AttributeError: |
||
701 | id = straat |
||
702 | |||
703 | def creator(): |
||
704 | res = crab_gateway_request( |
||
705 | self.client, 'ListHuisnummersWithStatusByStraatnaamId', |
||
706 | id, sort |
||
707 | ) |
||
708 | try: |
||
709 | return[ |
||
710 | Huisnummer( |
||
711 | r.HuisnummerId, |
||
712 | r.StatusHuisnummer, |
||
713 | r.Huisnummer, |
||
714 | id |
||
715 | ) for r in res.HuisnummerWithStatusItem |
||
716 | ] |
||
717 | except AttributeError: |
||
718 | return [] |
||
719 | if self.caches['short'].is_configured: |
||
720 | key = 'ListHuisnummersWithStatusByStraatnaamId#%s%s' % (id, sort) |
||
721 | huisnummers = self.caches['short'].get_or_create(key, creator) |
||
722 | else: |
||
723 | huisnummers = creator() |
||
724 | for h in huisnummers: |
||
725 | h.set_gateway(self) |
||
726 | return huisnummers |
||
727 | |||
728 | def list_huisnummers_by_perceel(self, perceel, sort=1): |
||
729 | ''' |
||
730 | List all `huisnummers` on a `Pereel`. |
||
731 | |||
732 | Generally there will only be one, but multiples are possible. |
||
733 | |||
734 | :param perceel: The :class:`Perceel` for which the \ |
||
735 | `huisnummers` are wanted. |
||
736 | :rtype: A :class: `list` of :class:`Huisnummer` |
||
737 | ''' |
||
738 | try: |
||
739 | id = perceel.id |
||
740 | except AttributeError: |
||
741 | id = perceel |
||
742 | |||
743 | def creator(): |
||
744 | res = crab_gateway_request( |
||
745 | self.client, 'ListHuisnummersWithStatusByIdentificatorPerceel', |
||
746 | id, sort |
||
747 | ) |
||
748 | try: |
||
749 | huisnummers= [] |
||
750 | for r in res.HuisnummerWithStatusItem: |
||
751 | h = self.get_huisnummer_by_id(r.HuisnummerId) |
||
752 | h.clear_gateway() |
||
753 | huisnummers.append(h) |
||
754 | return huisnummers |
||
755 | except AttributeError: |
||
756 | return [] |
||
757 | if self.caches['short'].is_configured: |
||
758 | key = 'ListHuisnummersWithStatusByIdentificatorPerceel#%s%s' % (id, sort) |
||
759 | huisnummers = self.caches['short'].get_or_create(key, creator) |
||
760 | else: |
||
761 | huisnummers = creator() |
||
762 | for h in huisnummers: |
||
763 | h.set_gateway(self) |
||
764 | return huisnummers |
||
765 | |||
766 | def get_huisnummer_by_id(self, id): |
||
767 | ''' |
||
768 | Retrieve a `huisnummer` by the Id. |
||
769 | |||
770 | :param integer id: the Id of the `huisnummer` |
||
771 | :rtype: :class:`Huisnummer` |
||
772 | ''' |
||
773 | def creator(): |
||
774 | res = crab_gateway_request( |
||
775 | self.client, 'GetHuisnummerWithStatusByHuisnummerId', id |
||
776 | ) |
||
777 | if res == None: |
||
778 | raise GatewayResourceNotFoundException() |
||
779 | return Huisnummer( |
||
780 | res.HuisnummerId, |
||
781 | res.StatusHuisnummer, |
||
782 | res.Huisnummer, |
||
783 | res.StraatnaamId, |
||
784 | Metadata( |
||
785 | res.BeginDatum, |
||
786 | res.BeginTijd, |
||
787 | self.get_bewerking(res.BeginBewerking), |
||
788 | self.get_organisatie(res.BeginOrganisatie) |
||
789 | ) |
||
790 | ) |
||
791 | if self.caches['short'].is_configured: |
||
792 | key = 'GetHuisnummerWithStatusByHuisnummerId#%s' % (id) |
||
793 | huisnummer = self.caches['short'].get_or_create(key, creator) |
||
794 | else: |
||
795 | huisnummer = creator() |
||
796 | huisnummer.set_gateway(self) |
||
797 | return huisnummer |
||
798 | |||
799 | def get_huisnummer_by_nummer_and_straat(self, nummer, straat): |
||
800 | ''' |
||
801 | Retrieve a `huisnummer` by the `nummer` and `straat` |
||
802 | |||
803 | :param integer nummer: The huisnummer of the 'huisnummer` |
||
804 | :param straat: The :class:`Straat` in which the `huisnummer` \ |
||
805 | is situated. |
||
806 | :rtype: A :class:`Huisnummer` |
||
807 | ''' |
||
808 | try: |
||
809 | straat_id = straat.id |
||
810 | except AttributeError: |
||
811 | straat_id = straat |
||
812 | |||
813 | def creator(): |
||
814 | res = crab_gateway_request( |
||
815 | self.client, 'GetHuisnummerWithStatusByHuisnummer', |
||
816 | nummer, straat_id |
||
817 | ) |
||
818 | if res == None: |
||
819 | raise GatewayResourceNotFoundException() |
||
820 | return Huisnummer( |
||
821 | res.HuisnummerId, |
||
822 | res.StatusHuisnummer, |
||
823 | res.Huisnummer, |
||
824 | res.StraatnaamId, |
||
825 | Metadata( |
||
826 | res.BeginDatum, |
||
827 | res.BeginTijd, |
||
828 | self.get_bewerking(res.BeginBewerking), |
||
829 | self.get_organisatie(res.BeginOrganisatie) |
||
830 | ) |
||
831 | ) |
||
832 | if self.caches['short'].is_configured: |
||
833 | key = 'GetHuisnummerWithStatusByHuisnummer#%s%s' % (nummer, straat_id) |
||
834 | huisnummer = self.caches['short'].get_or_create(key, creator) |
||
835 | else: |
||
836 | huisnummer = creator() |
||
837 | huisnummer.set_gateway(self) |
||
838 | return huisnummer |
||
839 | |||
840 | def list_postkantons_by_gemeente(self, gemeente): |
||
841 | ''' |
||
842 | List all `postkantons` in a :class:`Gemeente` |
||
843 | |||
844 | :param gemeente: The :class:`Gemeente` for which the \ |
||
845 | `potkantons` are wanted. |
||
846 | :rtype: A :class:`list` of :class:`Postkanton` |
||
847 | ''' |
||
848 | try: |
||
849 | id = gemeente.id |
||
850 | except AttributeError: |
||
851 | id = gemeente |
||
852 | |||
853 | def creator(): |
||
854 | res = crab_gateway_request( |
||
855 | self.client, 'ListPostkantonsByGemeenteId', id |
||
856 | ) |
||
857 | try: |
||
858 | return[ |
||
859 | Postkanton( |
||
860 | r.PostkantonCode |
||
861 | )for r in res.PostkantonItem |
||
862 | ] |
||
863 | except AttributeError: |
||
864 | return [] |
||
865 | if self.caches['long'].is_configured: |
||
866 | key = 'ListPostkantonsByGemeenteId#%s' % (id) |
||
867 | postkantons = self.caches['long'].get_or_create(key, creator) |
||
868 | else: |
||
869 | postkantons = creator() |
||
870 | for r in postkantons: |
||
871 | r.set_gateway(self) |
||
872 | return postkantons |
||
873 | |||
874 | View Code Duplication | def get_postkanton_by_huisnummer(self, huisnummer): |
|
0 ignored issues
–
show
|
|||
875 | ''' |
||
876 | Retrieve a `postkanton` by the Huisnummer. |
||
877 | |||
878 | :param huisnummer: The :class:`Huisnummer` for which the `postkanton` \ |
||
879 | is wanted. |
||
880 | :rtype: :class:`Postkanton` |
||
881 | ''' |
||
882 | try: |
||
883 | id = huisnummer.id |
||
884 | except AttributeError: |
||
885 | id = huisnummer |
||
886 | |||
887 | def creator(): |
||
888 | res = crab_gateway_request( |
||
889 | self.client, 'GetPostkantonByHuisnummerId', id |
||
890 | ) |
||
891 | if res == None: |
||
892 | raise GatewayResourceNotFoundException() |
||
893 | return Postkanton( |
||
894 | res.PostkantonCode |
||
895 | ) |
||
896 | if self.caches['short'].is_configured: |
||
897 | key = 'GetPostkantonByHuisnummerId#%s' % (id) |
||
898 | postkanton = self.caches['short'].get_or_create(key, creator) |
||
899 | else: |
||
900 | postkanton = creator() |
||
901 | postkanton.set_gateway(self) |
||
902 | return postkanton |
||
903 | |||
904 | View Code Duplication | def get_wegobject_by_id(self, id): |
|
0 ignored issues
–
show
|
|||
905 | ''' |
||
906 | Retrieve a `Wegobject` by the Id. |
||
907 | |||
908 | :param integer id: the Id of the `Wegobject` |
||
909 | :rtype: :class:`Wegobject` |
||
910 | ''' |
||
911 | def creator(): |
||
912 | res = crab_gateway_request( |
||
913 | self.client, 'GetWegobjectByIdentificatorWegobject', id |
||
914 | ) |
||
915 | if res == None: |
||
916 | raise GatewayResourceNotFoundException() |
||
917 | return Wegobject( |
||
918 | res.IdentificatorWegobject, |
||
919 | res.AardWegobject, |
||
920 | (res.CenterX, res.CenterY), |
||
921 | (res.MinimumX, res.MinimumY, res.MaximumX, res.MaximumY), |
||
922 | Metadata( |
||
923 | res.BeginDatum, |
||
924 | res.BeginTijd, |
||
925 | self.get_bewerking(res.BeginBewerking), |
||
926 | self.get_organisatie(res.BeginOrganisatie) |
||
927 | ) |
||
928 | ) |
||
929 | if self.caches['short'].is_configured: |
||
930 | key = 'GetWegobjectByIdentificatorWegobject#%s' % (id) |
||
931 | wegobject = self.caches['short'].get_or_create(key, creator) |
||
932 | else: |
||
933 | wegobject = creator() |
||
934 | wegobject.set_gateway(self) |
||
935 | return wegobject |
||
936 | |||
937 | def list_wegobjecten_by_straat(self, straat): |
||
938 | ''' |
||
939 | List all `wegobjecten` in a :class:`Straat` |
||
940 | |||
941 | :param straat: The :class:`Straat` for which the `wegobjecten` \ |
||
942 | are wanted. |
||
943 | :rtype: A :class:`list` of :class:`Wegobject` |
||
944 | ''' |
||
945 | try: |
||
946 | id = straat.id |
||
947 | except AttributeError: |
||
948 | id = straat |
||
949 | |||
950 | def creator(): |
||
951 | res = crab_gateway_request( |
||
952 | self.client, 'ListWegobjectenByStraatnaamId', id |
||
953 | ) |
||
954 | try: |
||
955 | return [ |
||
956 | Wegobject( |
||
957 | r.IdentificatorWegobject, |
||
958 | r.AardWegobject |
||
959 | )for r in res.WegobjectItem |
||
960 | ] |
||
961 | except AttributeError: |
||
962 | return [] |
||
963 | if self.caches['short'].is_configured: |
||
964 | key = 'ListWegobjectenByStraatnaamId#%s' % (id) |
||
965 | wegobjecten = self.caches['short'].get_or_create(key, creator) |
||
966 | else: |
||
967 | wegobjecten = creator() |
||
968 | for r in wegobjecten: |
||
969 | r.set_gateway(self) |
||
970 | return wegobjecten |
||
971 | |||
972 | def get_wegsegment_by_id(self, id): |
||
973 | ''' |
||
974 | Retrieve a `wegsegment` by the Id. |
||
975 | |||
976 | :param integer id: the Id of the `wegsegment` |
||
977 | :rtype: :class:`Wegsegment` |
||
978 | ''' |
||
979 | def creator(): |
||
980 | res = crab_gateway_request( |
||
981 | self.client, |
||
982 | 'GetWegsegmentByIdentificatorWegsegment', id |
||
983 | ) |
||
984 | if res == None: |
||
985 | raise GatewayResourceNotFoundException() |
||
986 | return Wegsegment( |
||
987 | res.IdentificatorWegsegment, |
||
988 | res.StatusWegsegment, |
||
989 | res.GeometriemethodeWegsegment, |
||
990 | res.Geometrie, |
||
991 | Metadata( |
||
992 | res.BeginDatum, |
||
993 | res.BeginTijd, |
||
994 | self.get_bewerking(res.BeginBewerking), |
||
995 | self.get_organisatie(res.BeginOrganisatie) |
||
996 | ) |
||
997 | ) |
||
998 | if self.caches['short'].is_configured: |
||
999 | key = 'GetWegsegmentByIdentificatorWegsegment#%s' % (id) |
||
1000 | wegsegment = self.caches['short'].get_or_create(key, creator) |
||
1001 | else: |
||
1002 | wegsegment = creator() |
||
1003 | wegsegment.set_gateway(self) |
||
1004 | return wegsegment |
||
1005 | |||
1006 | def list_wegsegmenten_by_straat(self, straat): |
||
1007 | ''' |
||
1008 | List all `wegsegmenten` in a :class:`Straat` |
||
1009 | |||
1010 | :param straat: The :class:`Straat` for which the `wegsegmenten` \ |
||
1011 | are wanted. |
||
1012 | :rtype: A :class:`list` of :class:`Wegsegment` |
||
1013 | ''' |
||
1014 | try: |
||
1015 | id = straat.id |
||
1016 | except AttributeError: |
||
1017 | id = straat |
||
1018 | |||
1019 | def creator(): |
||
1020 | res = crab_gateway_request( |
||
1021 | self.client, 'ListWegsegmentenByStraatnaamId', id |
||
1022 | ) |
||
1023 | try: |
||
1024 | return[ |
||
1025 | Wegsegment( |
||
1026 | r.IdentificatorWegsegment, |
||
1027 | r.StatusWegsegment |
||
1028 | )for r in res.WegsegmentItem |
||
1029 | ] |
||
1030 | except AttributeError: |
||
1031 | return [] |
||
1032 | if self.caches['short'].is_configured: |
||
1033 | key = 'ListWegsegmentenByStraatnaamId#%s' % (id) |
||
1034 | wegsegmenten = self.caches['short'].get_or_create(key, creator) |
||
1035 | else: |
||
1036 | wegsegmenten = creator() |
||
1037 | for r in wegsegmenten: |
||
1038 | r.set_gateway(self) |
||
1039 | return wegsegmenten |
||
1040 | |||
1041 | def list_terreinobjecten_by_huisnummer(self, huisnummer): |
||
1042 | ''' |
||
1043 | List all `terreinobjecten` for a :class:`Huisnummer` |
||
1044 | |||
1045 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1046 | `terreinobjecten` are wanted. |
||
1047 | :rtype: A :class:`list` of :class:`Terreinobject` |
||
1048 | ''' |
||
1049 | try: |
||
1050 | id = huisnummer.id |
||
1051 | except AttributeError: |
||
1052 | id = huisnummer |
||
1053 | |||
1054 | def creator(): |
||
1055 | res = crab_gateway_request( |
||
1056 | self.client, 'ListTerreinobjectenByHuisnummerId', id |
||
1057 | ) |
||
1058 | try: |
||
1059 | return[ |
||
1060 | Terreinobject( |
||
1061 | r.IdentificatorTerreinobject, |
||
1062 | r.AardTerreinobject |
||
1063 | )for r in res.TerreinobjectItem |
||
1064 | ] |
||
1065 | except AttributeError: |
||
1066 | return [] |
||
1067 | if self.caches['short'].is_configured: |
||
1068 | key = 'ListTerreinobjectenByHuisnummerId#%s' % (id) |
||
1069 | terreinobjecten = self.caches['short'].get_or_create(key, creator) |
||
1070 | else: |
||
1071 | terreinobjecten = creator() |
||
1072 | for r in terreinobjecten: |
||
1073 | r.set_gateway(self) |
||
1074 | return terreinobjecten |
||
1075 | |||
1076 | View Code Duplication | def get_terreinobject_by_id(self, id): |
|
0 ignored issues
–
show
|
|||
1077 | ''' |
||
1078 | Retrieve a `Terreinobject` by the Id. |
||
1079 | |||
1080 | :param integer id: the Id of the `Terreinobject` |
||
1081 | :rtype: :class:`Terreinobject` |
||
1082 | ''' |
||
1083 | def creator(): |
||
1084 | res = crab_gateway_request( |
||
1085 | self.client, |
||
1086 | 'GetTerreinobjectByIdentificatorTerreinobject', id |
||
1087 | ) |
||
1088 | if res == None: |
||
1089 | raise GatewayResourceNotFoundException() |
||
1090 | return Terreinobject( |
||
1091 | res.IdentificatorTerreinobject, |
||
1092 | res.AardTerreinobject, |
||
1093 | (res.CenterX, res.CenterY), |
||
1094 | (res.MinimumX, res.MinimumY, res.MaximumX, res.MaximumY), |
||
1095 | Metadata( |
||
1096 | res.BeginDatum, |
||
1097 | res.BeginTijd, |
||
1098 | self.get_bewerking(res.BeginBewerking), |
||
1099 | self.get_organisatie(res.BeginOrganisatie) |
||
1100 | ) |
||
1101 | ) |
||
1102 | if self.caches['short'].is_configured: |
||
1103 | key = 'GetTerreinobjectByIdentificatorTerreinobject#%s' % (id) |
||
1104 | terreinobject = self.caches['short'].get_or_create(key, creator) |
||
1105 | else: |
||
1106 | terreinobject = creator() |
||
1107 | terreinobject.set_gateway(self) |
||
1108 | return terreinobject |
||
1109 | |||
1110 | def list_percelen_by_huisnummer(self, huisnummer): |
||
1111 | ''' |
||
1112 | List all `percelen` for a :class:`Huisnummer` |
||
1113 | |||
1114 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1115 | `percelen` are wanted. |
||
1116 | :rtype: A :class:`list` of :class:`Perceel` |
||
1117 | ''' |
||
1118 | try: |
||
1119 | id = huisnummer.id |
||
1120 | except AttributeError: |
||
1121 | id = huisnummer |
||
1122 | |||
1123 | def creator(): |
||
1124 | res = crab_gateway_request( |
||
1125 | self.client, 'ListPercelenByHuisnummerId', id |
||
1126 | ) |
||
1127 | try: |
||
1128 | return [ |
||
1129 | Perceel( |
||
1130 | r.IdentificatorPerceel |
||
1131 | )for r in res.PerceelItem |
||
1132 | ] |
||
1133 | except AttributeError: |
||
1134 | return [] |
||
1135 | if self.caches['short'].is_configured: |
||
1136 | key = 'ListPercelenByHuisnummerId#%s' % (id) |
||
1137 | percelen = self.caches['short'].get_or_create(key, creator) |
||
1138 | else: |
||
1139 | percelen = creator() |
||
1140 | for r in percelen: |
||
1141 | r.set_gateway(self) |
||
1142 | return percelen |
||
1143 | |||
1144 | View Code Duplication | def get_perceel_by_id(self, id): |
|
0 ignored issues
–
show
|
|||
1145 | ''' |
||
1146 | Retrieve a `Perceel` by the Id. |
||
1147 | |||
1148 | :param string id: the Id of the `Perceel` |
||
1149 | :rtype: :class:`Perceel` |
||
1150 | ''' |
||
1151 | def creator(): |
||
1152 | res = crab_gateway_request( |
||
1153 | self.client, 'GetPerceelByIdentificatorPerceel', id |
||
1154 | ) |
||
1155 | if res == None: |
||
1156 | raise GatewayResourceNotFoundException() |
||
1157 | return Perceel( |
||
1158 | res.IdentificatorPerceel, |
||
1159 | (res.CenterX, res.CenterY), |
||
1160 | Metadata( |
||
1161 | res.BeginDatum, |
||
1162 | res.BeginTijd, |
||
1163 | self.get_bewerking(res.BeginBewerking), |
||
1164 | self.get_organisatie(res.BeginOrganisatie) |
||
1165 | ) |
||
1166 | ) |
||
1167 | if self.caches['short'].is_configured: |
||
1168 | key = 'GetPerceelByIdentificatorPerceel#%s' % (id) |
||
1169 | perceel = self.caches['short'].get_or_create(key, creator) |
||
1170 | else: |
||
1171 | perceel = creator() |
||
1172 | perceel.set_gateway(self) |
||
1173 | return perceel |
||
1174 | |||
1175 | def list_gebouwen_by_huisnummer(self, huisnummer): |
||
1176 | ''' |
||
1177 | List all `gebouwen` for a :class:`Huisnummer`. |
||
1178 | |||
1179 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1180 | `gebouwen` are wanted. |
||
1181 | :rtype: A :class:`list` of :class:`Gebouw` |
||
1182 | ''' |
||
1183 | try: |
||
1184 | id = huisnummer.id |
||
1185 | except AttributeError: |
||
1186 | id = huisnummer |
||
1187 | |||
1188 | def creator(): |
||
1189 | res = crab_gateway_request( |
||
1190 | self.client, 'ListGebouwenByHuisnummerId', id |
||
1191 | ) |
||
1192 | try: |
||
1193 | return [ |
||
1194 | Gebouw( |
||
1195 | r.IdentificatorGebouw, |
||
1196 | r.AardGebouw, |
||
1197 | r.StatusGebouw |
||
1198 | )for r in res.GebouwItem |
||
1199 | ] |
||
1200 | except AttributeError: |
||
1201 | return [] |
||
1202 | if self.caches['short'].is_configured: |
||
1203 | key = 'ListGebouwenByHuisnummerId#%s' % (id) |
||
1204 | gebouwen = self.caches['short'].get_or_create(key, creator) |
||
1205 | else: |
||
1206 | gebouwen = creator() |
||
1207 | for r in gebouwen: |
||
1208 | r.set_gateway(self) |
||
1209 | return gebouwen |
||
1210 | |||
1211 | def get_gebouw_by_id(self, id): |
||
1212 | ''' |
||
1213 | Retrieve a `Gebouw` by the Id. |
||
1214 | |||
1215 | :param integer id: the Id of the `Gebouw` |
||
1216 | :rtype: :class:`Gebouw` |
||
1217 | ''' |
||
1218 | def creator(): |
||
1219 | res = crab_gateway_request( |
||
1220 | self.client, 'GetGebouwByIdentificatorGebouw', id |
||
1221 | ) |
||
1222 | if res == None: |
||
1223 | raise GatewayResourceNotFoundException() |
||
1224 | return Gebouw( |
||
1225 | res.IdentificatorGebouw, |
||
1226 | res.AardGebouw, |
||
1227 | res.StatusGebouw, |
||
1228 | res.GeometriemethodeGebouw, |
||
1229 | res.Geometrie, |
||
1230 | Metadata( |
||
1231 | res.BeginDatum, |
||
1232 | res.BeginTijd, |
||
1233 | self.get_bewerking(res.BeginBewerking), |
||
1234 | self.get_organisatie(res.BeginOrganisatie) |
||
1235 | ) |
||
1236 | ) |
||
1237 | if self.caches['short'].is_configured: |
||
1238 | key = 'GetGebouwByIdentificatorGebouw#%s' % (id) |
||
1239 | gebouw = self.caches['short'].get_or_create(key, creator) |
||
1240 | else: |
||
1241 | gebouw = creator() |
||
1242 | gebouw.set_gateway(self) |
||
1243 | return gebouw |
||
1244 | |||
1245 | def get_bewerking(self, res): |
||
1246 | r = self.list_bewerkingen() |
||
1247 | for item in r: |
||
1248 | if int(item.id) == int(res): |
||
1249 | return item |
||
1250 | |||
1251 | def get_organisatie(self, res): |
||
1252 | r = self.list_organisaties() |
||
1253 | for item in r: |
||
1254 | if int(item.id) == int(res): |
||
1255 | return item |
||
1256 | |||
1257 | def list_subadressen_by_huisnummer(self, huisnummer): |
||
1258 | ''' |
||
1259 | List all `subadressen` for a :class:`Huisnummer`. |
||
1260 | |||
1261 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1262 | `subadressen` are wanted. OR A huisnummer id. |
||
1263 | :rtype: A :class:`list` of :class:`Gebouw` |
||
1264 | ''' |
||
1265 | try: |
||
1266 | id = huisnummer.id |
||
1267 | except AttributeError: |
||
1268 | id = huisnummer |
||
1269 | |||
1270 | def creator(): |
||
1271 | res = crab_gateway_request( |
||
1272 | self.client, 'ListSubadressenWithStatusByHuisnummerId', id |
||
1273 | ) |
||
1274 | try: |
||
1275 | return [ Subadres( |
||
1276 | r.SubadresId, |
||
1277 | r.Subadres, |
||
1278 | r.StatusSubadres |
||
1279 | )for r in res.SubadresWithStatusItem ] |
||
1280 | except AttributeError: |
||
1281 | return [] |
||
1282 | if self.caches['short'].is_configured: |
||
1283 | key = 'ListSubadressenWithStatusByHuisnummerId#%s' % (id) |
||
1284 | subadressen = self.caches['short'].get_or_create(key, creator) |
||
1285 | else: |
||
1286 | subadressen = creator() |
||
1287 | for s in subadressen: |
||
1288 | s.set_gateway(self) |
||
1289 | return subadressen |
||
1290 | |||
1291 | def get_subadres_by_id(self, id): |
||
1292 | ''' |
||
1293 | Retrieve a `Subadres` by the Id. |
||
1294 | |||
1295 | :param integer id: the Id of the `Subadres` |
||
1296 | :rtype: :class:`Subadres` |
||
1297 | ''' |
||
1298 | def creator(): |
||
1299 | res = crab_gateway_request( |
||
1300 | self.client, 'GetSubadresWithStatusBySubadresId', id |
||
1301 | ) |
||
1302 | if res == None: |
||
1303 | raise GatewayResourceNotFoundException() |
||
1304 | return Subadres( |
||
1305 | res.SubadresId, |
||
1306 | res.Subadres, |
||
1307 | res.StatusSubadres, |
||
1308 | res.HuisnummerId, |
||
1309 | res.AardSubadres, |
||
1310 | Metadata( |
||
1311 | res.BeginDatum, |
||
1312 | res.BeginTijd, |
||
1313 | self.get_bewerking(res.BeginBewerking), |
||
1314 | self.get_organisatie(res.BeginOrganisatie) |
||
1315 | ) |
||
1316 | ) |
||
1317 | if self.caches['short'].is_configured: |
||
1318 | key = 'GetSubadresWithStatusBySubadresId#%s' % (id) |
||
1319 | subadres = self.caches['short'].get_or_create(key, creator) |
||
1320 | else: |
||
1321 | subadres = creator() |
||
1322 | subadres.set_gateway(self) |
||
1323 | return subadres |
||
1324 | |||
1325 | def list_adresposities_by_huisnummer(self, huisnummer): |
||
1326 | ''' |
||
1327 | List all `adresposities` for a :class:`Huisnummer`. |
||
1328 | |||
1329 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1330 | `adresposities` are wanted. OR A huisnummer id. |
||
1331 | :rtype: A :class:`list` of :class:`Adrespositie` |
||
1332 | ''' |
||
1333 | try: |
||
1334 | id = huisnummer.id |
||
1335 | except AttributeError: |
||
1336 | id = huisnummer |
||
1337 | def creator(): |
||
1338 | res = crab_gateway_request( |
||
1339 | self.client, 'ListAdrespositiesByHuisnummerId', id |
||
1340 | ) |
||
1341 | try: |
||
1342 | return [Adrespositie( |
||
1343 | r.AdrespositieId, |
||
1344 | r.HerkomstAdrespositie |
||
1345 | ) for r in res.AdrespositieItem] |
||
1346 | except AttributeError: |
||
1347 | return [] |
||
1348 | if self.caches['short'].is_configured: |
||
1349 | key = 'ListAdrespositiesByHuisnummerId#%s' % (id) |
||
1350 | adresposities = self.caches['short'].get_or_create(key, creator) |
||
1351 | else: |
||
1352 | adresposities = creator() |
||
1353 | for a in adresposities: |
||
1354 | a.set_gateway(self) |
||
1355 | return adresposities |
||
1356 | |||
1357 | View Code Duplication | def list_adresposities_by_nummer_and_straat(self, nummer, straat): |
|
0 ignored issues
–
show
|
|||
1358 | ''' |
||
1359 | List all `adresposities` for a huisnummer and a :class:`Straat`. |
||
1360 | |||
1361 | :param nummer: A string representing a certain huisnummer. |
||
1362 | :param straat: The :class:`Straat` for which the \ |
||
1363 | `adresposities` are wanted. OR A straat id. |
||
1364 | :rtype: A :class:`list` of :class:`Adrespositie` |
||
1365 | ''' |
||
1366 | try: |
||
1367 | sid = straat.id |
||
1368 | except AttributeError: |
||
1369 | sid = straat |
||
1370 | def creator(): |
||
1371 | res = crab_gateway_request( |
||
1372 | self.client, 'ListAdrespositiesByHuisnummer', nummer, sid |
||
1373 | ) |
||
1374 | try: |
||
1375 | return [Adrespositie( |
||
1376 | r.AdrespositieId, |
||
1377 | r.HerkomstAdrespositie |
||
1378 | )for r in res.AdrespositieItem] |
||
1379 | except AttributeError: |
||
1380 | return [] |
||
1381 | if self.caches['short'].is_configured: |
||
1382 | key = 'ListAdrespositiesByHuisnummer#%s%s' % (nummer, sid) |
||
1383 | adresposities = self.caches['short'].get_or_create(key, creator) |
||
1384 | else: |
||
1385 | adresposities = creator() |
||
1386 | for a in adresposities: |
||
1387 | a.set_gateway(self) |
||
1388 | return adresposities |
||
1389 | |||
1390 | def list_adresposities_by_subadres(self, subadres): |
||
1391 | ''' |
||
1392 | List all `adresposities` for a :class:`Subadres`. |
||
1393 | |||
1394 | :param subadres: The :class:`Subadres` for which the \ |
||
1395 | `adresposities` are wanted. OR A subadres id. |
||
1396 | :rtype: A :class:`list` of :class:`Adrespositie` |
||
1397 | ''' |
||
1398 | try: |
||
1399 | id = subadres.id |
||
1400 | except AttributeError: |
||
1401 | id = subadres |
||
1402 | def creator(): |
||
1403 | res = crab_gateway_request( |
||
1404 | self.client, 'ListAdrespositiesBySubadresId', id |
||
1405 | ) |
||
1406 | try: |
||
1407 | return [Adrespositie( |
||
1408 | r.AdrespositieId, |
||
1409 | r.HerkomstAdrespositie |
||
1410 | )for r in res.AdrespositieItem] |
||
1411 | except AttributeError: |
||
1412 | return [] |
||
1413 | if self.caches['short'].is_configured: |
||
1414 | key = 'ListAdrespositiesBySubadresId#%s' % (id) |
||
1415 | adresposities = self.caches['short'].get_or_create(key, creator) |
||
1416 | else: |
||
1417 | adresposities = creator() |
||
1418 | for a in adresposities: |
||
1419 | a.set_gateway(self) |
||
1420 | return adresposities |
||
1421 | |||
1422 | View Code Duplication | def list_adresposities_by_subadres_and_huisnummer(self, subadres, huisnummer): |
|
0 ignored issues
–
show
|
|||
1423 | ''' |
||
1424 | List all `adresposities` for a subadres and a :class:`Huisnummer`. |
||
1425 | |||
1426 | :param subadres: A string representing a certain subadres. |
||
1427 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1428 | `adresposities` are wanted. OR A huisnummer id. |
||
1429 | :rtype: A :class:`list` of :class:`Adrespositie` |
||
1430 | ''' |
||
1431 | try: |
||
1432 | hid = huisnummer.id |
||
1433 | except AttributeError: |
||
1434 | hid = huisnummer |
||
1435 | def creator(): |
||
1436 | res = crab_gateway_request( |
||
1437 | self.client, 'ListAdrespositiesBySubadres', subadres, hid |
||
1438 | ) |
||
1439 | try: |
||
1440 | return [Adrespositie( |
||
1441 | r.AdrespositieId, |
||
1442 | r.HerkomstAdrespositie |
||
1443 | )for r in res.AdrespositieItem] |
||
1444 | except AttributeError: |
||
1445 | return [] |
||
1446 | if self.caches['short'].is_configured: |
||
1447 | key = 'ListAdrespositiesBySubadres#%s%s' % (subadres, hid) |
||
1448 | adresposities = self.caches['short'].get_or_create(key, creator) |
||
1449 | else: |
||
1450 | adresposities = creator() |
||
1451 | for a in adresposities: |
||
1452 | a.set_gateway(self) |
||
1453 | return adresposities |
||
1454 | |||
1455 | def get_adrespositie_by_id(self, id): |
||
1456 | ''' |
||
1457 | Retrieve a `Adrespositie` by the Id. |
||
1458 | |||
1459 | :param integer id: the Id of the `Adrespositie` |
||
1460 | :rtype: :class:`Adrespositie` |
||
1461 | ''' |
||
1462 | def creator(): |
||
1463 | res = crab_gateway_request( |
||
1464 | self.client, 'GetAdrespositieByAdrespositieId', id |
||
1465 | ) |
||
1466 | if res == None: |
||
1467 | raise GatewayResourceNotFoundException() |
||
1468 | return Adrespositie( |
||
1469 | res.AdrespositieId, |
||
1470 | res.HerkomstAdrespositie, |
||
1471 | res.Geometrie, |
||
1472 | res.AardAdres, |
||
1473 | Metadata( |
||
1474 | res.BeginDatum, |
||
1475 | res.BeginTijd, |
||
1476 | self.get_bewerking(res.BeginBewerking), |
||
1477 | self.get_organisatie(res.BeginOrganisatie) |
||
1478 | ) |
||
1479 | ) |
||
1480 | if self.caches['short'].is_configured: |
||
1481 | key = 'GetAdrespositieByAdrespositieId#%s' % (id) |
||
1482 | adrespositie = self.caches['short'].get_or_create(key, creator) |
||
1483 | else: |
||
1484 | adrespositie = creator() |
||
1485 | adrespositie.set_gateway(self) |
||
1486 | return adrespositie |
||
1487 | |||
1488 | View Code Duplication | def get_postadres_by_huisnummer(self, huisnummer): |
|
0 ignored issues
–
show
|
|||
1489 | ''' |
||
1490 | Get the `postadres` for a :class:`Huisnummer`. |
||
1491 | |||
1492 | :param huisnummer: The :class:`Huisnummer` for which the \ |
||
1493 | `postadres` is wanted. OR A huisnummer id. |
||
1494 | :rtype: A :class:`str`. |
||
1495 | ''' |
||
1496 | try: |
||
1497 | id = huisnummer.id |
||
1498 | except AttributeError: |
||
1499 | id = huisnummer |
||
1500 | def creator(): |
||
1501 | res = crab_gateway_request( |
||
1502 | self.client, 'GetPostadresByHuisnummerId', id |
||
1503 | ) |
||
1504 | if res == None: |
||
1505 | raise GatewayResourceNotFoundException() |
||
1506 | return res.Postadres |
||
1507 | if self.caches['short'].is_configured: |
||
1508 | key = 'GetPostadresByHuisnummerId#%s' % (id) |
||
1509 | postadres = self.caches['short'].get_or_create(key, creator) |
||
1510 | else: |
||
1511 | postadres = creator() |
||
1512 | return postadres |
||
1513 | |||
1514 | View Code Duplication | def get_postadres_by_subadres(self, subadres): |
|
0 ignored issues
–
show
|
|||
1515 | ''' |
||
1516 | Get the `postadres` for a :class:`Subadres`. |
||
1517 | |||
1518 | :param subadres: The :class:`Subadres` for which the \ |
||
1519 | `postadres` is wanted. OR A subadres id. |
||
1520 | :rtype: A :class:`str`. |
||
1521 | ''' |
||
1522 | try: |
||
1523 | id = subadres.id |
||
1524 | except AttributeError: |
||
1525 | id = subadres |
||
1526 | def creator(): |
||
1527 | res = crab_gateway_request( |
||
1528 | self.client, 'GetPostadresBySubadresId', id |
||
1529 | ) |
||
1530 | if res == None: |
||
1531 | raise GatewayResourceNotFoundException() |
||
1532 | return res.Postadres |
||
1533 | if self.caches['short'].is_configured: |
||
1534 | key = 'GetPostadresBySubadresId#%s' % (id) |
||
1535 | postadres = self.caches['short'].get_or_create(key, creator) |
||
1536 | else: |
||
1537 | postadres = creator() |
||
1538 | return postadres |
||
1539 | |||
1540 | |||
1541 | View Code Duplication | class GatewayObject(object): |
|
0 ignored issues
–
show
|
|||
1542 | ''' |
||
1543 | Abstract class for objects that are able to use a |
||
1544 | :class:`crabpy.Gateway.CrabGateway` to find further information. |
||
1545 | ''' |
||
1546 | |||
1547 | gateway = None |
||
1548 | ''' |
||
1549 | The :class:`crabpy.gateway.crab.CrabGateway` to use when making |
||
1550 | further calls to the CRAB service. |
||
1551 | ''' |
||
1552 | |||
1553 | def __init__(self, **kwargs): |
||
1554 | if 'gateway' in kwargs: |
||
1555 | self.set_gateway(kwargs['gateway']) |
||
1556 | |||
1557 | def set_gateway(self, gateway): |
||
1558 | ''' |
||
1559 | :param crabpy.gateway.crab.CrabGateway gateway: Gateway to use. |
||
1560 | ''' |
||
1561 | self.gateway = gateway |
||
1562 | |||
1563 | def clear_gateway(self): |
||
1564 | ''' |
||
1565 | Clear the currently set CrabGateway. |
||
1566 | ''' |
||
1567 | self.gateway = None |
||
1568 | |||
1569 | def check_gateway(self): |
||
1570 | ''' |
||
1571 | Check to see if a gateway was set on this object. |
||
1572 | ''' |
||
1573 | if not self.gateway: |
||
1574 | raise RuntimeError("There's no Gateway I can use") |
||
1575 | |||
1576 | if six.PY2: |
||
1577 | def __str__(self): |
||
1578 | return self.__unicode__().encode('utf-8') |
||
1579 | else: |
||
1580 | def __str__(self): |
||
1581 | return self.__unicode__() |
||
1582 | |||
1583 | |||
1584 | def check_lazy_load_gewest(f): |
||
1585 | ''' |
||
1586 | Decorator function to lazy load a :class:`Gewest`. |
||
1587 | ''' |
||
1588 | def wrapper(self): |
||
1589 | gewest = self |
||
1590 | attribute = 'namen' if f.__name__ == 'naam' else f.__name__ |
||
1591 | if (getattr(gewest, '_%s' % attribute, None) is None): |
||
1592 | log.debug('Lazy loading Gewest %d', gewest.id) |
||
1593 | gewest.check_gateway() |
||
1594 | g = gewest.gateway.get_gewest_by_id(gewest.id) |
||
1595 | gewest._namen = g._namen |
||
1596 | gewest._centroid = g._centroid |
||
1597 | gewest._bounding_box = g._bounding_box |
||
1598 | return f(self) |
||
1599 | return wrapper |
||
1600 | |||
1601 | |||
1602 | class Gewest(GatewayObject): |
||
1603 | ''' |
||
1604 | A large administrative unit in Belgium. |
||
1605 | |||
1606 | Belgium consists of 3 `gewesten`. Together they form the entire territory |
||
1607 | of the country. |
||
1608 | ''' |
||
1609 | def __init__( |
||
1610 | self, |
||
1611 | id, |
||
1612 | namen=None, |
||
1613 | centroid=None, |
||
1614 | bounding_box=None, |
||
1615 | **kwargs |
||
1616 | ): |
||
1617 | self.id = int(id) |
||
1618 | self._namen = namen |
||
1619 | self._centroid = centroid |
||
1620 | self._bounding_box = bounding_box |
||
1621 | super(Gewest, self).__init__(**kwargs) |
||
1622 | |||
1623 | @property |
||
1624 | @check_lazy_load_gewest |
||
1625 | def naam(self): |
||
1626 | return self._namen['nl'] |
||
1627 | |||
1628 | @property |
||
1629 | @check_lazy_load_gewest |
||
1630 | def centroid(self): |
||
1631 | return self._centroid |
||
1632 | |||
1633 | @property |
||
1634 | @check_lazy_load_gewest |
||
1635 | def bounding_box(self): |
||
1636 | return self._bounding_box |
||
1637 | |||
1638 | @property |
||
1639 | def provincies(self): |
||
1640 | return self.gateway.list_provincies(self.id) |
||
1641 | |||
1642 | @property |
||
1643 | def gemeenten(self): |
||
1644 | return self.gateway.list_gemeenten(self.id) |
||
1645 | |||
1646 | def __unicode__(self): |
||
1647 | if self._namen is not None: |
||
1648 | return "%s (%s)" % (self.naam, self.id) |
||
1649 | else: |
||
1650 | return "Gewest %s" % (self.id) |
||
1651 | |||
1652 | def __repr__(self): |
||
1653 | return "Gewest(%s)" % (self.id) |
||
1654 | |||
1655 | |||
1656 | class Provincie(GatewayObject): |
||
1657 | ''' |
||
1658 | The largest administrative unit within a :class:`Gewest`. |
||
1659 | |||
1660 | .. versionadded:: 0.4.0 |
||
1661 | ''' |
||
1662 | def __init__( |
||
1663 | self, niscode, naam, gewest, **kwargs |
||
1664 | ): |
||
1665 | self.id = self.niscode = int(niscode) |
||
1666 | self.naam = naam |
||
1667 | self.gewest = gewest |
||
1668 | |||
1669 | def set_gateway(self, gateway): |
||
1670 | ''' |
||
1671 | :param crabpy.gateway.crab.CrabGateway gateway: Gateway to use. |
||
1672 | ''' |
||
1673 | self.gateway = gateway |
||
1674 | self.gewest.gateway = gateway |
||
1675 | |||
1676 | def clear_gateway(self): |
||
1677 | ''' |
||
1678 | Clear the currently set CrabGateway. |
||
1679 | ''' |
||
1680 | self.gateway = None |
||
1681 | self.gewest.clear_gateway() |
||
1682 | |||
1683 | @property |
||
1684 | def gemeenten(self): |
||
1685 | self.check_gateway() |
||
1686 | return self.gateway.list_gemeenten_by_provincie(self.niscode) |
||
1687 | |||
1688 | def __unicode__(self): |
||
1689 | return "%s (%s)" % (self.naam, self.niscode) |
||
1690 | |||
1691 | def __repr__(self): |
||
1692 | return "Provincie(%s, '%s', Gewest(%s))" % (self.niscode, self.naam, self.gewest.id) |
||
1693 | |||
1694 | |||
1695 | def check_lazy_load_gemeente(f): |
||
1696 | ''' |
||
1697 | Decorator function to lazy load a :class:`Gemeente`. |
||
1698 | ''' |
||
1699 | def wrapper(*args): |
||
1700 | gemeente = args[0] |
||
1701 | if ( |
||
1702 | gemeente._centroid is None or gemeente._bounding_box is None |
||
1703 | or gemeente._taal_id is None or gemeente._metadata is None |
||
1704 | ): |
||
1705 | log.debug('Lazy loading Gemeente %d', gemeente.id) |
||
1706 | gemeente.check_gateway() |
||
1707 | g = gemeente.gateway.get_gemeente_by_id(gemeente.id) |
||
1708 | gemeente._taal_id = g._taal_id |
||
1709 | gemeente._centroid = g._centroid |
||
1710 | gemeente._bounding_box = g._bounding_box |
||
1711 | gemeente._metadata = g._metadata |
||
1712 | return f(*args) |
||
1713 | return wrapper |
||
1714 | |||
1715 | |||
1716 | class Gemeente(GatewayObject): |
||
1717 | ''' |
||
1718 | The smallest administrative unit in Belgium. |
||
1719 | ''' |
||
1720 | def __init__( |
||
1721 | self, id, naam, niscode, gewest, |
||
1722 | taal=None, centroid=None, |
||
1723 | bounding_box=None, metadata=None, **kwargs |
||
1724 | ): |
||
1725 | self.id = int(id) |
||
1726 | self.naam = naam |
||
1727 | self.niscode = niscode |
||
1728 | self.gewest = gewest |
||
1729 | try: |
||
1730 | self._taal_id = taal.id |
||
1731 | self._taal = taal |
||
1732 | except AttributeError: |
||
1733 | self._taal_id = taal |
||
1734 | self._taal = None |
||
1735 | self._centroid = centroid |
||
1736 | self._bounding_box = bounding_box |
||
1737 | self._metadata = metadata |
||
1738 | super(Gemeente, self).__init__(**kwargs) |
||
1739 | |||
1740 | def set_gateway(self, gateway): |
||
1741 | ''' |
||
1742 | :param crabpy.gateway.crab.CrabGateway gateway: Gateway to use. |
||
1743 | ''' |
||
1744 | self.gateway = gateway |
||
1745 | self.gewest.set_gateway(gateway) |
||
1746 | |||
1747 | def clear_gateway(self): |
||
1748 | ''' |
||
1749 | Clear the currently set CrabGateway. |
||
1750 | ''' |
||
1751 | self.gateway = None |
||
1752 | self.gewest.clear_gateway() |
||
1753 | |||
1754 | @property |
||
1755 | @check_lazy_load_gemeente |
||
1756 | def taal(self): |
||
1757 | if self._taal is None: |
||
1758 | talen = self.gateway.list_talen() |
||
1759 | for taal in talen: |
||
1760 | if taal.id == self._taal_id: |
||
1761 | self._taal = taal |
||
1762 | return self._taal |
||
1763 | |||
1764 | @property |
||
1765 | @check_lazy_load_gemeente |
||
1766 | def centroid(self): |
||
1767 | return self._centroid |
||
1768 | |||
1769 | @property |
||
1770 | @check_lazy_load_gemeente |
||
1771 | def bounding_box(self): |
||
1772 | return self._bounding_box |
||
1773 | |||
1774 | @property |
||
1775 | @check_lazy_load_gemeente |
||
1776 | def metadata(self): |
||
1777 | return self._metadata |
||
1778 | |||
1779 | @property |
||
1780 | def straten(self): |
||
1781 | self.check_gateway() |
||
1782 | return self.gateway.list_straten(self) |
||
1783 | |||
1784 | @property |
||
1785 | def postkantons(self): |
||
1786 | self.check_gateway() |
||
1787 | return self.gateway.list_postkantons_by_gemeente(self.id) |
||
1788 | |||
1789 | @property |
||
1790 | def provincie(self): |
||
1791 | self.check_gateway() |
||
1792 | provincies = self.gateway.list_provincies(self.gewest) |
||
1793 | for p in provincies: |
||
1794 | if math.floor(self.niscode / 10000) == math.floor(p.niscode / 10000): |
||
1795 | return p |
||
1796 | |||
1797 | def __unicode__(self): |
||
1798 | return "%s (%s)" % (self.naam, self.id) |
||
1799 | |||
1800 | def __repr__(self): |
||
1801 | return "Gemeente(%s, '%s', %s)" % (self.id, self.naam, self.niscode) |
||
1802 | |||
1803 | |||
1804 | class Deelgemeente(GatewayObject): |
||
1805 | ''' |
||
1806 | A subdivision of a :class:`Gemeente`. |
||
1807 | |||
1808 | .. versionadded:: 0.7.0 |
||
1809 | ''' |
||
1810 | def __init__( |
||
1811 | self, id, naam, gemeente_niscode, **kwargs |
||
1812 | ): |
||
1813 | self.id = id |
||
1814 | self.naam = naam |
||
1815 | self.gemeente_niscode = gemeente_niscode |
||
1816 | |||
1817 | def set_gateway(self, gateway): |
||
1818 | ''' |
||
1819 | :param crabpy.gateway.crab.CrabGateway gateway: Gateway to use. |
||
1820 | ''' |
||
1821 | self.gateway = gateway |
||
1822 | |||
1823 | def clear_gateway(self): |
||
1824 | ''' |
||
1825 | Clear the currently set CrabGateway. |
||
1826 | ''' |
||
1827 | self.gateway = None |
||
1828 | |||
1829 | @property |
||
1830 | def gemeente(self): |
||
1831 | return self.gateway.get_gemeente_by_niscode(self.gemeente_niscode) |
||
1832 | |||
1833 | def __unicode__(self): |
||
1834 | return "%s (%s)" % (self.naam, self.id) |
||
1835 | |||
1836 | def __repr__(self): |
||
1837 | return "Deelgemeente('%s', '%s', %s)" % (self.id, self.naam, self.gemeente_niscode) |
||
1838 | |||
1839 | |||
1840 | class Codelijst(GatewayObject): |
||
1841 | def __init__( |
||
1842 | self, id, naam, definitie, **kwargs |
||
1843 | ): |
||
1844 | self.id = id |
||
1845 | self.naam = naam |
||
1846 | self.definitie = definitie |
||
1847 | super(Codelijst, self).__init__(**kwargs) |
||
1848 | |||
1849 | def __unicode__(self): |
||
1850 | return self.naam |
||
1851 | |||
1852 | |||
1853 | class Taal(Codelijst): |
||
1854 | ''' |
||
1855 | A language. |
||
1856 | ''' |
||
1857 | def __repr__(self): |
||
1858 | return "Taal('%s', '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1859 | |||
1860 | |||
1861 | class Bewerking(Codelijst): |
||
1862 | ''' |
||
1863 | An edit. |
||
1864 | ''' |
||
1865 | def __repr__(self): |
||
1866 | return "Bewerking(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1867 | |||
1868 | |||
1869 | class Organisatie(Codelijst): |
||
1870 | ''' |
||
1871 | An organisation that played a role in the genessis of an object. |
||
1872 | ''' |
||
1873 | def __repr__(self): |
||
1874 | return "Organisatie(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1875 | |||
1876 | |||
1877 | class Aardsubadres(Codelijst): |
||
1878 | ''' |
||
1879 | The nature of a subaddress. |
||
1880 | ''' |
||
1881 | def __repr__(self): |
||
1882 | return "Aardsubadres(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1883 | |||
1884 | |||
1885 | class Aardadres(Codelijst): |
||
1886 | ''' |
||
1887 | The nature of an address. |
||
1888 | ''' |
||
1889 | def __repr__(self): |
||
1890 | return "Aardadres(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1891 | |||
1892 | |||
1893 | class Aardgebouw(Codelijst): |
||
1894 | ''' |
||
1895 | The nature of a building. |
||
1896 | ''' |
||
1897 | def __repr__(self): |
||
1898 | return "Aardgebouw(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1899 | |||
1900 | |||
1901 | class Aardwegobject(Codelijst): |
||
1902 | ''' |
||
1903 | The nature of a `wegobject`. |
||
1904 | ''' |
||
1905 | def __repr__(self): |
||
1906 | return "Aardwegobject(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1907 | |||
1908 | |||
1909 | class Aardterreinobject(Codelijst): |
||
1910 | ''' |
||
1911 | The nature of a `terreinobject`. |
||
1912 | ''' |
||
1913 | def __repr__(self): |
||
1914 | return "Aardterreinobject(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1915 | |||
1916 | |||
1917 | class Statushuisnummer(Codelijst): |
||
1918 | ''' |
||
1919 | The current state of a `huisnummer`. |
||
1920 | ''' |
||
1921 | def __repr__(self): |
||
1922 | return "Statushuisnummer(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1923 | |||
1924 | |||
1925 | class Statussubadres(Codelijst): |
||
1926 | ''' |
||
1927 | The current state of a `subadres`. |
||
1928 | ''' |
||
1929 | def __repr__(self): |
||
1930 | return "Statussubadres(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1931 | |||
1932 | |||
1933 | class Statusstraatnaam(Codelijst): |
||
1934 | ''' |
||
1935 | The current state of a `straatnaam`. |
||
1936 | ''' |
||
1937 | def __repr__(self): |
||
1938 | return "Statusstraatnaam(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1939 | |||
1940 | |||
1941 | class Statuswegsegment(Codelijst): |
||
1942 | ''' |
||
1943 | The current state of a `wegsegment`. |
||
1944 | ''' |
||
1945 | def __repr__(self): |
||
1946 | return "Statuswegsegment(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1947 | |||
1948 | |||
1949 | class Geometriemethodewegsegment(Codelijst): |
||
1950 | ''' |
||
1951 | The geometry method of a :class:`Wegsegment`. |
||
1952 | ''' |
||
1953 | def __repr__(self): |
||
1954 | return "Geometriemethodewegsegment(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1955 | |||
1956 | |||
1957 | class Statusgebouw(Codelijst): |
||
1958 | ''' |
||
1959 | The current state of a :class:`Gebouw`. |
||
1960 | ''' |
||
1961 | def __repr__(self): |
||
1962 | return "Statusgebouw(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1963 | |||
1964 | |||
1965 | class Geometriemethodegebouw(Codelijst): |
||
1966 | ''' |
||
1967 | The geometry method of a :class:`Gebouw`. |
||
1968 | ''' |
||
1969 | def __repr__(self): |
||
1970 | return "Geometriemethodegebouw(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1971 | |||
1972 | |||
1973 | class Herkomstadrespositie(Codelijst): |
||
1974 | ''' |
||
1975 | The origin of an Adressposition. |
||
1976 | ''' |
||
1977 | def __repr__(self): |
||
1978 | return "Herkomstadrespositie(%s, '%s', '%s')" % (self.id, self.naam, self.definitie) |
||
1979 | |||
1980 | |||
1981 | def check_lazy_load_straat(f): |
||
1982 | ''' |
||
1983 | Decorator function to lazy load a :class:`Straat`. |
||
1984 | ''' |
||
1985 | def wrapper(*args): |
||
1986 | straat = args[0] |
||
1987 | if ( |
||
1988 | straat._namen is None or straat._metadata is None |
||
1989 | ): |
||
1990 | log.debug('Lazy loading Straat %d', straat.id) |
||
1991 | straat.check_gateway() |
||
1992 | s = straat.gateway.get_straat_by_id(straat.id) |
||
1993 | straat._namen = s._namen |
||
1994 | straat._metadata = s._metadata |
||
1995 | return f(*args) |
||
1996 | return wrapper |
||
1997 | |||
1998 | |||
1999 | class Straat(GatewayObject): |
||
2000 | ''' |
||
2001 | A street. |
||
2002 | |||
2003 | A street object is always located in one and exactly one :class:`Gemeente`. |
||
2004 | ''' |
||
2005 | def __init__( |
||
2006 | self, id, label, gemeente_id, status, |
||
2007 | straatnaam=None, taalcode=None, |
||
2008 | straatnaam2=None, taalcode2=None, |
||
2009 | metadata=None, **kwargs |
||
2010 | ): |
||
2011 | self.id = id |
||
2012 | self.label = label |
||
2013 | try: |
||
2014 | self.status_id = status.id |
||
2015 | self._status = status |
||
2016 | except: |
||
2017 | self.status_id = status |
||
2018 | self._status = None |
||
2019 | self._namen = ((straatnaam, taalcode), (straatnaam2, taalcode2)) |
||
2020 | self.gemeente_id = gemeente_id |
||
2021 | self._metadata = metadata |
||
2022 | super(Straat, self).__init__(**kwargs) |
||
2023 | |||
2024 | @property |
||
2025 | @check_lazy_load_straat |
||
2026 | def namen(self): |
||
2027 | return self._namen |
||
2028 | |||
2029 | @property |
||
2030 | def gemeente(self): |
||
2031 | return self.gateway.get_gemeente_by_id(self.gemeente_id) |
||
2032 | |||
2033 | @property |
||
2034 | def status(self): |
||
2035 | if self._status is None: |
||
2036 | res = self.gateway.list_statusstraatnamen() |
||
2037 | for status in res: |
||
2038 | if int(status.id) == int(self.status_id): |
||
2039 | self._status = status |
||
2040 | return self._status |
||
2041 | |||
2042 | @property |
||
2043 | @check_lazy_load_straat |
||
2044 | def metadata(self): |
||
2045 | return self._metadata |
||
2046 | |||
2047 | @property |
||
2048 | def huisnummers(self): |
||
2049 | self.check_gateway() |
||
2050 | return self.gateway.list_huisnummers_by_straat(self) |
||
2051 | |||
2052 | @property |
||
2053 | @check_lazy_load_straat |
||
2054 | def taal(self): |
||
2055 | return self.gemeente.taal |
||
2056 | |||
2057 | @property |
||
2058 | def wegobjecten(self): |
||
2059 | self.check_gateway() |
||
2060 | return self.gateway.list_wegobjecten_by_straat(self) |
||
2061 | |||
2062 | @property |
||
2063 | def wegsegmenten(self): |
||
2064 | self.check_gateway() |
||
2065 | return self.gateway.list_wegsegmenten_by_straat(self) |
||
2066 | |||
2067 | @property |
||
2068 | def bounding_box(self): |
||
2069 | weg = [x.geometrie for x in self.wegsegmenten] |
||
2070 | if weg == []: |
||
2071 | return None |
||
2072 | x = [] |
||
2073 | y = [] |
||
2074 | for a in weg: |
||
2075 | a = a.replace("LINESTRING (", "").replace(")", "") |
||
2076 | list = a.split(',') |
||
2077 | for z in list: |
||
2078 | temp = z.split() |
||
2079 | x.append(temp[0]) |
||
2080 | y.append(temp[1]) |
||
2081 | return [min(x), min(y), max(x), max(y)] |
||
2082 | |||
2083 | def __unicode__(self): |
||
2084 | return "%s (%s)" % (self.label, self.id) |
||
2085 | |||
2086 | def __repr__(self): |
||
2087 | return "Straat(%s, '%s', %s, %s)" % (self.id, self.label, self.gemeente_id, self.status_id) |
||
2088 | |||
2089 | |||
2090 | def check_lazy_load_huisnummer(f): |
||
2091 | ''' |
||
2092 | Decorator function to lazy load a :class:`Huisnummer`. |
||
2093 | ''' |
||
2094 | def wrapper(*args): |
||
2095 | huisnummer = args[0] |
||
2096 | if ( |
||
2097 | huisnummer._metadata is None |
||
2098 | ): |
||
2099 | log.debug('Lazy loading Huisnummer %d', huisnummer.id) |
||
2100 | huisnummer.check_gateway() |
||
2101 | h = huisnummer.gateway.get_huisnummer_by_id(huisnummer.id) |
||
2102 | huisnummer._metadata = h._metadata |
||
2103 | return f(*args) |
||
2104 | return wrapper |
||
2105 | |||
2106 | |||
2107 | class Huisnummer(GatewayObject): |
||
2108 | ''' |
||
2109 | A house number. |
||
2110 | |||
2111 | This is mainly a combination of a street and a house number. |
||
2112 | ''' |
||
2113 | def __init__( |
||
2114 | self, id, status, huisnummer, straat_id, |
||
2115 | metadata=None, **kwargs |
||
2116 | ): |
||
2117 | self.id = int(id) |
||
2118 | try: |
||
2119 | self.status_id = status.id |
||
2120 | self._status = status |
||
2121 | except AttributeError: |
||
2122 | self.status_id = status |
||
2123 | self._status = None |
||
2124 | self.huisnummer = huisnummer |
||
2125 | self.straat_id = straat_id |
||
2126 | self._metadata = metadata |
||
2127 | super(Huisnummer, self).__init__(**kwargs) |
||
2128 | |||
2129 | @property |
||
2130 | def straat(self): |
||
2131 | self.check_gateway() |
||
2132 | return self.gateway.get_straat_by_id(self.straat_id) |
||
2133 | |||
2134 | @property |
||
2135 | @check_lazy_load_huisnummer |
||
2136 | def metadata(self): |
||
2137 | return self._metadata |
||
2138 | |||
2139 | @property |
||
2140 | def status(self): |
||
2141 | if self._status is None: |
||
2142 | res = self.gateway.list_statushuisnummers() |
||
2143 | for status in res: |
||
2144 | if int(status.id) == int(self.status_id): |
||
2145 | self._status = status |
||
2146 | return self._status |
||
2147 | |||
2148 | @property |
||
2149 | def postkanton(self): |
||
2150 | self.check_gateway() |
||
2151 | return self.gateway.get_postkanton_by_huisnummer(self.id) |
||
2152 | |||
2153 | @property |
||
2154 | def terreinobjecten(self): |
||
2155 | return self.gateway.list_terreinobjecten_by_huisnummer(self.id) |
||
2156 | |||
2157 | @property |
||
2158 | def percelen(self): |
||
2159 | return self.gateway.list_percelen_by_huisnummer(self.id) |
||
2160 | |||
2161 | @property |
||
2162 | def bounding_box(self): |
||
2163 | per = [x.bounding_box for x in self.terreinobjecten] |
||
2164 | if per == []: |
||
2165 | return None |
||
2166 | mini = min(per) |
||
2167 | maxi = max(per) |
||
2168 | return [mini[0], mini[1], maxi[0], maxi[1]] |
||
2169 | |||
2170 | @property |
||
2171 | def postadres(self): |
||
2172 | self.check_gateway() |
||
2173 | return self.gateway.get_postadres_by_huisnummer(self.id) |
||
2174 | |||
2175 | @property |
||
2176 | def gebouwen(self): |
||
2177 | self.check_gateway() |
||
2178 | return self.gateway.list_gebouwen_by_huisnummer(self.id) |
||
2179 | |||
2180 | @property |
||
2181 | def subadressen(self): |
||
2182 | self.check_gateway() |
||
2183 | return self.gateway.list_subadressen_by_huisnummer(self.id) |
||
2184 | |||
2185 | @property |
||
2186 | def adresposities(self): |
||
2187 | self.check_gateway() |
||
2188 | return self.gateway.list_adresposities_by_huisnummer(self.id) |
||
2189 | |||
2190 | def __unicode__(self): |
||
2191 | return "%s (%s)" % (self.huisnummer, self.id) |
||
2192 | |||
2193 | def __repr__(self): |
||
2194 | return "Huisnummer(%s, %s, '%s', %s)" % (self.id, self.status_id, self.huisnummer, self.straat_id) |
||
2195 | |||
2196 | |||
2197 | class Postkanton(GatewayObject): |
||
2198 | ''' |
||
2199 | A postal code. |
||
2200 | |||
2201 | Eg. postal code `9000` for the city of Ghent. |
||
2202 | ''' |
||
2203 | def __init__(self, id, **kwargs): |
||
2204 | self.id = int(id) |
||
2205 | super(Postkanton, self).__init__(**kwargs) |
||
2206 | |||
2207 | def __unicode__(self): |
||
2208 | return "Postkanton %s" % (self.id) |
||
2209 | |||
2210 | def __repr__(self): |
||
2211 | return "Postkanton(%s)" % (self.id) |
||
2212 | |||
2213 | |||
2214 | def check_lazy_load_wegobject(f): |
||
2215 | ''' |
||
2216 | Decorator function to lazy load a :class:`Wegobject`. |
||
2217 | ''' |
||
2218 | def wrapper(*args): |
||
2219 | wegobject = args[0] |
||
2220 | if ( |
||
2221 | wegobject._centroid is None or |
||
2222 | wegobject._bounding_box is None or |
||
2223 | wegobject._metadata is None |
||
2224 | ): |
||
2225 | log.debug('Lazy loading Wegobject %d', wegobject.id) |
||
2226 | wegobject.check_gateway() |
||
2227 | w = wegobject.gateway.get_wegobject_by_id(wegobject.id) |
||
2228 | wegobject._centroid = w._centroid |
||
2229 | wegobject._bounding_box = w._bounding_box |
||
2230 | wegobject._metadata = w._metadata |
||
2231 | return f(*args) |
||
2232 | return wrapper |
||
2233 | |||
2234 | |||
2235 | View Code Duplication | class Wegobject(GatewayObject): |
|
0 ignored issues
–
show
|
|||
2236 | def __init__( |
||
2237 | self, id, aard, centroid=None, |
||
2238 | bounding_box=None, metadata=None, **kwargs |
||
2239 | ): |
||
2240 | self.id = id |
||
2241 | try: |
||
2242 | self.aard_id = aard.id |
||
2243 | self._aard = aard |
||
2244 | except AttributeError: |
||
2245 | self.aard_id = aard |
||
2246 | self._aard = None |
||
2247 | self._centroid = centroid |
||
2248 | self._bounding_box = bounding_box |
||
2249 | self._metadata = metadata |
||
2250 | super(Wegobject, self).__init__(**kwargs) |
||
2251 | |||
2252 | @property |
||
2253 | def aard(self): |
||
2254 | if self._aard is None: |
||
2255 | res = self.gateway.list_aardwegobjecten() |
||
2256 | for aard in res: |
||
2257 | if int(aard.id) == int(self.aard_id): |
||
2258 | self._aard = aard |
||
2259 | return self._aard |
||
2260 | |||
2261 | @property |
||
2262 | @check_lazy_load_wegobject |
||
2263 | def centroid(self): |
||
2264 | return self._centroid |
||
2265 | |||
2266 | @property |
||
2267 | @check_lazy_load_wegobject |
||
2268 | def bounding_box(self): |
||
2269 | return self._bounding_box |
||
2270 | |||
2271 | @property |
||
2272 | @check_lazy_load_wegobject |
||
2273 | def metadata(self): |
||
2274 | return self._metadata |
||
2275 | |||
2276 | def __unicode__(self): |
||
2277 | return "Wegobject %s" % (self.id) |
||
2278 | |||
2279 | def __repr__(self): |
||
2280 | return "Wegobject(%s)" % (self.id) |
||
2281 | |||
2282 | |||
2283 | def check_lazy_load_wegsegment(f): |
||
2284 | ''' |
||
2285 | Decorator function to lazy load a :class:`Wegsegment`. |
||
2286 | ''' |
||
2287 | def wrapper(*args): |
||
2288 | wegsegment = args[0] |
||
2289 | if ( |
||
2290 | wegsegment._methode_id is None or |
||
2291 | wegsegment._geometrie is None or |
||
2292 | wegsegment._metadata is None |
||
2293 | ): |
||
2294 | log.debug('Lazy loading Wegsegment %d', wegsegment.id) |
||
2295 | wegsegment.check_gateway() |
||
2296 | w = wegsegment.gateway.get_wegsegment_by_id(wegsegment.id) |
||
2297 | wegsegment._methode_id = w._methode_id |
||
2298 | wegsegment._geometrie = w._geometrie |
||
2299 | wegsegment._metadata = w._metadata |
||
2300 | return f(*args) |
||
2301 | return wrapper |
||
2302 | |||
2303 | |||
2304 | View Code Duplication | class Wegsegment(GatewayObject): |
|
0 ignored issues
–
show
|
|||
2305 | def __init__( |
||
2306 | self, id, status, methode=None, |
||
2307 | geometrie=None, metadata=None, **kwargs |
||
2308 | ): |
||
2309 | self.id = id |
||
2310 | try: |
||
2311 | self.status_id = status.id |
||
2312 | self._status = status |
||
2313 | except: |
||
2314 | self.status_id = status |
||
2315 | self._status = None |
||
2316 | try: |
||
2317 | self._methode_id = methode.id |
||
2318 | self._methode = methode |
||
2319 | except: |
||
2320 | self._methode_id = methode |
||
2321 | self._methode = None |
||
2322 | self._geometrie = geometrie |
||
2323 | self._metadata = metadata |
||
2324 | super(Wegsegment, self).__init__(**kwargs) |
||
2325 | |||
2326 | @property |
||
2327 | def status(self): |
||
2328 | if self._status is None: |
||
2329 | res = self.gateway.list_statuswegsegmenten() |
||
2330 | for status in res: |
||
2331 | if int(status.id) == int(self.status_id): |
||
2332 | self._status = status |
||
2333 | return self._status |
||
2334 | |||
2335 | @property |
||
2336 | @check_lazy_load_wegsegment |
||
2337 | def methode(self): |
||
2338 | if self._methode is None: |
||
2339 | res = self.gateway.list_geometriemethodewegsegmenten() |
||
2340 | for methode in res: |
||
2341 | if int(methode.id) == int(self._methode_id): |
||
2342 | self._methode = methode |
||
2343 | return self._methode |
||
2344 | |||
2345 | @property |
||
2346 | @check_lazy_load_wegsegment |
||
2347 | def geometrie(self): |
||
2348 | return self._geometrie |
||
2349 | |||
2350 | @property |
||
2351 | @check_lazy_load_wegsegment |
||
2352 | def metadata(self): |
||
2353 | return self._metadata |
||
2354 | |||
2355 | def __unicode__(self): |
||
2356 | return "Wegsegment %s" % (self.id) |
||
2357 | |||
2358 | def __repr__(self): |
||
2359 | return "Wegsegment(%s)" % (self.id) |
||
2360 | |||
2361 | |||
2362 | def check_lazy_load_terreinobject(f): |
||
2363 | ''' |
||
2364 | Decorator function to lazy load a :class:`Terreinobject`. |
||
2365 | ''' |
||
2366 | def wrapper(*args): |
||
2367 | terreinobject = args[0] |
||
2368 | if ( |
||
2369 | terreinobject._centroid is None or |
||
2370 | terreinobject._bounding_box is None or |
||
2371 | terreinobject._metadata is None |
||
2372 | ): |
||
2373 | log.debug('Lazy loading Terreinobject %s', terreinobject.id) |
||
2374 | terreinobject.check_gateway() |
||
2375 | t = terreinobject.gateway.get_terreinobject_by_id(terreinobject.id) |
||
2376 | terreinobject._centroid = t._centroid |
||
2377 | terreinobject._bounding_box = t._bounding_box |
||
2378 | terreinobject._metadata = t._metadata |
||
2379 | return f(*args) |
||
2380 | return wrapper |
||
2381 | |||
2382 | |||
2383 | View Code Duplication | class Terreinobject(GatewayObject): |
|
0 ignored issues
–
show
|
|||
2384 | ''' |
||
2385 | A cadastral parcel. |
||
2386 | |||
2387 | A :class:`Terreinobject` is somewhat different from a :class:`Perceel` |
||
2388 | in the source of the data and the information provided. eg. A |
||
2389 | `terreinobject` has a `centroid` and a `bounding box`, while a `perceel` |
||
2390 | also has the centroid, but not the `bounding box`. |
||
2391 | ''' |
||
2392 | def __init__( |
||
2393 | self, id, aard, centroid=None, |
||
2394 | bounding_box=None, metadata=None, **kwargs |
||
2395 | ): |
||
2396 | self.id = id |
||
2397 | try: |
||
2398 | self.aard_id = aard.id |
||
2399 | self._aard = aard |
||
2400 | except AttributeError: |
||
2401 | self.aard_id = aard |
||
2402 | self._aard = None |
||
2403 | self._centroid = centroid |
||
2404 | self._metadata = metadata |
||
2405 | self._bounding_box = bounding_box |
||
2406 | super(Terreinobject, self).__init__(**kwargs) |
||
2407 | |||
2408 | @property |
||
2409 | def aard(self): |
||
2410 | if self._aard is None: |
||
2411 | res = self.gateway.list_aardterreinobjecten() |
||
2412 | for aard in res: |
||
2413 | if int(aard.id) == int(self.aard_id): |
||
2414 | self._aard = aard |
||
2415 | return self._aard |
||
2416 | |||
2417 | @property |
||
2418 | @check_lazy_load_terreinobject |
||
2419 | def centroid(self): |
||
2420 | return self._centroid |
||
2421 | |||
2422 | @property |
||
2423 | @check_lazy_load_terreinobject |
||
2424 | def bounding_box(self): |
||
2425 | return self._bounding_box |
||
2426 | |||
2427 | @property |
||
2428 | @check_lazy_load_terreinobject |
||
2429 | def metadata(self): |
||
2430 | return self._metadata |
||
2431 | |||
2432 | def __unicode__(self): |
||
2433 | return "Terreinobject %s" % (self.id) |
||
2434 | |||
2435 | def __repr__(self): |
||
2436 | return "Terreinobject(%s)" % (self.id) |
||
2437 | |||
2438 | |||
2439 | def check_lazy_load_perceel(f): |
||
2440 | ''' |
||
2441 | Decorator function to lazy load a :class:`Perceel`. |
||
2442 | ''' |
||
2443 | def wrapper(*args): |
||
2444 | perceel = args[0] |
||
2445 | if perceel._centroid is None or perceel._metadata is None: |
||
2446 | log.debug('Lazy loading Perceel %s', perceel.id) |
||
2447 | perceel.check_gateway() |
||
2448 | p = perceel.gateway.get_perceel_by_id(perceel.id) |
||
2449 | perceel._centroid = p._centroid |
||
2450 | perceel._metadata = p._metadata |
||
2451 | return f(*args) |
||
2452 | return wrapper |
||
2453 | |||
2454 | |||
2455 | class Perceel(GatewayObject): |
||
2456 | ''' |
||
2457 | A cadastral Parcel. |
||
2458 | |||
2459 | A :class:`Terreinobject` is somewhat different from a :class:`Perceel` |
||
2460 | in the source of the data and the information provided. eg. A |
||
2461 | `terreinobject` has a `centroid` and a `bounding box`, while a `perceel` |
||
2462 | also has the centroid, but not the `bounding box`. |
||
2463 | ''' |
||
2464 | def __init__( |
||
2465 | self, id, centroid=None, metadata=None, **kwargs |
||
2466 | ): |
||
2467 | self.id = id |
||
2468 | self._centroid = centroid |
||
2469 | self._metadata = metadata |
||
2470 | super(Perceel, self).__init__(**kwargs) |
||
2471 | |||
2472 | @property |
||
2473 | @check_lazy_load_perceel |
||
2474 | def centroid(self): |
||
2475 | return self._centroid |
||
2476 | |||
2477 | @property |
||
2478 | @check_lazy_load_perceel |
||
2479 | def metadata(self): |
||
2480 | return self._metadata |
||
2481 | |||
2482 | @property |
||
2483 | def huisnummers(self): |
||
2484 | ''' |
||
2485 | Returns the huisnummers on this Perceel. |
||
2486 | |||
2487 | Some of the huisnummers might no longer be active. |
||
2488 | |||
2489 | :rtype: list |
||
2490 | ''' |
||
2491 | self.check_gateway() |
||
2492 | return self.gateway.list_huisnummers_by_perceel(self.id) |
||
2493 | |||
2494 | @property |
||
2495 | def postadressen(self): |
||
2496 | ''' |
||
2497 | Returns the postadressen for this Perceel. |
||
2498 | |||
2499 | Will only take the huisnummers with status `inGebruik` into account. |
||
2500 | |||
2501 | :rtype: list |
||
2502 | ''' |
||
2503 | return [h.postadres for h in self.huisnummers if h.status.id == '3'] |
||
2504 | |||
2505 | def __unicode__(self): |
||
2506 | return "Perceel %s" % (self.id) |
||
2507 | |||
2508 | def __repr__(self): |
||
2509 | return "Perceel(%s)" % (self.id) |
||
2510 | |||
2511 | |||
2512 | def check_lazy_load_gebouw(f): |
||
2513 | ''' |
||
2514 | Decorator function to lazy load a :class:`Gebouw`. |
||
2515 | ''' |
||
2516 | def wrapper(*args): |
||
2517 | gebouw = args[0] |
||
2518 | if ( |
||
2519 | gebouw._methode_id is None or gebouw._geometrie is None or |
||
2520 | gebouw._metadata is None |
||
2521 | ): |
||
2522 | log.debug('Lazy loading Gebouw %d', gebouw.id) |
||
2523 | gebouw.check_gateway() |
||
2524 | g = gebouw.gateway.get_gebouw_by_id(gebouw.id) |
||
2525 | gebouw._methode_id = g._methode_id |
||
2526 | gebouw._geometrie = g._geometrie |
||
2527 | gebouw._metadata = g._metadata |
||
2528 | return f(*args) |
||
2529 | return wrapper |
||
2530 | |||
2531 | |||
2532 | class Gebouw(GatewayObject): |
||
2533 | ''' |
||
2534 | A building. |
||
2535 | ''' |
||
2536 | def __init__( |
||
2537 | self, id, aard, status, |
||
2538 | methode=None, geometrie=None, metadata=None, **kwargs |
||
2539 | ): |
||
2540 | self.id = int(id) |
||
2541 | try: |
||
2542 | self.aard_id = aard.id |
||
2543 | self._aard = aard |
||
2544 | except: |
||
2545 | self.aard_id = aard |
||
2546 | self._aard = None |
||
2547 | try: |
||
2548 | self.status_id = status.id |
||
2549 | self._status = status |
||
2550 | except: |
||
2551 | self.status_id = status |
||
2552 | self._status = None |
||
2553 | try: |
||
2554 | self._methode_id = methode.id |
||
2555 | self._methode = methode |
||
2556 | except: |
||
2557 | self._methode_id = methode |
||
2558 | self._methode = None |
||
2559 | self._geometrie = geometrie |
||
2560 | self._metadata = metadata |
||
2561 | super(Gebouw, self).__init__(**kwargs) |
||
2562 | |||
2563 | @property |
||
2564 | def aard(self): |
||
2565 | if self._aard is None: |
||
2566 | self.check_gateway() |
||
2567 | res = self.gateway.list_aardgebouwen() |
||
2568 | for aard in res: |
||
2569 | if int(aard.id) == int(self.aard_id): |
||
2570 | self._aard = aard |
||
2571 | return self._aard |
||
2572 | |||
2573 | @property |
||
2574 | def status(self): |
||
2575 | if self._status is None: |
||
2576 | self.check_gateway() |
||
2577 | res = self.gateway.list_statusgebouwen() |
||
2578 | for status in res: |
||
2579 | if int(status.id) == int(self.status_id): |
||
2580 | self._status = status |
||
2581 | return self._status |
||
2582 | |||
2583 | @property |
||
2584 | @check_lazy_load_gebouw |
||
2585 | def methode(self): |
||
2586 | if self._methode is None: |
||
2587 | res = self.gateway.list_geometriemethodegebouwen() |
||
2588 | for methode in res: |
||
2589 | if int(methode.id) == int(self._methode_id): |
||
2590 | self._methode = methode |
||
2591 | return self._methode |
||
2592 | |||
2593 | @property |
||
2594 | @check_lazy_load_gebouw |
||
2595 | def geometrie(self): |
||
2596 | return self._geometrie |
||
2597 | |||
2598 | @property |
||
2599 | @check_lazy_load_gebouw |
||
2600 | def metadata(self): |
||
2601 | return self._metadata |
||
2602 | |||
2603 | def __unicode__(self): |
||
2604 | return "Gebouw %s" % (self.id) |
||
2605 | |||
2606 | def __repr__(self): |
||
2607 | return "Gebouw(%s)" % (self.id) |
||
2608 | |||
2609 | |||
2610 | def check_lazy_load_subadres(f): |
||
2611 | ''' |
||
2612 | Decorator function to lazy load a :class:`Subadres`. |
||
2613 | ''' |
||
2614 | def wrapper(*args): |
||
2615 | subadres = args[0] |
||
2616 | if ( |
||
2617 | subadres._metadata is None or |
||
2618 | subadres.aard_id is None or |
||
2619 | subadres.huisnummer_id is None |
||
2620 | ): |
||
2621 | log.debug('Lazy loading Subadres %d', subadres.id) |
||
2622 | subadres.check_gateway() |
||
2623 | s = subadres.gateway.get_subadres_by_id(subadres.id) |
||
2624 | subadres._metadata = s._metadata |
||
2625 | subadres.aard_id = s.aard_id |
||
2626 | subadres.huisnummer_id = s.huisnummer_id |
||
2627 | return f(*args) |
||
2628 | return wrapper |
||
2629 | |||
2630 | |||
2631 | class Subadres(GatewayObject): |
||
2632 | ''' |
||
2633 | An address within a certain :class:`Huisnummer`. |
||
2634 | |||
2635 | These can eg. be postboxes within an appartment complex. |
||
2636 | ''' |
||
2637 | def __init__( |
||
2638 | self, id, subadres, status, huisnummer_id=None, aard=None, |
||
2639 | metadata=None, **kwargs |
||
2640 | ): |
||
2641 | self.id = int(id) |
||
2642 | self.subadres = subadres |
||
2643 | try: |
||
2644 | self.status_id = status.id |
||
2645 | self._status = status |
||
2646 | except AttributeError: |
||
2647 | self.status_id = status |
||
2648 | self._status = None |
||
2649 | self.huisnummer_id = huisnummer_id |
||
2650 | try: |
||
2651 | self.aard_id = aard.id |
||
2652 | self._aard = aard |
||
2653 | except AttributeError: |
||
2654 | self.aard_id = aard |
||
2655 | self._aard = None |
||
2656 | self._metadata = metadata |
||
2657 | super(Subadres, self).__init__(**kwargs) |
||
2658 | |||
2659 | @property |
||
2660 | def huisnummer(self): |
||
2661 | self.check_gateway() |
||
2662 | return self.gateway.get_huisnummer_by_id(self.huisnummer_id) |
||
2663 | |||
2664 | @property |
||
2665 | @check_lazy_load_subadres |
||
2666 | def metadata(self): |
||
2667 | return self._metadata |
||
2668 | |||
2669 | @property |
||
2670 | def status(self): |
||
2671 | if self._status is None: |
||
2672 | res = self.gateway.list_statushuisnummers() |
||
2673 | for status in res: |
||
2674 | if int(status.id) == int(self.status_id): |
||
2675 | self._status = status |
||
2676 | return self._status |
||
2677 | |||
2678 | @property |
||
2679 | @check_lazy_load_subadres |
||
2680 | def aard(self): |
||
2681 | if self._aard is None: |
||
2682 | res = self.gateway.list_aardsubadressen() |
||
2683 | for aard in res: |
||
2684 | if int(aard.id) == int(self.aard_id): |
||
2685 | self._aard = aard |
||
2686 | return self._aard |
||
2687 | |||
2688 | @property |
||
2689 | def postadres(self): |
||
2690 | self.check_gateway() |
||
2691 | return self.gateway.get_postadres_by_subadres(self.id) |
||
2692 | |||
2693 | @property |
||
2694 | def adresposities(self): |
||
2695 | self.check_gateway() |
||
2696 | return self.gateway.list_adresposities_by_subadres(self.id) |
||
2697 | |||
2698 | def __unicode__(self): |
||
2699 | return "%s (%s)" % (self.subadres, self.id) |
||
2700 | |||
2701 | def __repr__(self): |
||
2702 | return "Subadres(%s, %s, '%s', %s)" % (self.id, self.status_id, self.subadres, self.huisnummer_id) |
||
2703 | |||
2704 | |||
2705 | def check_lazy_load_adrespositie(f): |
||
2706 | ''' |
||
2707 | Decorator function to lazy load a :class:`Adrespositie`. |
||
2708 | ''' |
||
2709 | def wrapper(*args): |
||
2710 | adrespositie = args[0] |
||
2711 | if ( |
||
2712 | adrespositie._geometrie is None or |
||
2713 | adrespositie._aard is None or |
||
2714 | adrespositie._metadata is None |
||
2715 | ): |
||
2716 | log.debug('Lazy loading Adrespositie %d', adrespositie.id) |
||
2717 | adrespositie.check_gateway() |
||
2718 | a = adrespositie.gateway.get_adrespositie_by_id(adrespositie.id) |
||
2719 | adrespositie._geometrie = a._geometrie |
||
2720 | adrespositie.aard_id = a.aard_id |
||
2721 | adrespositie._metadata = a._metadata |
||
2722 | return f(*args) |
||
2723 | return wrapper |
||
2724 | |||
2725 | |||
2726 | View Code Duplication | class Adrespositie(GatewayObject): |
|
0 ignored issues
–
show
|
|||
2727 | ''' |
||
2728 | The position of an `Adres`. |
||
2729 | |||
2730 | This can be used for the position of both :class:`Huisnummer` and |
||
2731 | :class:`Subadres`. |
||
2732 | |||
2733 | A `Huisnummer` or `Subadres`, can have more than one `Adrespositie`, each |
||
2734 | offering a different interpretation of the position of the `Adres`. See |
||
2735 | the `herkomst` and `aard` of each `Adrespositie` to know which one to pick. |
||
2736 | ''' |
||
2737 | def __init__( |
||
2738 | self, id, herkomst, geometrie=None, aard=None, |
||
2739 | metadata=None, **kwargs |
||
2740 | ): |
||
2741 | self.id = id |
||
2742 | try: |
||
2743 | self.herkomst_id = herkomst.id |
||
2744 | self._herkomst = herkomst |
||
2745 | except AttributeError: |
||
2746 | self.herkomst_id = herkomst |
||
2747 | self._herkomst = None |
||
2748 | self._geometrie = geometrie |
||
2749 | try: |
||
2750 | self.aard_id = aard.id |
||
2751 | self._aard = aard |
||
2752 | except AttributeError: |
||
2753 | self.aard_id = aard |
||
2754 | self._aard = None |
||
2755 | self._metadata = metadata |
||
2756 | super(Adrespositie, self).__init__(**kwargs) |
||
2757 | |||
2758 | @property |
||
2759 | def herkomst(self): |
||
2760 | if self._herkomst is None: |
||
2761 | self.check_gateway() |
||
2762 | res = self.gateway.list_herkomstadresposities() |
||
2763 | for herkomst in res: |
||
2764 | if int(herkomst.id) == int(self.herkomst_id): |
||
2765 | self._herkomst = herkomst |
||
2766 | return self._herkomst |
||
2767 | |||
2768 | @property |
||
2769 | @check_lazy_load_adrespositie |
||
2770 | def metadata(self): |
||
2771 | return self._metadata |
||
2772 | |||
2773 | @property |
||
2774 | @check_lazy_load_adrespositie |
||
2775 | def geometrie(self): |
||
2776 | return self._geometrie |
||
2777 | |||
2778 | @property |
||
2779 | @check_lazy_load_adrespositie |
||
2780 | def aard(self): |
||
2781 | if self._aard is None: |
||
2782 | res = self.gateway.list_aardadressen() |
||
2783 | for aard in res: |
||
2784 | if int(aard.id) == int(self.aard_id): |
||
2785 | self._aard = aard |
||
2786 | return self._aard |
||
2787 | |||
2788 | def __unicode__(self): |
||
2789 | return "Adrespositie %s" % (self.id) |
||
2790 | |||
2791 | def __repr__(self): |
||
2792 | return "Adrespositie(%s, %s)" % (self.id, self.herkomst_id) |
||
2793 | |||
2794 | |||
2795 | class Metadata(GatewayObject): |
||
2796 | ''' |
||
2797 | Metadata about a `straat`, `huisnummer`, ... |
||
2798 | |||
2799 | Some of the metadata available is the datum the object was created, the |
||
2800 | organisation that created it and the type of creation. |
||
2801 | ''' |
||
2802 | def __init__( |
||
2803 | self, begin_datum, begin_tijd, |
||
2804 | begin_bewerking, begin_organisatie, |
||
2805 | **kwargs |
||
2806 | ): |
||
2807 | self.begin_datum = str(begin_datum) |
||
2808 | self.begin_tijd = str(begin_tijd) |
||
2809 | try: |
||
2810 | self._begin_bewerking_id = begin_bewerking.id |
||
2811 | self._begin_bewerking = begin_bewerking |
||
2812 | except AttributeError: |
||
2813 | self._begin_bewerking_id = begin_bewerking |
||
2814 | self._begin_bewerking = None |
||
2815 | try: |
||
2816 | self._begin_organisatie_id = begin_organisatie.id |
||
2817 | self._begin_organisatie = begin_organisatie |
||
2818 | except AttributeError: |
||
2819 | self._begin_organisatie_id = begin_organisatie |
||
2820 | self._begin_organisatie = None |
||
2821 | super(Metadata, self).__init__(**kwargs) |
||
2822 | |||
2823 | @property |
||
2824 | def begin_bewerking(self): |
||
2825 | if self._begin_bewerking is None: |
||
2826 | self.check_gateway() |
||
2827 | bewerkingen = self.gateway.list_bewerkingen() |
||
2828 | for bewerking in bewerkingen: |
||
2829 | if int(bewerking.id) == int(self._begin_bewerking_id): |
||
2830 | self._begin_bewerking = bewerking |
||
2831 | return self._begin_bewerking |
||
2832 | |||
2833 | @property |
||
2834 | def begin_organisatie(self): |
||
2835 | if self._begin_organisatie is None: |
||
2836 | self.check_gateway() |
||
2837 | organisaties = self.gateway.list_organisaties() |
||
2838 | for organisatie in organisaties: |
||
2839 | if int(organisatie.id) == int(self._begin_organisatie_id): |
||
2840 | self._begin_organisatie = organisatie |
||
2841 | return self._begin_organisatie |
||
2842 | |||
2843 | def __unicode__(self): |
||
2844 | return "Begin datum: %s" % (self.begin_datum) |
||
2845 |