def handle(self, **options):
if options.get("url") and options.get("file"):
raise CommandError("Please specify a url or file, not both")
if not options.get("url") and not options.get("file"):
raise CommandError("Must give a url or file")
self.stdout.write("Importing reden codes")
if options.get("url"):
with requests.Session() as s:
download = s.get(options["url"])
decoded_content = download.content.decode("utf-16")
rows = list(
csv.reader(decoded_content.splitlines(), delimiter=","))
else:
with open(options["file"], "r", newline="\n",
encoding="utf-16") as csvfile:
rows = list(csv.reader(csvfile, delimiter=",", quotechar='"'))
header_row = rows.pop(0)
if "Reden" not in header_row[0]:
raise CommandError("Reden should be the first column in your csv")
if "Omschrijving" not in header_row[1]:
raise CommandError(
"Omschrijving should be the second column in your csv")
redenen = [
RedenCodeAndOmschrijving(code=row[0], omschrijving=row[1])
for row in rows
]
RedenCodeAndOmschrijving.objects.bulk_create(redenen)
self.stdout.write(f"Done! {len(redenen)} imported!")
def convert_response_to_nationaliteit_historie_dict(response):
dict_object = xmltodict.parse(response.content)
antwoord_dict_object = dict_object["soapenv:Envelope"]["soapenv:Body"][
"ns:npsLa01"
]["ns:antwoord"]["ns:object"]["ns:inp.heeftAlsNationaliteit"]
nationaliteit_historie_dict = {
"aanduidingBijzonderNederlanderschap": antwoord_dict_object[
"ns:historieMaterieel"
]["ns:aanduidingStrijdigheidNietigheid"],
"datumIngangGeldigheid": {
"dag": int(
antwoord_dict_object["ns:historieMaterieel"]["StUF:tijdvakGeldigheid"][
"StUF:beginGeldigheid"
][settings.OPENPERSONEN_DAY_START : settings.OPENPERSONEN_DAY_END]
),
"datum": antwoord_dict_object["ns:historieMaterieel"][
"StUF:tijdvakGeldigheid"
]["StUF:beginGeldigheid"],
"jaar": int(
antwoord_dict_object["ns:historieMaterieel"]["StUF:tijdvakGeldigheid"][
"StUF:beginGeldigheid"
][settings.OPENPERSONEN_YEAR_START : settings.OPENPERSONEN_YEAR_END]
),
"maand": int(
antwoord_dict_object["ns:historieMaterieel"]["StUF:tijdvakGeldigheid"][
"StUF:beginGeldigheid"
][settings.OPENPERSONEN_MONTH_START : settings.OPENPERSONEN_MONTH_END]
),
},
"nationaliteit": {"code": "0000", "omschrijving": "Nederland"},
"redenOpname": {
"code": antwoord_dict_object["ns:historieFormeelRelatie"][
"ns:inp.redenVerkrijging"
],
"omschrijving": RedenCodeAndOmschrijving.get_omschrijving_from_code(
antwoord_dict_object["ns:historieFormeelRelatie"][
"ns:inp.redenVerkrijging"
]
),
},
"inOnderzoek": {
"aanduidingBijzonderNederlanderschap": bool(
antwoord_dict_object["ns:historieMaterieel"][
"ns:aanduidingStrijdigheidNietigheid"
]
),
"nationaliteit": True,
"redenOpname": bool(
antwoord_dict_object["ns:historieFormeelRelatie"][
"ns:inp.redenVerkrijging"
]
),
"datumIngangOnderzoek": {
"dag": 0,
"datum": "string",
"jaar": 0,
"maand": 0,
},
},
"geheimhoudingPersoonsgegevens": True,
"datumEindeGeldigheid": {
"dag": int(
antwoord_dict_object["ns:historieMaterieel"]["StUF:tijdvakGeldigheid"][
"StUF:eindGeldigheid"
][settings.OPENPERSONEN_DAY_START : settings.OPENPERSONEN_DAY_END]
),
"datum": antwoord_dict_object["ns:historieMaterieel"][
"StUF:tijdvakGeldigheid"
]["StUF:eindGeldigheid"],
"jaar": int(
antwoord_dict_object["ns:historieMaterieel"]["StUF:tijdvakGeldigheid"][
"StUF:eindGeldigheid"
][settings.OPENPERSONEN_YEAR_START : settings.OPENPERSONEN_YEAR_END]
),
"maand": int(
antwoord_dict_object["ns:historieMaterieel"]["StUF:tijdvakGeldigheid"][
"StUF:eindGeldigheid"
][settings.OPENPERSONEN_MONTH_START : settings.OPENPERSONEN_MONTH_END]
),
},
"redenBeeindigen": {
"code": antwoord_dict_object["ns:historieFormeelRelatie"][
"ns:inp.redenVerlies"
],
"omschrijving": RedenCodeAndOmschrijving.get_omschrijving_from_code(
antwoord_dict_object["ns:historieFormeelRelatie"]["ns:inp.redenVerlies"]
),
},
"indicatieNationaliteitBeeindigd": True,
}
convert_empty_instances(nationaliteit_historie_dict)
return nationaliteit_historie_dict
def convert_persoon_to_instance_dict(persoon):
ingeschreven_persoon_dict = {
"burgerservicenummer": persoon.burgerservicenummer_persoon,
"geheimhoudingPersoonsgegevens": True,
"naam": {
"geslachtsnaam": persoon.geslachtsnaam_persoon,
"voorletters": "string",
"voornamen": persoon.voornamen_persoon,
"voorvoegsel": persoon.voorvoegsel_geslachtsnaam_persoon,
"inOnderzoek": {
"geslachtsnaam": bool(persoon.geslachtsnaam_persoon),
"voornamen": bool(persoon.voornamen_persoon),
"voorvoegsel": bool(persoon.voorvoegsel_geslachtsnaam_persoon),
"datumIngangOnderzoek": {
"dag":
int(persoon.datum_ingang_onderzoek[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
persoon.datum_ingang_onderzoek) else 0,
"datum":
persoon.datum_ingang_onderzoek,
"jaar":
int(persoon.datum_ingang_onderzoek[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
persoon.datum_ingang_onderzoek) else 0,
"maand":
int(persoon.datum_ingang_onderzoek[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
persoon.datum_ingang_onderzoek) else 0,
},
},
"aanduidingNaamgebruik": persoon.aanduiding_naamgebruik,
},
"geboorte": {
"datum": {
"dag":
int(persoon.geboortedatum_persoon[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if is_valid_date_format(persoon.geboortedatum_persoon) else 0,
"datum":
persoon.geboortedatum_persoon,
"jaar":
int(persoon.geboortedatum_persoon[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if is_valid_date_format(persoon.geboortedatum_persoon) else 0,
"maand":
int(persoon.geboortedatum_persoon[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if is_valid_date_format(persoon.geboortedatum_persoon) else 0,
},
"land": {
"code":
persoon.geboorteland_persoon,
"omschrijving":
CountryCodeAndOmschrijving.get_omschrijving_from_code(
persoon.geboorteland_persoon),
},
"plaats": {
"code":
persoon.geboorteplaats_persoon,
"omschrijving":
GemeenteCodeAndOmschrijving.get_omschrijving_from_code(
persoon.geboorteplaats_persoon),
},
"inOnderzoek": {
"datum": True,
"land": True,
"plaats": True,
"datumIngangOnderzoek": {
"dag": 0,
"datum": "string",
"jaar": 0,
"maand": 0,
},
},
},
"geslachtsaanduiding": persoon.geslachtsaanduiding,
"leeftijd": calculate_age(persoon.geboortedatum_persoon),
"datumEersteInschrijvingGBA": {
"dag": 0,
"datum": "string",
"jaar": 0,
"maand": 0,
},
"inOnderzoek": {
"burgerservicenummer": bool(persoon.burgerservicenummer_persoon),
"geslachtsaanduiding": bool(persoon.geslachtsaanduiding),
"datumIngangOnderzoek": {
"dag": 0,
"datum": "string",
"jaar": 0,
"maand": 0,
},
},
"opschortingBijhouding": {
"reden": "overlijden",
"datum": {
"dag": 0,
"datum": "string",
"jaar": 0,
"maand": 0
},
},
}
ingeschreven_persoon_dict["kiesrecht"] = dict()
kiesrecht = persoon.kiesrecht_set.first()
if kiesrecht:
ingeschreven_persoon_dict["kiesrecht"] = {
"europeesKiesrecht":
bool(kiesrecht.aanduiding_europees_kiesrecht),
"uitgeslotenVanKiesrecht":
bool(kiesrecht.aanduiding_uitgesloten_kiesrecht),
"einddatumUitsluitingEuropeesKiesrecht": {
"dag":
int(kiesrecht.einddatum_uitsluiting_europees_kiesrecht[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if is_valid_date_format(
kiesrecht.einddatum_uitsluiting_europees_kiesrecht) else 0,
"datum":
kiesrecht.einddatum_uitsluiting_europees_kiesrecht,
"jaar":
int(kiesrecht.einddatum_uitsluiting_europees_kiesrecht[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if is_valid_date_format(
kiesrecht.einddatum_uitsluiting_europees_kiesrecht) else 0,
"maand":
int(kiesrecht.einddatum_uitsluiting_europees_kiesrecht[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if is_valid_date_format(
kiesrecht.einddatum_uitsluiting_europees_kiesrecht) else 0,
},
"einddatumUitsluitingKiesrecht": {
"dag":
int(kiesrecht.einddatum_uitsluiting_kiesrecht[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
kiesrecht.einddatum_uitsluiting_kiesrecht) else 0,
"datum":
kiesrecht.einddatum_uitsluiting_kiesrecht,
"jaar":
int(kiesrecht.einddatum_uitsluiting_kiesrecht[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
kiesrecht.einddatum_uitsluiting_kiesrecht) else 0,
"maand":
int(kiesrecht.einddatum_uitsluiting_kiesrecht[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
kiesrecht.einddatum_uitsluiting_kiesrecht) else 0,
},
}
ingeschreven_persoon_dict["overlijden"] = dict()
overlijden = persoon.overlijden_set.first()
if overlijden:
ingeschreven_persoon_dict["overlijden"] = {
"indicatieOverleden": True,
"datum": {
"dag":
int(overlijden.
datum_overlijden[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if is_valid_date_format(overlijden.datum_overlijden) else 0,
"datum":
overlijden.datum_overlijden,
"jaar":
int(overlijden.
datum_overlijden[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if is_valid_date_format(overlijden.datum_overlijden) else 0,
"maand":
int(overlijden.
datum_overlijden[settings.OPENPERSONEN_MONTH_START:settings
.OPENPERSONEN_MONTH_END])
if is_valid_date_format(overlijden.datum_overlijden) else 0,
},
"land": {
"code":
overlijden.land_overlijden,
"omschrijving":
CountryCodeAndOmschrijving.get_omschrijving_from_code(
overlijden.land_overlijden),
},
"plaats": {
"code":
overlijden.plaats_overlijden,
"omschrijving":
GemeenteCodeAndOmschrijving.get_omschrijving_from_code(
overlijden.plaats_overlijden),
},
"inOnderzoek": {
"datum": bool(overlijden.datum_overlijden),
"land": bool(overlijden.land_overlijden),
"plaats": bool(overlijden.plaats_overlijden),
"datumIngangOnderzoek": {
"dag": 0,
"datum": "string",
"jaar": 0,
"maand": 0,
},
},
}
ingeschreven_persoon_dict["verblijfplaats"] = dict()
verblijfplaats = persoon.verblijfplaats_set.first()
if verblijfplaats:
ingeschreven_persoon_dict["verblijfplaats"] = {
"functieAdres": verblijfplaats.functie_adres,
"huisletter": verblijfplaats.huisletter,
"huisnummer": verblijfplaats.huisnummer,
"huisnummertoevoeging": verblijfplaats.huisnummertoevoeging,
"aanduidingBijHuisnummer":
verblijfplaats.aanduiding_bij_huisnummer,
"identificatiecodeNummeraanduiding":
verblijfplaats.identificatiecode_nummeraanduiding,
"naamOpenbareRuimte": verblijfplaats.naam_openbare_ruimte,
"postcode": verblijfplaats.postcode,
"woonplaatsnaam": verblijfplaats.woonplaatsnaam,
"identificatiecodeAdresseerbaarObject": "string",
"indicatieVestigingVanuitBuitenland": True,
"locatiebeschrijving": verblijfplaats.locatiebeschrijving,
"straatnaam": verblijfplaats.straatnaam,
"vanuitVertrokkenOnbekendWaarheen": True,
"datumAanvangAdreshouding": {
"dag":
int(verblijfplaats.datum_aanvang_adres_buitenland[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfplaats.datum_aanvang_adres_buitenland) else 0,
"datum":
verblijfplaats.datum_aanvang_adres_buitenland,
"jaar":
int(verblijfplaats.datum_aanvang_adres_buitenland[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfplaats.datum_aanvang_adres_buitenland) else 0,
"maand":
int(verblijfplaats.datum_aanvang_adres_buitenland[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfplaats.datum_aanvang_adres_buitenland) else 0,
},
"datumIngangGeldigheid": {
"dag":
int(verblijfplaats.ingangsdatum_geldigheid_met_betrekking[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfplaats.ingangsdatum_geldigheid_met_betrekking)
else 0,
"datum":
verblijfplaats.ingangsdatum_geldigheid_met_betrekking,
"jaar":
int(verblijfplaats.ingangsdatum_geldigheid_met_betrekking[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfplaats.ingangsdatum_geldigheid_met_betrekking)
else 0,
"maand":
int(verblijfplaats.ingangsdatum_geldigheid_met_betrekking[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfplaats.ingangsdatum_geldigheid_met_betrekking)
else 0,
},
"datumInschrijvingInGemeente": {
"dag":
int(verblijfplaats.datum_inschrijving_in_de_gemeente[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if is_valid_date_format(
verblijfplaats.datum_inschrijving_in_de_gemeente) else 0,
"datum":
verblijfplaats.datum_inschrijving_in_de_gemeente,
"jaar":
int(verblijfplaats.datum_inschrijving_in_de_gemeente[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if is_valid_date_format(
verblijfplaats.datum_inschrijving_in_de_gemeente) else 0,
"maand":
int(verblijfplaats.datum_inschrijving_in_de_gemeente[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if is_valid_date_format(
verblijfplaats.datum_inschrijving_in_de_gemeente) else 0,
},
"datumVestigingInNederland": {
"dag":
int(verblijfplaats.datum_vestiging_in_nederland[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfplaats.datum_vestiging_in_nederland) else 0,
"datum":
verblijfplaats.datum_vestiging_in_nederland,
"jaar":
int(verblijfplaats.datum_vestiging_in_nederland[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfplaats.datum_vestiging_in_nederland) else 0,
"maand":
int(verblijfplaats.datum_vestiging_in_nederland[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfplaats.datum_vestiging_in_nederland) else 0,
},
"gemeenteVanInschrijving": {
"code": "string",
"omschrijving": verblijfplaats.gemeente_van_inschrijving,
},
"landVanwaarIngeschreven": {
"code": "string",
"omschrijving": verblijfplaats.land_vanwaar_ingeschreven,
},
"verblijfBuitenland": {
"adresRegel1": verblijfplaats.regel_1_adres_buitenland,
"adresRegel2": verblijfplaats.regel_2_adres_buitenland,
"adresRegel3": verblijfplaats.regel_3_adres_buitenland,
"vertrokkenOnbekendWaarheen": True,
"land": {
"code": "string",
"omschrijving": "string"
},
},
"inOnderzoek": {
"aanduidingBijHuisnummer":
bool(verblijfplaats.aanduiding_bij_huisnummer),
"datumAanvangAdreshouding":
bool(verblijfplaats.datum_aanvang_adreshouding),
"datumIngangGeldigheid":
True,
"datumInschrijvingInGemeente":
bool(verblijfplaats.datum_inschrijving_in_de_gemeente),
"datumVestigingInNederland":
bool(verblijfplaats.datum_vestiging_in_nederland),
"functieAdres":
True,
"gemeenteVanInschrijving":
bool(verblijfplaats.gemeente_van_inschrijving),
"huisletter":
bool(verblijfplaats.huisletter),
"huisnummer":
bool(verblijfplaats.huisnummer),
"huisnummertoevoeging":
bool(verblijfplaats.huisnummertoevoeging),
"identificatiecodeNummeraanduiding":
bool(verblijfplaats.identificatiecode_nummeraanduiding),
"identificatiecodeAdresseerbaarObject":
True,
"landVanwaarIngeschreven":
bool(verblijfplaats.land_vanwaar_ingeschreven),
"locatiebeschrijving":
bool(verblijfplaats.locatiebeschrijving),
"naamOpenbareRuimte":
bool(verblijfplaats.naam_openbare_ruimte),
"postcode":
bool(verblijfplaats.postcode),
"straatnaam":
bool(verblijfplaats.straatnaam),
"verblijfBuitenland":
True,
"woonplaatsnaam":
bool(verblijfplaats.woonplaatsnaam),
"datumIngangOnderzoek": {
"dag":
int(verblijfplaats.datum_ingang_onderzoek[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfplaats.datum_ingang_onderzoek) else 0,
"datum":
verblijfplaats.datum_ingang_onderzoek,
"jaar":
int(verblijfplaats.datum_ingang_onderzoek[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfplaats.datum_ingang_onderzoek) else 0,
"maand":
int(verblijfplaats.datum_ingang_onderzoek[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfplaats.datum_ingang_onderzoek) else 0,
},
},
}
ingeschreven_persoon_dict["gezagsverhouding"] = dict()
gezagsverhouding = persoon.gezagsverhouding_set.first()
if gezagsverhouding:
ingeschreven_persoon_dict["gezagsverhouding"] = {
"indicatieCurateleRegister":
gezagsverhouding.indicatie_curateleregister,
"indicatieGezagMinderjarige":
gezagsverhouding.indicatie_gezag_minderjarige,
"inOnderzoek": {
"indicatieCurateleRegister":
bool(gezagsverhouding.indicatie_curateleregister),
"indicatieGezagMinderjarige":
bool(gezagsverhouding.indicatie_gezag_minderjarige),
"datumIngangOnderzoek": {
"dag":
int(gezagsverhouding.datum_ingang_onderzoek[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
gezagsverhouding.datum_ingang_onderzoek) else 0,
"datum":
gezagsverhouding.datum_ingang_onderzoek,
"jaar":
int(gezagsverhouding.datum_ingang_onderzoek[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
gezagsverhouding.datum_ingang_onderzoek) else 0,
"maand":
int(gezagsverhouding.datum_ingang_onderzoek[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
gezagsverhouding.datum_ingang_onderzoek) else 0,
},
},
}
ingeschreven_persoon_dict["verblijfstitel"] = dict()
verblijfstitel = persoon.verblijfstitel_set.first()
if verblijfstitel:
ingeschreven_persoon_dict["verblijfstitel"] = {
"aanduiding": {
"code": "string",
"omschrijving": verblijfstitel.aanduiding_verblijfstitel,
},
"datumEinde": {
"dag":
int(verblijfstitel.datum_einde_verblijfstitel[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfstitel.datum_einde_verblijfstitel) else 0,
"datum":
verblijfstitel.datum_einde_verblijfstitel,
"jaar":
int(verblijfstitel.datum_einde_verblijfstitel[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfstitel.datum_einde_verblijfstitel) else 0,
"maand":
int(verblijfstitel.datum_einde_verblijfstitel[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfstitel.datum_einde_verblijfstitel) else 0,
},
"datumIngang": {
"dag":
int(verblijfstitel.ingangsdatum_verblijfstitel[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfstitel.ingangsdatum_verblijfstitel) else 0,
"datum":
verblijfstitel.ingangsdatum_verblijfstitel,
"jaar":
int(verblijfstitel.ingangsdatum_verblijfstitel[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfstitel.ingangsdatum_verblijfstitel) else 0,
"maand":
int(verblijfstitel.ingangsdatum_verblijfstitel[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfstitel.ingangsdatum_verblijfstitel) else 0,
},
"inOnderzoek": {
"aanduiding": bool(verblijfstitel.aanduiding_verblijfstitel),
"datumEinde": bool(verblijfstitel.datum_einde_verblijfstitel),
"datumIngang":
bool(verblijfstitel.ingangsdatum_verblijfstitel),
"datumIngangOnderzoek": {
"dag":
int(verblijfstitel.datum_ingang_onderzoek[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
verblijfstitel.datum_ingang_onderzoek) else 0,
"datum":
verblijfstitel.datum_ingang_onderzoek,
"jaar":
int(verblijfstitel.datum_ingang_onderzoek[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
verblijfstitel.datum_ingang_onderzoek) else 0,
"maand":
int(verblijfstitel.datum_ingang_onderzoek[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
verblijfstitel.datum_ingang_onderzoek) else 0,
},
},
}
ingeschreven_persoon_dict["nationaliteit"] = []
nationaliteiten = persoon.nationaliteit_set.all()
for nationaliteit in nationaliteiten:
ingeschreven_persoon_dict["nationaliteit"].append({
"aanduidingBijzonderNederlanderschap":
nationaliteit.aanduiding_bijzonder_nederlanderschap,
"datumIngangGeldigheid": {
"dag":
int(nationaliteit.datum_van_ingang_geldigheid_met_betrekking[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if is_valid_date_format(
nationaliteit.datum_van_ingang_geldigheid_met_betrekking)
else 0,
"datum":
nationaliteit.datum_van_ingang_geldigheid_met_betrekking,
"jaar":
int(nationaliteit.datum_van_ingang_geldigheid_met_betrekking[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if is_valid_date_format(
nationaliteit.datum_van_ingang_geldigheid_met_betrekking)
else 0,
"maand":
int(nationaliteit.datum_van_ingang_geldigheid_met_betrekking[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if is_valid_date_format(
nationaliteit.datum_van_ingang_geldigheid_met_betrekking)
else 0,
},
"nationaliteit": {
"code": "string",
"omschrijving": nationaliteit.nationaliteit,
},
"redenOpname": {
"code":
nationaliteit.reden_opname_nationaliteit,
"omschrijving":
RedenCodeAndOmschrijving.get_omschrijving_from_code(
nationaliteit.reden_opname_nationaliteit),
},
"inOnderzoek": {
"aanduidingBijzonderNederlanderschap":
bool(nationaliteit.aanduiding_bijzonder_nederlanderschap),
"nationaliteit":
bool(nationaliteit.nationaliteit),
"redenOpname":
bool(nationaliteit.reden_opname_nationaliteit),
"datumIngangOnderzoek": {
"dag":
int(nationaliteit.datum_ingang_onderzoek[
settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END]) if is_valid_date_format(
nationaliteit.datum_ingang_onderzoek) else 0,
"datum":
nationaliteit.datum_ingang_onderzoek,
"jaar":
int(nationaliteit.datum_ingang_onderzoek[
settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END]) if is_valid_date_format(
nationaliteit.datum_ingang_onderzoek) else 0,
"maand":
int(nationaliteit.datum_ingang_onderzoek[
settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if is_valid_date_format(
nationaliteit.datum_ingang_onderzoek) else 0,
},
},
})
ingeschreven_persoon_dict["reisdocumenten"] = []
for reisdocument in persoon.reisdocument_set.all():
ingeschreven_persoon_dict["reisdocumenten"].append(
reisdocument.nummer_nederlands_reisdocument)
ingeschreven_persoon_dict["kinderen"] = []
for kind in persoon.kind_set.all():
ingeschreven_persoon_dict["kinderen"].append(
convert_kind_instance_to_dict(kind))
partners_title = None
partners_last_name_prefix = None
partners_last_name = None
partners_date = None
ingeschreven_persoon_dict["partners"] = []
for partner in persoon.partnerschap_set.all():
ingeschreven_persoon_dict["partners"].append(
convert_partner_instance_to_dict(partner))
if (not partners_last_name or
(partner.datum_ontbinding_huwelijk_geregistreerd_partnerschap
and partners_date >
partner.datum_huwelijkssluiting_aangaan_geregistreerd_partnerschap
) or
(partner.datum_ontbinding_huwelijk_geregistreerd_partnerschap == ""
and partners_date <
partner.datum_huwelijkssluiting_aangaan_geregistreerd_partnerschap
)):
(
partners_title,
partners_last_name_prefix,
partners_last_name,
partners_date,
) = _get_partner_info(partner)
ingeschreven_persoon_dict["ouders"] = []
for ouder in persoon.ouder_set.all():
ingeschreven_persoon_dict["ouders"].append(
convert_ouder_instance_to_dict(ouder))
ingeschreven_persoon_dict["naam"]["aanhef"] = get_aanhef(
persoon.voorvoegsel_geslachtsnaam_persoon,
persoon.geslachtsnaam_persoon,
partners_last_name_prefix,
partners_last_name,
persoon.aanduiding_naamgebruik,
persoon.geslachtsaanduiding,
persoon.adellijke_titel_predikaat_persoon,
partners_title,
)
ingeschreven_persoon_dict["naam"]["aanschrijfwijze"] = get_aanschrijfwijze(
persoon.voorvoegsel_geslachtsnaam_persoon,
persoon.geslachtsnaam_persoon,
persoon.voornamen_persoon,
partners_last_name_prefix,
partners_last_name,
persoon.aanduiding_naamgebruik,
persoon.geslachtsaanduiding,
persoon.adellijke_titel_predikaat_persoon,
partners_title,
)
ingeschreven_persoon_dict["naam"][
"gebruikInLopendeTekst"] = get_gebruik_in_lopende_tekst(
persoon.voorvoegsel_geslachtsnaam_persoon,
persoon.geslachtsnaam_persoon,
partners_last_name_prefix,
partners_last_name,
persoon.aanduiding_naamgebruik,
persoon.geslachtsaanduiding,
persoon.adellijke_titel_predikaat_persoon,
partners_title,
)
return ingeschreven_persoon_dict
def test_getting_reden_code_by_omschrijving_returns_0_when_not_found(self):
result = RedenCodeAndOmschrijving.get_code_from_omschrijving(
"Not found")
self.assertEqual(".", result)
def test_getting_reden_omschrijving_by_code_returns_Onbekend_when_not_found(
self):
result = RedenCodeAndOmschrijving.get_omschrijving_from_code(99999)
self.assertEqual("Onbekend", result)
def test_getting_reden_code_by_omschrijving(self):
result = RedenCodeAndOmschrijving.get_code_from_omschrijving(
self.reden_code_and_omschrijving_factory.omschrijving)
self.assertEqual(self.reden_code_and_omschrijving_factory.code, result)
def get_persoon_instance_dict(instance_xml_dict):
ingeschreven_persoon_dict = {
"burgerservicenummer":
instance_xml_dict.get("inp.bsn", "string"),
"geheimhoudingPersoonsgegevens":
instance_xml_dict.get("inp.indicatieGeheim", "string"),
"naam": {
"geslachtsnaam":
instance_xml_dict.get("geslachtsnaam", "string"),
"voorletters":
instance_xml_dict.get("voorletters", "string"),
"voornamen":
instance_xml_dict.get("voornamen", "string"),
"voorvoegsel":
instance_xml_dict.get("voorvoegselGeslachtsnaam", "string"),
"inOnderzoek": {
"geslachtsnaam":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"voornamen":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"voorvoegsel":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
"aanduidingNaamgebruik":
instance_xml_dict.get("aanduidingNaamgebruik", "string"),
},
"geboorte": {
"datum": {
"dag":
int(
instance_xml_dict.get(
"geboortedatum",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("geboortedatum")
and not isinstance(instance_xml_dict["geboortedatum"], dict)
else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("geboortedatum"))
if instance_xml_dict.get("geboortedatum")
and not isinstance(instance_xml_dict["geboortedatum"], dict)
else None,
"jaar":
int(
instance_xml_dict.get(
"geboortedatum",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("geboortedatum")
and not isinstance(instance_xml_dict["geboortedatum"], dict)
else None,
"maand":
int(
instance_xml_dict.get(
"geboortedatum",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("geboortedatum")
and not isinstance(instance_xml_dict["geboortedatum"], dict)
else None,
},
"land": {
"code":
instance_xml_dict.get("inp.geboorteLand"),
"omschrijving":
CountryCodeAndOmschrijving.get_omschrijving_from_code(
instance_xml_dict.get("inp.geboorteLand"))
if instance_xml_dict.get("inp.geboorteLand") and
not isinstance(instance_xml_dict.get("inp.geboorteLand"), dict)
else None,
},
"plaats": {
"code":
GemeenteCodeAndOmschrijving.get_code_from_omschrijving(
instance_xml_dict.get("inp.geboorteplaats", 0))
if not isinstance(instance_xml_dict.get("inp.geboorteplaats"),
dict) else 0,
"omschrijving":
instance_xml_dict.get("inp.geboorteplaats", "string"),
},
"inOnderzoek": {
"datum":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"land":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"plaats":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
},
"geslachtsaanduiding":
instance_xml_dict.get("geslachtsaanduiding", "string"),
"leeftijd":
calculate_age(instance_xml_dict.get("geboortedatum", "string")),
"datumEersteInschrijvingGBA": {
"dag":
int(
instance_xml_dict.get("inp.datumInschrijving", "19000101")
[settings.OPENPERSONEN_DAY_START:settings.OPENPERSONEN_DAY_END]
) if instance_xml_dict.get("inp.datumInschrijving") and
not isinstance(instance_xml_dict["inp.datumInschrijving"], dict)
else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("inp.datumInschrijving"))
if instance_xml_dict.get("inp.datumInschrijving") and
not isinstance(instance_xml_dict["inp.datumInschrijving"], dict)
else None,
"jaar":
int(
instance_xml_dict.get(
"inp.datumInschrijving",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("inp.datumInschrijving") and
not isinstance(instance_xml_dict["inp.datumInschrijving"], dict)
else None,
"maand":
int(
instance_xml_dict.get(
"inp.datumInschrijving",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END]) if
instance_xml_dict.get("inp.datumInschrijving") and not isinstance(
instance_xml_dict["inp.datumInschrijving"], dict) else None,
},
"kiesrecht": {
"europeesKiesrecht":
instance_xml_dict.get("ing.aanduidingEuropeesKiesrecht") == "2",
"uitgeslotenVanKiesrecht":
instance_xml_dict.get("ing.aanduidingUitgeslotenKiesrecht") == "A",
"einddatumUitsluitingEuropeesKiesrecht": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
"einddatumUitsluitingKiesrecht": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
"inOnderzoek": {
"burgerservicenummer":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get("inOnderzoek", [])
if isinstance(in_onderzoek, dict)
]),
"geslachtsaanduiding":
any([
"Persoonsgegevens" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get("inOnderzoek", [])
if isinstance(in_onderzoek, dict)
]),
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
"nationaliteit": [{
"aanduidingBijzonderNederlanderschap":
instance_xml_dict.get("inp.aanduidingBijzonderNederlanderschap",
"string")
if not isinstance(
instance_xml_dict.get(
"inp.aanduidingBijzonderNederlanderschap"),
dict,
) else 1,
"datumIngangGeldigheid": {
"dag":
int(
instance_xml_dict.get("inp.heeftAlsNationaliteit", {}).get(
"inp.datumVerkrijging",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.datumVerkrijging")
and not isinstance(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{})["inp.datumVerkrijging"],
dict,
) else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.datumVerkrijging"))
if instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.datumVerkrijging")
and not isinstance(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{})["inp.datumVerkrijging"],
dict,
) else None,
"jaar":
int(
instance_xml_dict.get("inp.heeftAlsNationaliteit", {}).get(
"inp.datumVerkrijging",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.datumVerkrijging")
and not isinstance(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{})["inp.datumVerkrijging"],
dict,
) else None,
"maand":
int(
instance_xml_dict.get("inp.heeftAlsNationaliteit", {}).get(
"inp.datumVerkrijging",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.datumVerkrijging")
and not isinstance(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{})["inp.datumVerkrijging"],
dict,
) else None,
},
"nationaliteit": {
"code":
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("gerelateerde", {}).get("code"),
"omschrijving":
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("gerelateerde",
{}).get("omschrijving"),
},
"redenOpname": {
"code":
instance_xml_dict.get("inp.heeftAlsNationaliteit", {}).get(
"inp.redenVerkrijging", ".") if not isinstance(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.redenVerkrijging"),
dict,
) else "string",
"omschrijving":
RedenCodeAndOmschrijving.get_omschrijving_from_code(
instance_xml_dict.get("inp.heeftAlsNationaliteit", {}).get(
"inp.redenVerkrijging", 0))
if not isinstance(
instance_xml_dict.get("inp.heeftAlsNationaliteit",
{}).get("inp.redenVerkrijging"),
dict,
) else 0,
},
"inOnderzoek": {
"aanduidingBijzonderNederlanderschap":
any([
"aanduidingBijzonderNederlanderschap" == in_onderzoek.get(
"elementnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"nationaliteit":
any([
"Nationaliteit" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"redenOpname":
False,
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
}],
"opschortingBijhouding": {
"reden":
instance_xml_dict.get("inp.redenOpschortingBijhouding", "string"),
"datum": {
"dag":
int(
instance_xml_dict.get(
"inp.datumOpschortingBijhouding",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("inp.datumOpschortingBijhouding")
and not isinstance(
instance_xml_dict.get("inp.datumOpschortingBijhouding"),
dict) else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("inp.datumOpschortingBijhouding"))
if instance_xml_dict.get("inp.datumOpschortingBijhouding")
and not isinstance(
instance_xml_dict.get("inp.datumOpschortingBijhouding"),
dict) else None,
"jaar":
int(
instance_xml_dict.get(
"inp.datumOpschortingBijhouding",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("inp.datumOpschortingBijhouding")
and not isinstance(
instance_xml_dict.get("inp.datumOpschortingBijhouding"),
dict) else None,
"maand":
int(
instance_xml_dict.get(
"inp.datumOpschortingBijhouding",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("inp.datumOpschortingBijhouding")
and not isinstance(
instance_xml_dict.get("inp.datumOpschortingBijhouding"),
dict) else None,
},
},
"overlijden": {
"indicatieOverleden":
instance_xml_dict.get("inp.redenOpschortingBijhouding") == "O",
"datum": {
"dag":
int(
instance_xml_dict.get(
"overlijdensdatum",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("overlijdensdatum")
and not isinstance(instance_xml_dict["overlijdensdatum"], dict)
else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("overlijdensdatum"))
if instance_xml_dict.get("overlijdensdatum")
and not isinstance(instance_xml_dict["overlijdensdatum"], dict)
else None,
"jaar":
int(
instance_xml_dict.get(
"overlijdensdatum",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("overlijdensdatum")
and not isinstance(instance_xml_dict["overlijdensdatum"], dict)
else None,
"maand":
int(
instance_xml_dict.get(
"overlijdensdatum",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("overlijdensdatum")
and not isinstance(instance_xml_dict["overlijdensdatum"], dict)
else None,
},
"land": {
"code":
instance_xml_dict.get("inp.overlijdenLand") if
not isinstance(instance_xml_dict.get("overlijdensdatum"), dict)
else None,
"omschrijving":
CountryCodeAndOmschrijving.get_omschrijving_from_code(
instance_xml_dict.get("inp.overlijdenLand"))
if instance_xml_dict.get("inp.overlijdenLand")
and not isinstance(instance_xml_dict.get("inp.overlijdenLand"),
dict) else None,
},
"plaats": {
"code":
GemeenteCodeAndOmschrijving.get_code_from_omschrijving(
instance_xml_dict.get("inp.overlijdenplaats", 0)) if
not isinstance(instance_xml_dict.get("inp.overlijdenplaats"),
dict) else 0,
"omschrijving": (instance_xml_dict.get("inp.overlijdenplaats",
"string")),
},
"inOnderzoek": {
"datum":
any([
"Overlijden" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"land":
any([
"Overlijden" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"plaats":
any([
"Overlijden" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
},
"verblijfplaats": {
"functieAdres":
"woonadres",
"huisletter":
instance_xml_dict.get("verblijfsadres",
{}).get("aoa.huisletter", "string"),
"huisnummer":
instance_xml_dict.get("verblijfsadres",
{}).get("aoa.huisnummer", "string"),
"huisnummertoevoeging":
instance_xml_dict.get("verblijfsadres",
{}).get("aoa.huisnummertoevoeging",
"string"),
"aanduidingBijHuisnummer":
None,
"identificatiecodeNummeraanduiding":
instance_xml_dict.get("verblijfsadres",
{}).get("aoa.identificatie", "string"),
"naamOpenbareRuimte":
instance_xml_dict.get("verblijfsadres",
{}).get("gor.openbareRuimteNaam", "string"),
"postcode":
instance_xml_dict.get("verblijfsadres",
{}).get("aoa.postcode", "string"),
"woonplaatsnaam":
instance_xml_dict.get("verblijfsadres",
{}).get("wpl.woonplaatsNaam", "string"),
"identificatiecodeAdresseerbaarObject":
instance_xml_dict.get("verblijfsadres",
{}).get("wpl.identificatie", "string"),
"indicatieVestigingVanuitBuitenland":
True,
"locatiebeschrijving":
instance_xml_dict.get("verblijfsadres",
{}).get("inp.locatiebeschrijving", "string"),
"straatnaam":
instance_xml_dict.get("verblijfsadres",
{}).get("gor.straatnaam", "string"),
"vanuitVertrokkenOnbekendWaarheen":
True,
"datumAanvangAdreshouding": {
"dag":
int(
instance_xml_dict.get("verblijfsadres", {}).get(
"begindatumVerblijf",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("verblijfsadres",
{}).get("begindatumVerblijf")
and not isinstance(
instance_xml_dict.get("verblijfsadres",
{})["begindatumVerblijf"],
dict,
) else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("verblijfsadres",
{}).get("begindatumVerblijf"))
if instance_xml_dict.get("verblijfsadres",
{}).get("begindatumVerblijf")
and not isinstance(
instance_xml_dict.get("verblijfsadres",
{})["begindatumVerblijf"],
dict,
) else None,
"jaar":
int(
instance_xml_dict.get("verblijfsadres", {}).get(
"begindatumVerblijf",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("verblijfsadres",
{}).get("begindatumVerblijf")
and not isinstance(
instance_xml_dict.get("verblijfsadres",
{})["begindatumVerblijf"],
dict,
) else None,
"maand":
int(
instance_xml_dict.get("verblijfsadres", {}).get(
"begindatumVerblijf",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("verblijfsadres",
{}).get("begindatumVerblijf")
and not isinstance(
instance_xml_dict.get("verblijfsadres",
{})["begindatumVerblijf"],
dict,
) else None,
},
"datumIngangGeldigheid": {
"dag":
int(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject",
"19000101")
[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject")
and not isinstance(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {})["ingangsdatumObject"],
dict,
) else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject"))
if instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject")
and not isinstance(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {})["ingangsdatumObject"],
dict,
) else None,
"jaar":
int(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject",
"19000101")
[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject")
and not isinstance(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {})["ingangsdatumObject"],
dict,
) else None,
"maand":
int(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject",
"19000101")
[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {}).get("ingangsdatumObject")
and not isinstance(
instance_xml_dict.get("inp.verblijftIn", {}).get(
"gerelateerde", {})["ingangsdatumObject"],
dict,
) else None,
},
"datumInschrijvingInGemeente": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
"datumVestigingInNederland": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
"gemeenteVanInschrijving": {
"code":
instance_xml_dict.get("inp.verblijftIn",
{}).get("gerelateerde",
{}).get("gemeenteCode"),
"omschrijving":
instance_xml_dict.get("inp.verblijftIn",
{}).get("gerelateerde",
{}).get("gemeenteNaam"),
},
"landVanwaarIngeschreven": {
"code": "",
"omschrijving": ""
},
"verblijfBuitenland": {
"adresRegel1":
instance_xml_dict.get("sub.verblijfBuitenland",
{}).get("sub.adresBuitenland1"),
"adresRegel2":
instance_xml_dict.get("sub.verblijfBuitenland",
{}).get("sub.adresBuitenland2"),
"adresRegel3":
instance_xml_dict.get("sub.verblijfBuitenland",
{}).get("sub.adresBuitenland3"),
"vertrokkenOnbekendWaarheen":
True,
"land": {
"code":
instance_xml_dict.get("sub.verblijfBuitenland",
{}).get("lnd.landcode"),
"omschrijving":
CountryCodeAndOmschrijving.get_omschrijving_from_code(
instance_xml_dict.get("sub.verblijfBuitenland",
{}).get("lnd.landcode", 0))
if not isinstance(
instance_xml_dict.get("sub.verblijfBuitenland",
{}).get("lnd.landcode"),
dict,
) else None,
},
},
"inOnderzoek": {
"aanduidingBijHuisnummer":
False,
"datumAanvangAdreshouding":
False,
"datumIngangGeldigheid":
False,
"datumInschrijvingInGemeente":
False,
"datumVestigingInNederland":
False,
"functieAdres":
False,
"gemeenteVanInschrijving":
False,
"huisletter":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"huisnummer":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"huisnummertoevoeging":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"identificatiecodeNummeraanduiding":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"identificatiecodeAdresseerbaarObject":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"landVanwaarIngeschreven":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"locatiebeschrijving":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"naamOpenbareRuimte":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"postcode":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"straatnaam":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"verblijfBuitenland":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"woonplaatsnaam":
any([
"Verblijfplaats" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
},
"gezagsverhouding": {
"indicatieCurateleRegister":
instance_xml_dict.get("ing.indicatieCurateleRegister", False),
"indicatieGezagMinderjarige":
instance_xml_dict.get("ing.indicatieGezagMinderjarige", False),
"inOnderzoek": {
"indicatieCurateleRegister":
any([
"Gezagsverhouding" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"indicatieGezagMinderjarige":
any([
"Gezagsverhouding" == in_onderzoek.get("groepsnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
},
"verblijfstitel": {
"aanduiding": {
"code": instance_xml_dict.get("vbt.aanduidingVerblijfstitel"),
"omschrijving": None,
},
"datumEinde": {
"dag":
int(
instance_xml_dict.get(
"ing.datumVerliesVerblijfstitel",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("ing.datumVerliesVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerliesVerblijfstitel"],
dict,
) else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("ing.datumVerliesVerblijfstitel",
"19000101"))
if instance_xml_dict.get("ing.datumVerliesVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerliesVerblijfstitel"],
dict,
) else None,
"jaar":
int(
instance_xml_dict.get(
"ing.datumVerliesVerblijfstitel",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("ing.datumVerliesVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerliesVerblijfstitel"],
dict,
) else None,
"maand":
int(
instance_xml_dict.get(
"ing.datumVerliesVerblijfstitel",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("ing.datumVerliesVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerliesVerblijfstitel"],
dict,
) else None,
},
"datumIngang": {
"dag":
int(
instance_xml_dict.get(
"ing.datumVerkrijgingVerblijfstitel",
"19000101")[settings.OPENPERSONEN_DAY_START:settings.
OPENPERSONEN_DAY_END])
if instance_xml_dict.get("ing.datumVerkrijgingVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerkrijgingVerblijfstitel"],
dict,
) else None,
"datum":
convert_datum_to_proper_date_format(
instance_xml_dict.get("ing.datumVerkrijgingVerblijfstitel",
"19000101"))
if instance_xml_dict.get("ing.datumVerkrijgingVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerkrijgingVerblijfstitel"],
dict,
) else None,
"jaar":
int(
instance_xml_dict.get(
"ing.datumVerkrijgingVerblijfstitel",
"19000101")[settings.OPENPERSONEN_YEAR_START:settings.
OPENPERSONEN_YEAR_END])
if instance_xml_dict.get("ing.datumVerkrijgingVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerkrijgingVerblijfstitel"],
dict,
) else None,
"maand":
int(
instance_xml_dict.get(
"ing.datumVerkrijgingVerblijfstitel",
"19000101")[settings.OPENPERSONEN_MONTH_START:settings.
OPENPERSONEN_MONTH_END])
if instance_xml_dict.get("ing.datumVerkrijgingVerblijfstitel")
and not isinstance(
instance_xml_dict["ing.datumVerkrijgingVerblijfstitel"],
dict,
) else None,
},
"inOnderzoek": {
"aanduiding":
any([
"aanduidingVerblijfstitel" == in_onderzoek.get(
"elementnaam")
for in_onderzoek in instance_xml_dict.get(
"inOnderzoek", []) if isinstance(in_onderzoek, dict)
]),
"datumEinde":
False,
"datumIngang":
False,
"datumIngangOnderzoek": {
"dag": None,
"datum": None,
"jaar": None,
"maand": None,
},
},
},
"reisdocumenten": [],
}
kinderen_info = instance_xml_dict["inp.heeftAlsKinderen"]
ouders_info = instance_xml_dict["inp.heeftAlsOuders"]
partners_info = instance_xml_dict["inp.heeftAlsEchtgenootPartner"]
if not isinstance(kinderen_info, list):
kinderen_info = [kinderen_info]
if not isinstance(ouders_info, list):
ouders_info = [ouders_info]
if not isinstance(partners_info, list):
partners_info = [partners_info]
ingeschreven_persoon_dict["kinderen"] = []
ingeschreven_persoon_dict["ouders"] = []
ingeschreven_persoon_dict["partners"] = []
for kind_info in kinderen_info:
if "gerelateerde" in kind_info:
ingeschreven_persoon_dict["kinderen"].append(
get_kind_instance_dict(kind_info["gerelateerde"]))
for ouder_info in ouders_info:
if "gerelateerde" in ouder_info:
ingeschreven_persoon_dict["ouders"].append(
get_ouder_instance_dict(ouder_info["gerelateerde"]))
partners_title = None
partners_last_name_prefix = None
partners_last_name = None
partners_date = None
for partner_info in partners_info:
if "gerelateerde" in partner_info:
ingeschreven_persoon_dict["partners"].append(
get_partner_instance_dict(partner_info["gerelateerde"]))
if (not partners_last_name
or (partner_info.get("datumOntbinding") and partners_date
and partners_date > partner_info["datumSluiting"]) or
(partner_info.get("datumOntbinding") is None and partners_date
and partners_date < partner_info["datumSluiting"])):
(
partners_title,
partners_last_name_prefix,
partners_last_name,
partners_date,
) = _get_partner_info(partner_info)
ingeschreven_persoon_dict["naam"]["aanhef"] = get_aanhef(
instance_xml_dict.get("voorvoegselGeslachtsnaam"),
instance_xml_dict.get("geslachtsnaam"),
partners_last_name_prefix,
partners_last_name,
instance_xml_dict.get("aanduidingNaamgebruik"),
instance_xml_dict.get("geslachtsaanduiding"),
instance_xml_dict.get("adellijkeTitelPredikaat"),
partners_title,
)
ingeschreven_persoon_dict["naam"]["aanschrijfwijze"] = get_aanschrijfwijze(
instance_xml_dict.get("voorvoegselGeslachtsnaam"),
instance_xml_dict.get("geslachtsnaam"),
instance_xml_dict.get("voornamen"),
partners_last_name_prefix,
partners_last_name,
instance_xml_dict.get("aanduidingNaamgebruik"),
instance_xml_dict.get("geslachtsaanduiding"),
instance_xml_dict.get("adellijkeTitelPredikaat"),
partners_title,
)
ingeschreven_persoon_dict["naam"][
"gebruikInLopendeTekst"] = get_gebruik_in_lopende_tekst(
instance_xml_dict.get("voorvoegselGeslachtsnaam"),
instance_xml_dict.get("geslachtsnaam"),
partners_last_name_prefix,
partners_last_name,
instance_xml_dict.get("aanduidingNaamgebruik"),
instance_xml_dict.get("geslachtsaanduiding"),
instance_xml_dict.get("adellijkeTitelPredikaat"),
partners_title,
)
convert_empty_instances(ingeschreven_persoon_dict)
return ingeschreven_persoon_dict