#ifdef PRS
/*
 *  $Revision$
 *  $Id$
 */

CREATE OR REPLACE PACKAGE aut AS
  FUNCTION fac_get_prs_same_level(userkey IN NUMBER, perslidkey IN NUMBER) RETURN NUMBER;
END aut;
/

CREATE OR REPLACE PACKAGE BODY aut AS

  FUNCTION fac_get_prs_same_level(userkey IN NUMBER, perslidkey IN NUMBER) RETURN NUMBER IS
  CURSOR usr_deps IS
   SELECT paf.prs_afdeling_key, prs_afdeling_elder_key, niveau
      FROM prs_v_afdeling_familie paf, prs_perslid pp
     WHERE paf.prs_afdeling_key = pp.prs_afdeling_key
       AND pp.prs_perslid_key=userkey
    ORDER BY niveau DESC;

  CURSOR pers_deps IS
   SELECT paf.prs_afdeling_key, prs_afdeling_elder_key, niveau
      FROM prs_v_afdeling_familie paf, prs_perslid pp
     WHERE paf.prs_afdeling_key = pp.prs_afdeling_key
       AND pp.prs_perslid_key=perslidkey
    ORDER BY niveau DESC;

  usr_orglevel		NUMBER(1);
  pers_orglevel		NUMBER(1);
  samelevelFound	BOOLEAN;
  samelevel		NUMBER(1);

  BEGIN
    BEGIN
      samelevelFound := FALSE;
      FOR c1 IN usr_deps
      LOOP
        FOR c2 IN pers_deps
        LOOP
          IF c1.prs_afdeling_elder_key = c2.prs_afdeling_elder_key
          THEN
            samelevelFound := TRUE;
            samelevel := c2.niveau;
            EXIT;
          END IF;
        END LOOP;
        IF samelevelFound
        THEN
          EXIT;
        END IF;
      END LOOP;
      IF NOT samelevelFound
      THEN
        samelevel := 0; 	-- no same level found,then assume same company
      END IF;			-- multi_company will be detected in ASP so no problem here
    EXCEPTION
      WHEN OTHERS THEN
        samelevel:= 9;
    END;
    RETURN samelevel;
  END;
END aut;
/

/* Formatted on 3-11-2010 11:50:08 (QP5 v5.136.908.31019) */
CREATE OR REPLACE PACKAGE prs
AS
   FUNCTION getkpverantwoordelijke (pkostenplaats_key IN NUMBER,
                                    pmethode IN NUMBER,
                                    pexcludekey IN NUMBER)
      RETURN NUMBER;

   FUNCTION getkostenplaats (pperslid_key IN NUMBER, pmethode IN NUMBER, pexcludekey IN NUMBER)
      RETURN NUMBER;

   FUNCTION getprofiellimiet (pperslidkey IN NUMBER, pdisckey IN NUMBER)
      RETURN NUMBER;

   FUNCTION getlimietagb (pkostenplaatskey IN NUMBER, pmethode IN NUMBER, pdisckey IN NUMBER)
      RETURN NUMBER;

   FUNCTION getfiatteur (pkostenplaats_key   IN NUMBER,
                         pexcludekey         IN NUMBER,
                         pondergrens         IN NUMBER,
                         pdisckey            IN NUMBER,
                         pfiatbedrag         IN NUMBER DEFAULT -1
                        )
      RETURN NUMBER;

   FUNCTION nextfiatteur (pkey        IN NUMBER,
                          pmodule     IN VARCHAR2,
                          pexcludekey IN NUMBER DEFAULT -1)
      RETURN NUMBER;

   PROCEDURE setpassword(pperslidkey IN NUMBER, pwachtwoord IN VARCHAR2);

   FUNCTION testpassword(pperslidkey IN NUMBER, pwachtwoord IN VARCHAR2)
      RETURN NUMBER;

   PROCEDURE upsertkenmerk (p_kenmerk_key IN NUMBER, p_prs_key IN NUMBER, p_waarde IN VARCHAR2);

   PROCEDURE movetoruimte (p_prs_key IN NUMBER, p_ruimte_key IN NUMBER, p_alg_type IN VARCHAR2, p_virtual IN NUMBER DEFAULT 0);

   PROCEDURE import_perslid (p_import_key IN NUMBER, p_seq_of_columns IN VARCHAR2, p_header IN VARCHAR2);

   PROCEDURE update_perslid (p_import_key IN NUMBER, p_sleutelkolom IN VARCHAR2, p_alg_type IN VARCHAR2, p_import_kenmerk IN NUMBER DEFAULT 0);

   PROCEDURE delete_perslid (p_import_key IN NUMBER, p_perslid_key IN NUMBER);

   PROCEDURE set_afdeling_verwijder (p_afdeling_key IN NUMBER);

   FUNCTION combinatievalidatie (p_kp_key IN NUMBER, p_ksrt_key IN NUMBER, p_disc_key IN NUMBER) RETURN BOOLEAN;
   PROCEDURE personen_inactief_schonen;
   PROCEDURE personen_vervangers_schonen;
END prs;
/

CREATE OR REPLACE PACKAGE BODY prs
AS
   -- Levert de prs_perslid_key op van de budgethouder van een kostenplaats
   -- Simpele versie van getfiatteur: hij negeert limieten
   FUNCTION getkpverantwoordelijke (pkostenplaats_key IN NUMBER,
                                    pmethode IN NUMBER, -- deze gebruiken we eigenlijk niet meer sinds 2017.2
                                    pexcludekey IN NUMBER)
      RETURN NUMBER
   IS
   BEGIN
    IF pmethode = 3 THEN
        raise_application_error (-20001, 'Cannot use prs.getkpverantwoordelijke with prs_approvemethod = 3');
    END IF;
    RETURN  getfiatteur (pkostenplaats_key,
                         pexcludekey,
                         NULL,
                         NULL
                        );
   END;

   -- Levert de prs_kostenplaats_key op van de persoon volgens
   -- de door ons gedefinieerde regels.
   -- Levert -1 op indien er geen gevonden wordt.
   -- Controleert niet of de meegegeven persoon nog wel actief is
   -- pmethode geeft .. inderdaad, waarbij
   -- methode 1 = 1-laagsmethode via eigen afdeling - kostenplaats
   -- methode 2 = n-laagsmethode via afdelingsboom
   -- Met pexcludekey kan een kostenplaats_key worden opgegeven die je niet wilt
   -- Dat leek me wel een aardige feature. Geef -1 mee als je geen kostenplaats wilt excluden
   FUNCTION getkostenplaats (pperslid_key IN NUMBER, pmethode IN NUMBER, pexcludekey IN NUMBER)
      RETURN NUMBER
   IS
      lkostenplaatskey prs_afdeling.prs_kostenplaats_key%TYPE;
      lparentafdkey prs_afdeling.prs_afdeling_parentkey%TYPE;
   BEGIN
      BEGIN
         SELECT   COALESCE (a.prs_kostenplaats_key, -1),
                  a.prs_afdeling_parentkey
           INTO   lkostenplaatskey,
                  lparentafdkey
           FROM   prs_perslid p,
                  prs_afdeling a
          WHERE   p.prs_afdeling_key = a.prs_afdeling_key
            AND   p.prs_perslid_key = pperslid_key;
      EXCEPTION
         WHEN NO_DATA_FOUND
         THEN
            -- persoon bestaat niet
            RETURN -1;
      END;

      IF (lkostenplaatskey = -1 OR lkostenplaatskey = pexcludekey) AND pmethode = 2
      -- doorloop de boom naar boven, met allerlei aannames
      THEN
         WHILE (lkostenplaatskey = -1 OR lkostenplaatskey = pexcludekey) AND lparentafdkey IS NOT NULL
         LOOP
            SELECT   COALESCE (a.prs_kostenplaats_key, -1),
                     a.prs_afdeling_parentkey
              INTO   lkostenplaatskey,
                     lparentafdkey
              FROM   prs_afdeling a
             WHERE   a.prs_afdeling_verwijder IS NULL
                     AND a.prs_afdeling_key = lparentafdkey;
         END LOOP;
      -- nu heb ik er een of kan ik er geen vinden
      END IF;

      RETURN lkostenplaatskey;
   END;

    -- Levert de limiet (maximaal bestelbedrag) van persoon pperslidkey,
    -- eventueel specifiek voor pdisckey indien dat gedefinieerd zou zijn.
   FUNCTION getprofiellimiet (pperslidkey IN NUMBER, pdisckey IN NUMBER)
      RETURN NUMBER
   IS
      llimiet fac_profiel.fac_profiel_limiet%TYPE;
   BEGIN
      -- de algemene limiet telt het zwaarst indien ingevuld
      IF pperslidkey IS NULL
      THEN
        RETURN NULL;
      END IF;
      -- persoon wordt geacht te bestaan, profiel is optioneel
      SELECT   fp.fac_profiel_limiet
        INTO   llimiet
        FROM   prs_perslid p, fac_profiel fp
       WHERE   p.fac_profiel_key = fp.fac_profiel_key(+) AND p.prs_perslid_key = pperslidkey;

      IF llimiet IS NULL AND pdisckey IS NOT NULL
      THEN
         -- geen algemene limiet; zoek de disciplineafhankelijke (max() to prevent no data found)
         SELECT   MAX (fpw.fac_profielwaarde_limiet)
           INTO   llimiet
           FROM   prs_perslid p, fac_profielwaarde fpw
          WHERE       p.fac_profiel_key = fpw.fac_profiel_key
                  AND fpw.ins_discipline_key = pdisckey
                  AND p.prs_perslid_key = pperslidkey;
      END IF;

      RETURN llimiet;
   END;

    -- Levert de limiet (maximaal bestelbedrag) van persoon pperslidkey i.v.m. Afdelings Gebonden Budget (AGB),
   FUNCTION getlimietagb (pkostenplaatskey IN NUMBER, pmethode IN NUMBER, pdisckey IN NUMBER)
      RETURN NUMBER
   IS
      llimiet prs_kostenplaats.prs_kostenplaats_limiet%TYPE;
   BEGIN
      IF pkostenplaatskey > 0
      THEN
        -- Er is een kostenplaats meegegeven
        SELECT k.prs_kostenplaats_limiet
          INTO llimiet
          FROM prs_kostenplaats k
          WHERE k.prs_kostenplaats_key = pkostenplaatskey;
        -- AGB per kostenplaats of catalogus
        IF llimiet IS NULL
        THEN
          BEGIN
            SELECT prs_kostenplaatsdisc_limiet
              INTO llimiet
              FROM prs_kostenplaatsdisc
             WHERE prs_kostenplaats_key = pkostenplaatskey
               AND ins_discipline_key = pdisckey;
          EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
               -- er is geen limiet voor deze kostenplaats-discipline.
              RETURN NULL;
          END;
        END IF;
      ELSE
        RETURN NULL;
      END IF;

      RETURN llimiet;
   END;

   -- De functie levert de prs_perslid_key op van de perslid die een item (opdracht/bestelling) van
   -- discipline pdisckey boven bedrag COALESCE(pfiatbedrag, pondergrens) mag fiatteren
   -- volgens de door ons gedefinieerde regels. Werkt analoog aan getkpverantwoordelijke
   -- Maar houdt hierbij rekening met de profielen van de budgethouders als prs_approvemethod == 3
   --
   -- 1) Levert dus in eerste instantie de kostenplaatsverantwoordelijke (budgethouder) op.
   -- 2) Levert de kostenplaatsgroepverantwoordelijke op indien geen goede budgethouder wordt gevonden.
   --    Afhankelijk van de pfiatbedrag levert de functie dan de kostenplaatsgroepverantwoordelijke op
   --    die boven het bedrag van COALESCE(pfiatbedrag, pondergrens) mag fiatteren.
   --    Als er in dat geval WEL een pfiatbedrag wordt meegegeven dan wordt de VOLGENDE (kpg) fiatteur opgeleverd.
   --    Als er in dat geval GEEN pfiatbedrag wordt meegegeven dan wordt de LAATSTE (kpg) fiatteur opgeleverd.
   --    De parameter pondergrens wordt ook gebruikt voor mode 3 om het profiel van de budgethouder te controleren. Daarom extra parameter pfiatbedrag nodig.
   --
   -- Als pexcludekey gevuld is, dan is dit de kp verantwoordelijke. Niet vullen met een kpGROEP verantwoordelijke, want dan wordt de kp verantwoordelijke teruggegeven.
   -- Het fiatbedrag (of pondergrens) zorgt er wel voor dat je juiste kpg verantwoordelijke wordt teruggegeven.
   --
   FUNCTION getfiatteur (pkostenplaats_key   IN NUMBER,
                         pexcludekey         IN NUMBER,
                         pondergrens         IN NUMBER,
                         pdisckey            IN NUMBER,
                         pfiatbedrag         IN NUMBER DEFAULT -1
                        )
      RETURN NUMBER
   IS
      lkpverantwkey prs_kostenplaats.prs_perslid_key%TYPE;
      lkpgverantwkey prs_kostenplaatsgrp.prs_perslid_key%TYPE;
      lkpgverantwkey1 prs_kostenplaatsgrp.prs_perslid_key%TYPE;
      lkpgverantwkey2 prs_kostenplaatsgrp.prs_kostenplaatsgrp_fiat2_key%TYPE;
      lkpgverantwkey3 prs_kostenplaatsgrp.prs_kostenplaatsgrp_fiat3_key%TYPE;
      lkpgfinlimit1 prs_kostenplaatsgrp.prs_kostenplaatsgrp_fin_limit1%TYPE;
      lkpgfinlimit2 prs_kostenplaatsgrp.prs_kostenplaatsgrp_fin_limit2%TYPE;
      lexcludeisvervanger NUMBER;
      lexcludeiskpgverantw NUMBER;
      lkpverantwlimiet fac_profiel.fac_profiel_limiet%TYPE;
      afdkey prs_afdeling.prs_afdeling_key%TYPE;
      parentafdkey prs_afdeling.prs_afdeling_parentkey%TYPE;
      lmethode NUMBER;
      lteller NUMBER;
      lfoundfiatteur NUMBER;
      lfiatteur prs_kostenplaats.prs_perslid_key%TYPE;
      llastfiat	BOOLEAN;
      lgrens NUMBER;
   BEGIN
      BEGIN
         lkpverantwkey := -1;
         SELECT   COALESCE (prs_perslid_key, -1)
           INTO   lkpverantwkey
           FROM   prs_kostenplaats
          WHERE   prs_kostenplaats_key = pkostenplaats_key;
      EXCEPTION
         WHEN NO_DATA_FOUND
         THEN
            -- Kostenplaats bestaat niet.
            RETURN -1;
      END;
      dbms_output.put_line('Budgethouder: '||lkpverantwkey);
      -- De lkpverantwkey is (mits gedefinieerd) de budgethouder van de kp. Het is nog niet gezegd of dit de gevraagde fiatteur is.
      -- Is de meegegeven pexcludekey wellicht een vervanger van kostenplaatsverantwoordelijke van de kostenplaats?
      -- Zo ja, dan is in dat geval lkpverantwkey de pexcludekey.
      IF pexcludekey > 0 AND lkpverantwkey <> pexcludekey THEN
          SELECT COUNT(prs_perslid_key)
            INTO lexcludeisvervanger
            FROM prs_collega
           WHERE prs_perslid_key_alt = pexcludekey
             AND prs_perslid_key = lkpverantwkey;
      END IF;
      dbms_output.put_line('ExcludeIsVervanger: '||lexcludeisvervanger);
      lmethode := fac.getSetting('prs_approvemethod');
      dbms_output.put_line('Approvemethod: '||lmethode);
      dbms_output.put_line('Ondergrens: '||pondergrens);

      IF lmethode = 3 AND lkpverantwkey > 0
      THEN -- ook profiel budgethouder controleren
        lkpverantwlimiet := prs.getprofiellimiet (lkpverantwkey, pdisckey);
        dbms_output.put_line('Zijn limiet: '||lkpverantwlimiet);
        IF (lkpverantwlimiet < pondergrens) -- lkpverantwkey != -1 is impliciet in die limiet
        THEN -- het profiel van deze budgethouder is niet genoeg
          lkpverantwkey := -1; -- Niet meer interessant wie dit was.
        END IF;
      END IF;

      -- Mode 2 en 3: Doorloop de afdeling boom indien de kostenplaats geen verantwoordelijke heeft. Voor mode 3 ook profiel budgethouder controleren.
      IF lkpverantwkey = -1 AND (lmethode = 2 OR lmethode = 3)
      -- Doorloop de boom naar boven, met allerlei aannames.
      THEN
        dbms_output.put_line('We gaan de boom in');
         -- Waar hoort deze kp bij?
         BEGIN
            SELECT   prs_afdeling_key, prs_afdeling_parentkey
              INTO   afdkey, parentafdkey
              FROM   prs_afdeling
             WHERE   prs_kostenplaats_key = pkostenplaats_key AND prs_afdeling_verwijder IS NULL;
         EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
               -- De kostenplaats is niet aan een afdeling gerelateerd, dan weet ik het met deze methode niet.
               RETURN -1;
         END;
         -- Zolang nog geen goede en we kunnen hogerop.
         WHILE (lkpverantwkey = -1 OR lkpverantwkey = pexcludekey OR lexcludeisvervanger = 1)
              AND parentafdkey IS NOT NULL
         LOOP
            SELECT   COALESCE (k.prs_perslid_key, -1), prs_afdeling_parentkey
              INTO   lkpverantwkey, parentafdkey
              FROM   prs_kostenplaats k, prs_afdeling a
             WHERE       k.prs_kostenplaats_key(+) = a.prs_kostenplaats_key
                     AND a.prs_afdeling_verwijder IS NULL
                         AND a.prs_afdeling_key = parentafdkey;
            dbms_output.put_line('Volgende budgethouder: '||lkpverantwkey);

            IF lmethode = 3 THEN -- Ook profiel budgethouder controleren.
              lkpverantwlimiet := prs.getprofiellimiet (lkpverantwkey, pdisckey);
              dbms_output.put_line('Zijn limiet B: '||lkpverantwlimiet);
              IF (lkpverantwlimiet < pondergrens)
              THEN -- het profiel van deze budgethouder is niet genoeg
                lkpverantwkey := -1; -- Niet meer interessant wie dit was.
              END IF;
            END IF;

            IF pexcludekey > 0 AND lkpverantwkey <> pexcludekey THEN
                SELECT COUNT(prs_perslid_key)
                  INTO lexcludeisvervanger
                  FROM prs_collega
                 WHERE prs_perslid_key_alt = pexcludekey
                   AND prs_perslid_key = lkpverantwkey;
            END IF;
         END LOOP;
      -- Nu heb ik er een of kan ik er geen vinden.
      END IF;
      dbms_output.put_line('Gevonden budgethouder voor de kpgroep-tak: '||lkpverantwkey);
      -- Als 1) de methode 1 is of
      --     2) de methode 2 of 3 is en dit niemand opleverde (ondanks afdelingskostenplaats) of
      --     3) de opgeleverde kostenplaatsverandwoordelijke de exclude(vervanger) is
      -- dan kpngroepverantwoordelijken opvragen en kijken wie van hen de gevraagde fiatteur is.
      IF lkpverantwkey = -1 OR lkpverantwkey = pexcludekey OR lexcludeisvervanger = 1
      THEN
         -- Vindt de kostenplaatsGROEPverantwoordelijken van de altijd meegegeven kostenplaats.
         BEGIN
            SELECT COALESCE(kg.prs_perslid_key, -1),
                   COALESCE(kg.prs_kostenplaatsgrp_fiat2_key, -1),
                   COALESCE(kg.prs_kostenplaatsgrp_fiat3_key, -1),
                   COALESCE(kg.prs_kostenplaatsgrp_fin_limit1, fac.safe_To_Number(fac.getsetting ('mld_opdr_kpg_fin_limit1'))),
                   COALESCE(kg.prs_kostenplaatsgrp_fin_limit2, fac.safe_To_Number(fac.getsetting ('mld_opdr_kpg_fin_limit2')))
              INTO lkpgverantwkey1,
                   lkpgverantwkey2,
                   lkpgverantwkey3,
                   lkpgfinlimit1,
                   lkpgfinlimit2
              FROM prs_kostenplaats k,
                   prs_kostenplaatsgrp kg
             WHERE prs_kostenplaats_key = pkostenplaats_key
               AND kg.prs_kostenplaatsgrp_key = k.prs_kostenplaatsgrp_key;
         EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
               -- Er is geen kpgroep bij.
               RETURN -1;
         END;

         lteller := 1;
         lfoundfiatteur := 0;
         lfiatteur := -1;

         -- Als er WEL een fiatbedrag is meegegeven dan de VOLGENDE fiatteur opleveren. De ondergrens is dan het fiatbedrag (pfiatbedrag).
         -- Als er GEEN fiatbedrag is meegegeven dan de LAATSTE fiatteur opleveren. De ondergrens is dan pondergrens (normaalgesproken het totale opdrachtbedrag).
         IF pfiatbedrag >= 0
         THEN
             lgrens := pfiatbedrag; -- De volgende fiatteur opleveren.
         ELSE
             lgrens := pondergrens; -- De laatste fiatteur opleveren.
         END IF;

         WHILE lteller <= 3 AND lfoundfiatteur = 0
         LOOP
             CASE
             WHEN lteller = 1
             THEN
                lkpgverantwkey := lkpgverantwkey1;
                llastfiat := lgrens < lkpgfinlimit1;
             WHEN lteller = 2
             THEN
                lkpgverantwkey := lkpgverantwkey2;
                llastfiat := lgrens < lkpgfinlimit2;
             WHEN lteller = 3
             THEN
                lkpgverantwkey := lkpgverantwkey3;
                llastfiat := lgrens >= lkpgfinlimit2 OR
                             lexcludeiskpgverantw = 1; -- Als de 2de fiatteur de exclude is dan moet de 3de fiatteur toch nog fiatteren.
             END CASE;

             IF lkpgverantwkey = pexcludekey
             THEN
                 lexcludeiskpgverantw := 1;
             ELSE
                 SELECT CASE
                        WHEN COUNT(prs_perslid_key) > 0
                        THEN 1
                        ELSE 0
                        END
                   INTO lexcludeiskpgverantw
                   FROM prs_collega
                  WHERE prs_perslid_key_alt = pexcludekey
                    AND prs_perslid_key = lkpgverantwkey;
             END IF;

             IF lexcludeiskpgverantw = 0 AND llastfiat
             THEN
                 lfiatteur := lkpgverantwkey;
                 lfoundfiatteur := 1;
             END IF;
             lteller := lteller + 1;
         END LOOP;
      ELSE
        lfiatteur := lkpverantwkey;
      END IF;
      dbms_output.put_line('Resultaat budgethouder: '||lfiatteur);
      RETURN lfiatteur;
   END;

   -- Levert de volgende fiatteur in de rij op. Indien geen volgende fiatteur gevonden kan worden wordt -1 teruggegeven.
   -- Er wordt hier niet gecontroleerd of de opdracht gefiatteerd dient te worden. Dat dien je voor de aanroep te bepalen.
   -- LET OP: Als de eerste fiatteur is verwijderd dan wordt bij het herfiatteren van een meldingen geen fiatteur meer gevonden.
   --         Dan moet de functie prs.getfiatteur worden gebruikt (BLCC#80088).
   FUNCTION nextfiatteur (pkey        IN NUMBER,
                          pmodule     IN VARCHAR2,
                          pexcludekey IN NUMBER DEFAULT -1)
      RETURN NUMBER
   IS
      lnextfiatteur prs_kostenplaats.prs_perslid_key%TYPE;
   BEGIN
       CASE pmodule
       WHEN 'MLD'
       THEN
           SELECT CASE
                  WHEN mld_opdr_fiatbedrag IS NULL
                  -- I.v.m. herfiattering hier niet meer met de 'ORDFOK' tracking gecontroleerd of de kp verantvoordelijke al gefiatteerd heeft,
                  -- maar hier kijken naar het gefiatteerde bedrag die is opgeslagen in het veld mld_opdr.mld_opdr_fiatbedrag.
                  -- Met Melding AASA#55601 wordt het veld mld_opdr.mld_opdr_fiatbedrag leeg gemaakt als de setting "mld_opdr_refiat_preference" op 1 staat
                  -- en de goedkeurder heeft aangegeven dat de opdracht opnieuw als een nieuwe opdracht moet worden gefiatteerd.
                  -- Er kan dan in dat geval nagegaan worden tot welk bedrag er is gefiatteerd.
                  THEN
                     prs.getfiatteur(o.prs_kostenplaats_key, pexcludekey, mld_opdr_kosten, std.mld_ins_discipline_key, COALESCE(mld_opdr_fiatbedrag, 0))
                  WHEN mld_opdr_fiatbedrag >= COALESCE(kpg.prs_kostenplaatsgrp_fin_limit2, fac.safe_To_Number(fac.getsetting ('mld_opdr_kpg_fin_limit2')))
                  THEN
                     COALESCE(prs_kostenplaatsgrp_fiat3_key, -1)
                  WHEN mld_opdr_fiatbedrag >= COALESCE(kpg.prs_kostenplaatsgrp_fin_limit1, fac.safe_To_Number(fac.getsetting ('mld_opdr_kpg_fin_limit1')))
                  THEN
                     COALESCE(prs_kostenplaatsgrp_fiat2_key, -1)
                  ELSE
                     COALESCE(kpg.prs_perslid_key, -1)
                  END nextfiatteur
             INTO lnextfiatteur
             FROM mld_opdr o,
                  mld_melding m,
                  mld_stdmelding std,
                  prs_kostenplaats kp,
                  prs_kostenplaatsgrp kpg
            WHERE o.mld_melding_key = m.mld_melding_key
              AND m.mld_stdmelding_key = std.mld_stdmelding_key
              AND o.prs_kostenplaats_key = kp.prs_kostenplaats_key(+)
              AND kp.prs_kostenplaatsgrp_key = kpg.prs_kostenplaatsgrp_key(+)
              AND o.mld_opdr_key = pkey;
       WHEN 'BES'
       THEN
           SELECT CASE
                      WHEN bes_bestelling_fiat_user IS NULL
                      -- I.v.m. herfiattering hier niet meer met de 'BESFIT' tracking gecontroleerd of de kp verantvoordelijke al gefiatteerd heeft,
                      -- maar hier kijken naar het gefiatteerde bedrag die is opgeslagen in het veld bes_bestelling.bes_bestelling_fiat_user.
                      -- Bij herfiattering wordt dit veld leeg gemaakt zodat de bestelling weer als een nieuwe bestelling moet worden gefiatteerd (AAIT#79538).
                      THEN
                          prs.getfiatteur(b.prs_kostenplaats_key, pexcludekey, binfo.totaal, binfo.ins_discipline_key, COALESCE(bes_bestelling_fiatbedrag, -1))
                      WHEN bes_bestelling_fiatbedrag >= COALESCE(kpg.prs_kostenplaatsgrp_fin_limit2, fac.safe_To_Number(fac.getsetting ('mld_opdr_kpg_fin_limit2')))
                      THEN
                          COALESCE(prs_kostenplaatsgrp_fiat3_key, -1)
                      WHEN bes_bestelling_fiatbedrag >= COALESCE(kpg.prs_kostenplaatsgrp_fin_limit1, fac.safe_To_Number(fac.getsetting ('mld_opdr_kpg_fin_limit1')))
                      THEN
                          COALESCE(prs_kostenplaatsgrp_fiat2_key, -1)
                      ELSE
                          COALESCE(kpg.prs_perslid_key, -1)
                  END
                      nextfiatteur
             INTO lnextfiatteur
             FROM bes_bestelling b,
                  (SELECT MAX(bsg.ins_discipline_key) ins_discipline_key,
                          SUM(bi.bes_bestelling_item_aantal * bi.bes_bestelling_item_prijs) totaal
                     FROM bes_bestelling_item bi,
                          bes_srtdeel bsd,
                          bes_srtgroep bsg
                    WHERE bi.bes_srtdeel_key = bsd.bes_srtdeel_key
                      AND bsd.bes_srtgroep_key = bsg.bes_srtgroep_key
                      AND bes_bestelling_key = pkey) binfo,
                  prs_kostenplaats kp,
                  prs_kostenplaatsgrp kpg
            WHERE b.prs_kostenplaats_key = kp.prs_kostenplaats_key(+)
              AND kp.prs_kostenplaatsgrp_key = kpg.prs_kostenplaatsgrp_key(+)
              AND b.bes_bestelling_key = pkey;
       END CASE;
       RETURN lnextfiatteur;
   END;

  PROCEDURE setpassword(pperslidkey IN NUMBER, pwachtwoord IN VARCHAR2)
  IS
  BEGIN
      IF pwachtwoord IS NULL
      THEN
          UPDATE prs_perslid
             SET prs_perslid_salt = NULL,
                 prs_perslid_wachtwoord_hash = NULL,
                 prs_perslid_wachtwoord_exp = NULL,
                 prs_perslid_otpsecret = NULL
           WHERE prs_perslid_key = pperslidkey;
      ELSE
          UPDATE prs_perslid
             SET prs_perslid_salt = DBMS_RANDOM.string ('a', 32)
           WHERE prs_perslid_key = pperslidkey;
          UPDATE prs_perslid
             SET prs_perslid_wachtwoord_hash = fac.makehash(prs_perslid_salt || pwachtwoord),
                 prs_perslid_wachtwoord_exp = CASE WHEN fac.getsetting ('prs_password_expiration') > 0
                                                   THEN SYSDATE + fac.getsetting ('prs_password_expiration')
                                                   ELSE NULL
                                              END
           WHERE prs_perslid_key = pperslidkey;
      END IF;
  END;

  FUNCTION testpassword(pperslidkey IN NUMBER, pwachtwoord IN VARCHAR2)
    RETURN NUMBER
  IS
      perslid_key prs_perslid.prs_perslid_key%TYPE;
  BEGIN
      IF pwachtwoord IS NULL
      THEN
          RETURN 0;
      END IF;
      BEGIN
          SELECT prs_perslid_key
            INTO perslid_key
            FROM prs_perslid
           WHERE fac.testhash(prs_perslid_wachtwoord_hash, prs_perslid_salt || pwachtwoord) = 1
             AND prs_perslid_key = pperslidkey;
      EXCEPTION
        WHEN NO_DATA_FOUND
          THEN RETURN 0;
      END;
      RETURN 1;
  END;

  -- Er wordt nu niet getrackt (wat eigenlijk niet zo goed is)
  PROCEDURE upsertkenmerk (p_kenmerk_key   IN NUMBER,
                           p_prs_key       IN NUMBER,
                           p_waarde        IN VARCHAR2)
  IS
      v_count    NUMBER;
      v_niveau   prs_kenmerk.prs_kenmerk_niveau%TYPE;
  BEGIN
      -- niveau van prs_kenmerk ophalen, omdat deze ook in prs_kenmerklink wordt opgeslagen
      SELECT prs_kenmerk_niveau
        INTO v_niveau
        FROM prs_kenmerk
       WHERE prs_kenmerk_key = p_kenmerk_key;

      SELECT COUNT ( * )
        INTO v_count
        FROM prs_kenmerklink
       WHERE     prs_link_key = p_prs_key
             AND prs_kenmerk_key = p_kenmerk_key
             AND prs_kenmerklink_verwijder IS NULL;

      IF v_count = 1
      THEN
          IF p_waarde IS NULL
          THEN
              DELETE prs_kenmerklink
               WHERE     prs_link_key = p_prs_key
                     AND prs_kenmerk_key = p_kenmerk_key
                     AND prs_kenmerklink_verwijder IS NULL;
          ELSE
              UPDATE prs_kenmerklink
                 SET prs_kenmerklink_waarde = p_waarde
               WHERE     prs_link_key = p_prs_key
                     AND prs_kenmerk_key = p_kenmerk_key
                     AND prs_kenmerklink_verwijder IS NULL;
          END IF;
      ELSE
          IF p_kenmerk_key IS NOT NULL AND p_waarde IS NOT NULL
          THEN
              INSERT INTO prs_kenmerklink (prs_kenmerk_key,
                                           prs_link_key,
                                           prs_kenmerklink_niveau,
                                           prs_kenmerklink_waarde)
                  VALUES (p_kenmerk_key,
                          p_prs_key,
                          v_niveau,
                          p_waarde);
          END IF;
      END IF;
  END;
   -- Verhuist een persoon p_prs_key naar een werkplek in p_ruimte_key
   -- Als er al vaste werkplekken waren binnen het niveau van p_alg_type (R,V,G,L,D,NULL,A)
   -- dan worden die geleegd/gewist. Bij NULL wordt niks gewist, bij A wordt altijd gewist.
   PROCEDURE movetoruimte (p_prs_key      IN NUMBER,
                           p_ruimte_key   IN NUMBER,
                           p_alg_type     IN VARCHAR2,
                           p_virtual      IN NUMBER DEFAULT 0)
    IS
        v_count       NUMBER;
        v_wp_key      NUMBER (10);
        v_wp_volgnr   prs_werkplek.prs_werkplek_volgnr%TYPE;
        v_ruimte_nr   alg_ruimte.alg_ruimte_nr%TYPE;
        v_wp_oms      prs_werkplek.prs_werkplek_omschrijving%TYPE;
        v_alg_key     NUMBER (10);
    BEGIN
        -- Bepalen of werkplek gewijzigd is tov de huidige situatie
        -- door te tellen hoe vaak (1) we al in de nieuwe situatie zitten
        SELECT COUNT ( * )
          INTO v_count
          FROM prs_perslidwerkplek pw, prs_werkplek wp
         WHERE     pw.prs_perslid_key = p_prs_key
               AND pw.prs_werkplek_key = wp.prs_werkplek_key
               AND wp.prs_alg_ruimte_key = p_ruimte_key
               AND wp.prs_werkplek_type = 0  -- alleen vaste plekken
               AND wp.prs_werkplek_virtueel = p_virtual;

        IF (v_count = 0)
        THEN
            -- Persoon zit nog niet op de bestemming
            -- Verwijderen oude -vaste- werkplek(ken) op meegegeven niveau.
            SELECT MIN(DECODE (p_alg_type,
                               'R', alg_ruimte_key,
                               'V', alg_verdieping_key,
                               'G', alg_gebouw_key,
                               'L', alg_locatie_key,
                               'D', alg_district_key,
                               NULL))
              INTO v_alg_key
              FROM alg_v_ruimte_gegevens_all
             WHERE alg_ruimte_key = p_ruimte_key;

            IF fac.getsetting ('prs_werkplek_implicit') = '0'                                --expliciet
            THEN
                -- Wis de bezetting maar laat de werkplek bestaan
                DELETE FROM prs_perslidwerkplek pw
                      WHERE pw.prs_perslid_key = p_prs_key
                            AND EXISTS
                                   (SELECT 1
                                      FROM prs_werkplek wp,
                                           (SELECT alg_ruimte_key,
                                                   DECODE (p_alg_type,
                                                           'R', alg_ruimte_key,
                                                           'V', alg_verdieping_key,
                                                           'G', alg_gebouw_key,
                                                           'L', alg_locatie_key,
                                                           'D', alg_district_key,
                                                           NULL)
                                                       alg_key
                                              FROM alg_v_ruimte_gegevens_all) og
                                     WHERE     wp.prs_werkplek_key = pw.prs_werkplek_key
                                           AND wp.prs_werkplek_virtueel = p_virtual
                                           AND wp.prs_werkplek_type = 0  -- alleen vaste plekken
                                           AND wp.prs_alg_ruimte_key = og.alg_ruimte_key
                                           AND (og.alg_key = v_alg_key OR p_alg_type = 'A'));
            ELSE
                -- Wis de werkplek, automatisch inclusief de bezetting
                DELETE FROM prs_werkplek wp
                      WHERE wp.prs_werkplek_virtueel = p_virtual
                            AND wp.prs_werkplek_type = 0  -- alleen vaste plekken
                            AND EXISTS
                                   (SELECT 1
                                      FROM prs_perslidwerkplek pw,
                                           (SELECT alg_ruimte_key,
                                                   DECODE (p_alg_type,
                                                           'R', alg_ruimte_key,
                                                           'V', alg_verdieping_key,
                                                           'G', alg_gebouw_key,
                                                           'L', alg_locatie_key,
                                                           'D', alg_district_key,
                                                           NULL)
                                                       alg_key
                                              FROM alg_v_ruimte_gegevens_all) og
                                     WHERE     pw.prs_perslid_key = p_prs_key
                                           AND pw.prs_werkplek_key = wp.prs_werkplek_key
                                           AND wp.prs_alg_ruimte_key = og.alg_ruimte_key
                                           AND (og.alg_key = v_alg_key OR p_alg_type = 'A'));
            END IF;

            -- Persoon krijgt wp op de meegegeven ruimte.
            IF p_ruimte_key IS NOT NULL
            THEN
                -- Bepalen vrije werkplek (kan alleen igv expliciete werkplekken).
                IF fac.getsetting ('prs_werkplek_implicit') = '0'                                --expliciet
                THEN
                    SELECT MIN (wp.prs_werkplek_key)
                      INTO v_wp_key
                      FROM prs_werkplek wp
                     WHERE wp.prs_alg_ruimte_key = p_ruimte_key
                           AND wp.prs_werkplek_virtueel = p_virtual
                           AND wp.prs_werkplek_type = 0  -- alleen vaste plekken
                           AND NOT EXISTS (SELECT 1
                                             FROM prs_perslidwerkplek pw
                                            WHERE pw.prs_werkplek_key = wp.prs_werkplek_key);
                END IF;

                IF v_wp_key IS NULL
                THEN
                    -- Er is geen vrije (kan ook omdat we impliciet zijn), maak dan een nieuwe vrije werkplek.
                    SELECT COALESCE(MIN (ll), 1) eerstvrije
                      INTO v_wp_volgnr
                      FROM ( SELECT prs_werkplek_volgnr +1 AS ll
                               FROM prs_werkplek
                              WHERE prs_alg_ruimte_key = p_ruimte_key
                             MINUS
                             SELECT prs_werkplek_volgnr
                               FROM prs_werkplek
                              WHERE prs_alg_ruimte_key = p_ruimte_key);

                    SELECT alg_ruimte_nr
                      INTO v_ruimte_nr
                      FROM alg_ruimte
                     WHERE alg_ruimte_key = p_ruimte_key;

                    v_wp_oms := v_ruimte_nr || '/' || TO_CHAR (v_wp_volgnr);

                    -- Toevoegen nieuwe werkplek in meegegeven ruimte.
                    INSERT INTO prs_werkplek (prs_werkplek_volgnr,
                                              prs_werkplek_omschrijving,
                                              prs_alg_ruimte_key,
                                              prs_werkplek_type,
                                              prs_werkplek_virtueel)
                        VALUES (v_wp_volgnr, v_wp_oms, p_ruimte_key, 0, p_virtual)
                     RETURNING prs_werkplek_key
                          INTO v_wp_key;
                END IF;

                -- Koppelen persoon aan de (nieuwe of bestaande) vrije werkplek
                INSERT INTO prs_perslidwerkplek (prs_perslid_key,
                                                 prs_werkplek_key,
                                                 prs_perslidwerkplek_bezetting)
                    VALUES (p_prs_key, v_wp_key, 100);
            END IF;
        END IF;
    END;

  -- Procedure om op een standaard wijze de import tabel voor personen te vullen
  --     p_import_key
  --     p_seq_of_columns   string met puntkomma gescheiden reeks van kolomnummers waar onderstaande kolom
  --                        in het import bestand gevonden kan worden.
  --
  --                        Naar analogie met de factuur import.
  --                        v_seq_of_columns ListOfInteger := (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21 .....,46);
  --                        Het getal op een bepaalde postitie geeft aan in welke kolom dit veld in de csv staat
  --                        Voorbeeld: Als de derde waarde een 8 bevat betekent dit dat de verdieping volgnummer in kolom 8 van de csv staat.
  --
  --                        Dus dan maar via een string, en ook op slimme wijze, nl alsof het een ingelezen perslid-record is met p_fielddelimitor
  --
  --                        Afwijkingen op deze volgorde zijn in eigen cust_import_perslid te regelen.
  --
  --                        Als locatiecode en gebouwcode b.v. zijn omgedraaid in het CSV-formaat,
  --                        dan perslid import ListOfInteger := (2,1,3,4,5,6,7,8,9,10,11,12);
  --                        v_seq_of_columns := '2;1;3;4;5;6;7;8;9;10;11;12';
  --
  --                        Als locatiecode NIET in CSV staat, dan perslid import ListOfInteger := (0,2,3,4,5,6,7,8,9,10,11,12);
  --                        v_seq_of_columns := '0;2;3;4;5;6;7;8;9;10;11;12';
  --                        M.a.w. waar een 0 staat, wordt de variabele niet ingelezen en blijft LEEG.
  --
  --     p_header           header waarop gecontroleerd moet worden. Indien null dan wordt er niet op een header gecontroleerd.
  --                        Het is mogelijk om wildcards in de string op te geven.
  -- Standaard volgorde van de kolommen in het CSV-formaat)
  -- Variabelelijst
  -- v_alg_locatie_code 1
  -- v_alg_gebouw_code 2
  -- v_alg_verdieping_volgnr 3
  -- v_alg_ruimte_nr 4
  -- v_prs_werkplek_volgnr 5
  -- v_prs_werkplek_omschrijving 6
  -- v_prs_afdeling_naam 7
  -- v_prs_perslid_naam 8
  -- v_prs_perslid_tussenvoegsel 9
  -- v_prs_perslid_voornaam 10
  -- v_prs_perslid_voorletters 11
  -- v_prs_perslid_partner_naam 12
  -- v_prs_perslid_partner_tussenv 13
  -- v_prs_naamgebruik_code 14             0 (default) perslid_naam en perslid_tussenvoegsel worden gebruikt
  --                                       1 personen die de geboortenaam van de partner icm de eigen naam willen gebruiken
  --                                       2 personen die de geboortenaam van de partner willen gebruiken
  --                                       3 personen die de eigen naam icm de geboortenaam van de partner willen gebruiken
  -- v_prs_perslid_geslacht 15             Gebruik 'man', 'm' of 1 voor man en 'vrouw', 'v' of 0 voor vrouw case insensitive geen default
  -- v_prs_perslid_telefoonnr 16
  -- v_prs_perslid_mobiel 17
  -- v_prs_perslid_email 18
  -- v_prs_perslid_dienstverband 19
  -- v_prs_perslid_nr 20
  -- v_prs_srtperslid_omschrijving 21
  -- v_prs_perslid_oslogin 22
  -- v_prs_perslid_wachtwoord 23
  -- v_prs_perslid_titel 24
  -- v_prs_perslid_apikey 25
  -- v_prs_kostenplaats_nr 26
  -- v_prs_kenmerk1 27
  -- v_prs_kenmerk2 28
  -- v_prs_kenmerk3 29
  -- v_prs_kenmerk4 30
  -- v_prs_kenmerk5 31
  -- v_prs_kenmerk6 32
  -- v_prs_kenmerk7 33
  -- v_prs_kenmerk8 34
  -- v_prs_kenmerk9 35
  -- v_prs_kenmerk10 36
  -- v_prs_kenmerk11 37
  -- v_prs_kenmerk12 38
  -- v_prs_kenmerk13 39
  -- v_prs_kenmerk14 40
  -- v_prs_kenmerk15 41
  -- v_prs_kenmerk16 42
  -- v_prs_kenmerk17 43
  -- v_prs_kenmerk18 44
  -- v_prs_kenmerk19 45
  -- v_prs_kenmerk20 46
  PROCEDURE import_perslid (
     p_import_key       IN NUMBER,
     p_seq_of_columns   IN VARCHAR2,
     p_header           IN VARCHAR2)
  AS
     v_newline                       fac_imp_file.fac_imp_file_line%TYPE; -- Input line
     v_field                         VARCHAR2 (100);
     v_fielddelimitor                VARCHAR2 (2);
     v_aanduiding                    VARCHAR2 (400);
     v_errormsg                      VARCHAR (200);
     v_errorhint                     VARCHAR2 (200);
     v_count                         NUMBER (10) := 0;
     v_count_tot                     NUMBER (10) := 0;
     v_count_import                  NUMBER (10) := 0;
     v_index                         NUMBER (10);
     v_ongeldig                      NUMBER (10);
     v_header_is_valid               NUMBER (1) := 0;
     oracle_err_num                  NUMBER;
     oracle_err_mes                  VARCHAR2 (200);

     -- De importvelden
     v_empty                         VARCHAR2 (100);
     v_alg_locatie_code              VARCHAR2 (256);
     v_alg_gebouw_code               VARCHAR2 (256);
     v_alg_verdieping_volgnr         VARCHAR2 (256);
     v_alg_ruimte_nr                 VARCHAR2 (256);
     v_prs_werkplek_volgnr           VARCHAR2 (256);
     v_prs_werkplek_omschrijving     VARCHAR2 (256);
     v_prs_afdeling_naam             VARCHAR2 (256);
     v_prs_kostenplaats_nr           VARCHAR2 (256);
     v_prs_perslid_naam              VARCHAR2 (256);
     v_prs_perslid_tussenvoegsel     VARCHAR2 (256);
     v_prs_perslid_voornaam          VARCHAR2 (256);
     v_prs_perslid_voorletters       VARCHAR2 (256);
     v_prs_perslid_partner_naam      VARCHAR2 (256);
     v_prs_perslid_partner_tussenv   VARCHAR2 (256);
     v_prs_naamgebruik_code          VARCHAR2 (256);
     v_prs_perslid_geslacht          VARCHAR2 (256);
     v_prs_perslid_telefoonnr        VARCHAR2 (256);
     v_prs_perslid_mobiel            VARCHAR2 (256);
     v_prs_perslid_email             VARCHAR2 (256);
     v_prs_perslid_dienstverband     VARCHAR2 (256);
     v_prs_perslid_nr                VARCHAR2 (256);
     v_prs_srtperslid_omschrijving   VARCHAR2 (256);
     v_prs_perslid_titel             VARCHAR2 (256);
     v_prs_perslid_oslogin           VARCHAR2 (256);
     v_prs_perslid_wachtwoord        VARCHAR2 (256);
     v_prs_perslid_apikey            VARCHAR2 (256);
     v_prs_kenmerk1                  VARCHAR2 (4000);
     v_prs_kenmerk2                  VARCHAR2 (4000);
     v_prs_kenmerk3                  VARCHAR2 (4000);
     v_prs_kenmerk4                  VARCHAR2 (4000);
     v_prs_kenmerk5                  VARCHAR2 (4000);
     v_prs_kenmerk6                  VARCHAR2 (4000);
     v_prs_kenmerk7                  VARCHAR2 (4000);
     v_prs_kenmerk8                  VARCHAR2 (4000);
     v_prs_kenmerk9                  VARCHAR2 (4000);
     v_prs_kenmerk10                 VARCHAR2 (4000);
     v_prs_kenmerk11                 VARCHAR2 (4000);
     v_prs_kenmerk12                 VARCHAR2 (4000);
     v_prs_kenmerk13                 VARCHAR2 (4000);
     v_prs_kenmerk14                 VARCHAR2 (4000);
     v_prs_kenmerk15                 VARCHAR2 (4000);
     v_prs_kenmerk16                 VARCHAR2 (4000);
     v_prs_kenmerk17                 VARCHAR2 (4000);
     v_prs_kenmerk18                 VARCHAR2 (4000);
     v_prs_kenmerk19                 VARCHAR2 (4000);
     v_prs_kenmerk20                 VARCHAR2 (4000);
     v_prs_kenmerk_key1              VARCHAR2 (255);
     v_prs_kenmerk_key2              VARCHAR2 (255);
     v_prs_kenmerk_key3              VARCHAR2 (255);
     v_prs_kenmerk_key4              VARCHAR2 (255);
     v_prs_kenmerk_key5              VARCHAR2 (255);
     v_prs_kenmerk_key6              VARCHAR2 (255);
     v_prs_kenmerk_key7              VARCHAR2 (255);
     v_prs_kenmerk_key8              VARCHAR2 (255);
     v_prs_kenmerk_key9              VARCHAR2 (255);
     v_prs_kenmerk_key10             VARCHAR2 (255);
     v_prs_kenmerk_key11             VARCHAR2 (255);
     v_prs_kenmerk_key12             VARCHAR2 (255);
     v_prs_kenmerk_key13             VARCHAR2 (255);
     v_prs_kenmerk_key14             VARCHAR2 (255);
     v_prs_kenmerk_key15             VARCHAR2 (255);
     v_prs_kenmerk_key16             VARCHAR2 (255);
     v_prs_kenmerk_key17             VARCHAR2 (255);
     v_prs_kenmerk_key18             VARCHAR2 (255);
     v_prs_kenmerk_key19             VARCHAR2 (255);
     v_prs_kenmerk_key20             VARCHAR2 (255);
     v_alg_verdieping_volgnr_num     NUMBER;
     v_prs_werkplek_volgnr_num       NUMBER;
     v_prs_perslid_dienstv_num       NUMBER;

     v_seq_of_columns                VARCHAR2 (200);
     v_lim_header                    VARCHAR2(4000);

     TYPE array_t IS VARRAY (46) OF NUMBER (10);

     v_colnr                         array_t := array_t ();

     CURSOR c
     IS
          SELECT *
            FROM fac_imp_file
           WHERE fac_import_key = p_import_key
        ORDER BY fac_imp_file_index;

   FUNCTION bepaal_kenmerk_key (kw IN VARCHAR)
      RETURN NUMBER
   IS
      v_kenmerk_key   NUMBER;
   BEGIN
      IF fac.safe_to_number (kw) IS NULL
      THEN                -- kenmerkwaarde is alfanumeriek (dus omschrijving)!
         SELECT   prs_kenmerk_key
           INTO   v_kenmerk_key
           FROM   prs_kenmerk
          WHERE   prs_kenmerk_upper = UPPER (kw)
                  AND prs_kenmerk_verwijder IS NULL
                  AND prs_kenmerk_niveau = 'P'
                  AND prs_kenmerk_kenmerktype IN ('C', 'D', 'N', 'R', 'r', 'S', 'X', 'V');
      ELSE                             -- kenmerkwaarde is numeriek (dus key)!
         SELECT   prs_kenmerk_key
           INTO   v_kenmerk_key
           FROM   prs_kenmerk
          WHERE   prs_kenmerk_key = fac.safe_to_number (kw)
                  AND prs_kenmerk_verwijder IS NULL
                  AND prs_kenmerk_niveau = 'P'
                  AND prs_kenmerk_kenmerktype IN ('C', 'D', 'N', 'R', 'r', 'S', 'X', 'V');
      END IF;

      RETURN v_kenmerk_key;
   EXCEPTION
      WHEN NO_DATA_FOUND
      THEN
         IF kw IS NULL OR UPPER (kw) LIKE 'KENMERK%'
         THEN
            RETURN NULL;
         ELSE
            fac.imp_writelog (p_import_key,
                              'W',
                              'Fout bij bepalen kenmerk [' || kw || ']',
                              'Bestaat niet of type ongeldig');
            COMMIT;
            RETURN NULL;
         END IF;
   END;


  BEGIN
     -- JGL: Ik zou graag een WHERE fac_import_key = p_import_key hieronder
     --      toevoegen zodat het script ook multi-user veilig is,
     --      Heel veel klant-specifieke imports(/aanvullingen) controleren
     --      echter niet op de fac_import_key en zouden flink de fout in gaan.
     --      Daarom vooralsnog hier toch maar alles verwijderen
     -- NB:  In fac_import_perslid worden v_seq_of_columns en p_header gezet!
     DELETE FROM   fac_imp_perslid;

     SELECT COALESCE (MAX (fac_imp_file_index), 0) + 1
       INTO v_count
       FROM fac_imp_factuur;

     -- Init
     v_fielddelimitor := fac.import_delimiter(p_import_key);
     v_seq_of_columns := p_seq_of_columns;
     v_errorhint := 'Bepalen volgorde kolommen';

     FOR v_index IN 1 .. 46
     LOOP
        v_colnr.EXTEND;
        -- De volgorde van de te importeren kolommen in de CSV uitlezen uit v_seq_of_columns
        -- De field delimiter is hier altijd ";"
        fac.imp_getfield (v_seq_of_columns,
                          ';',
                          v_colnr (v_index));
     END LOOP;


     -- Indien geen header check is opgegeven, gaan we niet op zoek naar een geldige header
     IF p_header IS NULL
     THEN
        v_header_is_valid := 1;
     END IF;

     FOR rec1 IN c
     LOOP
        BEGIN
           v_errormsg := 'Fout FETCH te importeren rij';

           v_newline := rec1.fac_imp_file_line;
           v_errormsg := '';
           v_errorhint := 'Fout opvragen te importeren rij';
           v_aanduiding := '';
           v_ongeldig := 0;

           IF v_header_is_valid = 0
           THEN
              v_lim_header := REPLACE(p_header, ';', v_fielddelimitor);

              IF UPPER(v_newline) LIKE UPPER(v_lim_header)
              THEN
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 27, v_prs_kenmerk1);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 28, v_prs_kenmerk2);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 29, v_prs_kenmerk3);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 30, v_prs_kenmerk4);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 31, v_prs_kenmerk5);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 32, v_prs_kenmerk6);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 33, v_prs_kenmerk7);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 34, v_prs_kenmerk8);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 35, v_prs_kenmerk9);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 36, v_prs_kenmerk10);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 37, v_prs_kenmerk11);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 38, v_prs_kenmerk12);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 39, v_prs_kenmerk13);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 40, v_prs_kenmerk14);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 41, v_prs_kenmerk15);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 42, v_prs_kenmerk16);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 43, v_prs_kenmerk17);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 44, v_prs_kenmerk18);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 45, v_prs_kenmerk19);
                 fac.imp_getfield_nr(v_newline, v_fielddelimitor, 46, v_prs_kenmerk20);

                 v_prs_kenmerk_key1  := bepaal_kenmerk_key (v_prs_kenmerk1);
                 v_prs_kenmerk_key2  := bepaal_kenmerk_key (v_prs_kenmerk2);
                 v_prs_kenmerk_key3  := bepaal_kenmerk_key (v_prs_kenmerk3);
                 v_prs_kenmerk_key4  := bepaal_kenmerk_key (v_prs_kenmerk4);
                 v_prs_kenmerk_key5  := bepaal_kenmerk_key (v_prs_kenmerk5);
                 v_prs_kenmerk_key6  := bepaal_kenmerk_key (v_prs_kenmerk6);
                 v_prs_kenmerk_key7  := bepaal_kenmerk_key (v_prs_kenmerk7);
                 v_prs_kenmerk_key8  := bepaal_kenmerk_key (v_prs_kenmerk8);
                 v_prs_kenmerk_key9  := bepaal_kenmerk_key (v_prs_kenmerk9);
                 v_prs_kenmerk_key10 := bepaal_kenmerk_key (v_prs_kenmerk10);
                 v_prs_kenmerk_key11 := bepaal_kenmerk_key (v_prs_kenmerk11);
                 v_prs_kenmerk_key12 := bepaal_kenmerk_key (v_prs_kenmerk12);
                 v_prs_kenmerk_key13 := bepaal_kenmerk_key (v_prs_kenmerk13);
                 v_prs_kenmerk_key14 := bepaal_kenmerk_key (v_prs_kenmerk14);
                 v_prs_kenmerk_key15 := bepaal_kenmerk_key (v_prs_kenmerk15);
                 v_prs_kenmerk_key16 := bepaal_kenmerk_key (v_prs_kenmerk16);
                 v_prs_kenmerk_key17 := bepaal_kenmerk_key (v_prs_kenmerk17);
                 v_prs_kenmerk_key18 := bepaal_kenmerk_key (v_prs_kenmerk18);
                 v_prs_kenmerk_key19 := bepaal_kenmerk_key (v_prs_kenmerk19);
                 v_prs_kenmerk_key20 := bepaal_kenmerk_key (v_prs_kenmerk20);
                 v_header_is_valid := 1;
              END IF;
           ELSE
              -- Lees alle veldwaarden
              v_errorhint := 'Inlezen alg_locatie_code kolom:' || v_colnr (1);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (1),
                                   v_alg_locatie_code);
              v_errorhint := 'Inlezen alg_lcoatie_code kolom:' || v_colnr (2);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (2),
                                   v_alg_gebouw_code);
              v_errorhint := 'Inlezen alg_verdieping_volgnr kolom:' || v_colnr (3);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (3),
                                   v_alg_verdieping_volgnr);
              v_errorhint := 'Inlezen alg_ruimte_nr kolom:' || v_colnr (4);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (4),
                                   v_alg_ruimte_nr);
              v_errorhint := 'Inlezen prs_werkplek_volgnr kolom:' || v_colnr (5);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (5),
                                   v_prs_werkplek_volgnr);
              v_errorhint := 'Inlezen prs_werkplek_omschrijving kolom:' || v_colnr (6);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (6),
                                   v_prs_werkplek_omschrijving);
              v_errorhint := 'Inlezen prs_afdeling_naam kolom:' || v_colnr (7);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (7),
                                   v_prs_afdeling_naam);
              v_errorhint := 'Inlezen prs_perslid_naam kolom:' || v_colnr (8);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (8),
                                   v_prs_perslid_naam);
              v_errorhint := 'Inlezen prs_perslid_tussenvoegsel kolom:' || v_colnr (9);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (9),
                                   v_prs_perslid_tussenvoegsel);
              v_errorhint := 'Inlezen prs_perslid_voornaam kolom:' || v_colnr (10);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (10),
                                   v_prs_perslid_voornaam);
              v_errorhint := 'Inlezen prs_perslid_voorletters kolom:' || v_colnr (11);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (11),
                                   v_prs_perslid_voorletters);
              v_errorhint := 'Inlezen prs_perslid_partner_naam kolom:' || v_colnr (12);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (12),
                                   v_prs_perslid_partner_naam);
              v_errorhint := 'Inlezen prs_perslid_partner_tussenv kolom:' || v_colnr (13);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (13),
                                   v_prs_perslid_partner_tussenv);
              v_errorhint := 'Inlezen prs_perslid_geslacht kolom:' || v_colnr (14);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (14),
                                   v_prs_naamgebruik_code);
              v_errorhint := 'Inlezen alg_lcoatie_code kolom:' || v_colnr (15);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (15),
                                   v_prs_perslid_geslacht);
              v_errorhint := 'Inlezen prs_perslid_telefoonnr kolom:' || v_colnr (16);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (16),
                                   v_prs_perslid_telefoonnr);
              v_errorhint := 'Inlezen prs_perslid_mobiel kolom:' || v_colnr (17);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (17),
                                   v_prs_perslid_mobiel);
              v_errorhint := 'Inlezen prs_perslid_email kolom:' || v_colnr (18);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (18),
                                   v_prs_perslid_email);
              v_errorhint := 'Inlezen prs_perslid_dienstverband kolom:' || v_colnr (19);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (19),
                                   v_prs_perslid_dienstverband);
              v_errorhint := 'Inlezen prs_perslid_nr kolom:' || v_colnr (20);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (20),
                                   v_prs_perslid_nr);
              v_errorhint := 'Inlezen prs_srtperslid_omschrijving kolom:' || v_colnr (21);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (21),
                                   v_prs_srtperslid_omschrijving);
              v_errorhint := 'Inlezen prs_perslid_oslogin kolom:' || v_colnr (22);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (22),
                                   v_prs_perslid_oslogin);
              v_errorhint := 'Inlezen prs_perslid_wachtwoord kolom:' || v_colnr (23);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (23),
                                   v_prs_perslid_wachtwoord);
              v_errorhint := 'Inlezen prs_perslid_titel kolom:' || v_colnr (24);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (24),
                                   v_prs_perslid_titel);
              v_errorhint := 'Inlezen prs_perslid_apikey kolom:' || v_colnr (25);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (25),
                                   v_prs_perslid_apikey);
              v_errorhint := 'Inlezen prs_perslid_kostenplaats kolom:' || v_colnr (26);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (26),
                                   v_prs_kostenplaats_nr);
              v_errorhint := 'Inlezen prs_kenmerk1 kolom:' || v_colnr (27);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (27),
                                   v_prs_kenmerk1);
              v_errorhint := 'Inlezen prs_kenmerk2 kolom:' || v_colnr (28);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (28),
                                   v_prs_kenmerk2);
              v_errorhint := 'Inlezen prs_kenmerk3 kolom:' || v_colnr (29);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (29),
                                   v_prs_kenmerk3);
              v_errorhint := 'Inlezen prs_kenmerk4 kolom:' || v_colnr (30);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (30),
                                   v_prs_kenmerk4);
              v_errorhint := 'Inlezen prs_kenmerk5 kolom:' || v_colnr (31);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (31),
                                   v_prs_kenmerk5);
              v_errorhint := 'Inlezen prs_kenmerk6 kolom:' || v_colnr (32);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (32),
                                   v_prs_kenmerk6);
              v_errorhint := 'Inlezen prs_kenmerk7 kolom:' || v_colnr (33);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (33),
                                   v_prs_kenmerk7);
              v_errorhint := 'Inlezen prs_kenmerk8 kolom:' || v_colnr (34);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (34),
                                   v_prs_kenmerk8);
              v_errorhint := 'Inlezen prs_kenmerk9 kolom:' || v_colnr (35);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (35),
                                   v_prs_kenmerk9);
              v_errorhint := 'Inlezen prs_kenmerk10 kolom:' || v_colnr (36);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (36),
                                   v_prs_kenmerk10);
              v_errorhint := 'Inlezen prs_kenmerk11 kolom:' || v_colnr (37);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (37),
                                   v_prs_kenmerk11);
              v_errorhint := 'Inlezen prs_kenmerk12 kolom:' || v_colnr (38);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (38),
                                   v_prs_kenmerk12);
              v_errorhint := 'Inlezen prs_kenmerk13 kolom:' || v_colnr (39);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (39),
                                   v_prs_kenmerk13);
              v_errorhint := 'Inlezen prs_kenmerk14 kolom:' || v_colnr (40);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (40),
                                   v_prs_kenmerk14);
              v_errorhint := 'Inlezen prs_kenmerk15 kolom:' || v_colnr (41);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (41),
                                   v_prs_kenmerk15);
              v_errorhint := 'Inlezen prs_kenmerk16 kolom:' || v_colnr (42);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (42),
                                   v_prs_kenmerk16);
              v_errorhint := 'Inlezen prs_kenmerk17 kolom:' || v_colnr (43);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (43),
                                   v_prs_kenmerk17);
              v_errorhint := 'Inlezen prs_kenmerk18 kolom:' || v_colnr (44);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (44),
                                   v_prs_kenmerk18);
              v_errorhint := 'Inlezen prs_kenmerk19 kolom:' || v_colnr (45);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (45),
                                   v_prs_kenmerk19);
              v_errorhint := 'Inlezen prs_kenmerk20 kolom:' || v_colnr (46);
              fac.imp_getfield_nr (v_newline,
                                   v_fielddelimitor,
                                   v_colnr (46),
                                   v_prs_kenmerk20);

              v_aanduiding :=
                 v_prs_perslid_naam || '|' || v_prs_perslid_voornaam || '| ';

              v_count_tot := v_count_tot + 1;
              v_errorhint := 'Ongeldige locatiecode';
              v_alg_locatie_code := TRIM (v_alg_locatie_code);

              IF LENGTH (v_alg_locatie_code) > 10
              THEN
                 v_alg_locatie_code := SUBSTR (v_alg_locatie_code, 1, 10);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Locatie-aanduiding is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_alg_locatie_code
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige gebouw code';
              v_alg_gebouw_code := TRIM (v_alg_gebouw_code);

              IF LENGTH (v_alg_gebouw_code) > 12
              THEN
                 v_alg_gebouw_code := SUBSTR (v_alg_gebouw_code, 1, 12);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Gebouw-aanduiding is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_alg_gebouw_code
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldig verdieping volgnummer';
              v_alg_verdieping_volgnr := TRIM (v_alg_verdieping_volgnr);

              IF (v_alg_verdieping_volgnr IS NULL)
              THEN
                 v_alg_verdieping_volgnr_num :=
                    TO_NUMBER (v_alg_verdieping_volgnr);
              ELSE
                 BEGIN
                    v_alg_verdieping_volgnr_num :=
                       TO_NUMBER (v_alg_verdieping_volgnr);
                 EXCEPTION
                    WHEN OTHERS
                    THEN
                       v_ongeldig := 1;
                       oracle_err_num := SQLCODE;
                       oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
                       v_errormsg :=
                          'Error ' || oracle_err_num || '/' || oracle_err_mes;
                       fac.imp_writelog (p_import_key,
                                         'E',
                                         v_aanduiding || v_errormsg,
                                         v_errorhint);
                 END;
              END IF;

              --
              v_errorhint := 'Ongeldige ruimte nr';
              v_alg_ruimte_nr := TRIM (v_alg_ruimte_nr);

              IF LENGTH (v_alg_ruimte_nr) > 20
              THEN
                 v_alg_ruimte_nr := SUBSTR (v_alg_ruimte_nr, 1, 20);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Ruimtenr-aanduiding is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_alg_ruimte_nr
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldig werkplek volgnummer';
              v_prs_werkplek_volgnr := TRIM (v_prs_werkplek_volgnr);

              IF (v_prs_werkplek_volgnr IS NULL)
              THEN
                 v_prs_werkplek_volgnr_num := TO_NUMBER (v_prs_werkplek_volgnr);
              ELSE
                 BEGIN
                    v_alg_verdieping_volgnr_num :=
                       TO_NUMBER (v_alg_verdieping_volgnr);
                 EXCEPTION
                    WHEN OTHERS
                    THEN
                       v_ongeldig := 1;
                       oracle_err_num := SQLCODE;
                       oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
                       v_errormsg :=
                          'Error ' || oracle_err_num || '/' || oracle_err_mes;
                       fac.imp_writelog (p_import_key,
                                         'E',
                                         v_aanduiding || v_errormsg,
                                         v_errorhint);
                 END;
              END IF;

              --
              v_errorhint := 'Ongeldige werkplek omschrijving';
              v_prs_werkplek_omschrijving := TRIM (v_prs_werkplek_omschrijving);

              IF LENGTH (v_prs_werkplek_omschrijving) > 30
              THEN
                 v_prs_werkplek_omschrijving :=
                    SUBSTR (v_prs_werkplek_omschrijving, 1, 30);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Werkplek-aanduiding is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_werkplek_omschrijving
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige afdelingscode';
              v_prs_afdeling_naam := TRIM (v_prs_afdeling_naam);

              IF LENGTH (v_prs_afdeling_naam) > 15
              THEN
                 v_prs_afdeling_naam := SUBSTR (v_prs_afdeling_naam, 1, 15);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Afdelingscode is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_afdeling_naam
                    || ']');
              ELSE
                 IF (v_prs_afdeling_naam IS NULL)
                 THEN
                    v_ongeldig := 1;
                    fac.imp_writelog (p_import_key,
                                      'E',
                                      v_aanduiding || 'Afdelingscode onbekend',
                                      'Afdelingscode moet worden opgegeven');
                 END IF;
              END IF;

              --
              v_errorhint := 'Ongeldige kostenplaats';
              v_prs_kostenplaats_nr := TRIM (v_prs_kostenplaats_nr);

              IF LENGTH (v_prs_kostenplaats_nr) > 30
              THEN
                 v_prs_kostenplaats_nr := SUBSTR (v_prs_kostenplaats_nr, 1, 30);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'kostenplaatsnummer is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_kostenplaats_nr
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige naam persoon';
              v_prs_perslid_naam := TRIM (v_prs_perslid_naam);

              IF LENGTH (v_prs_perslid_naam) > 60
              THEN
                 v_prs_perslid_naam := SUBSTR (v_prs_perslid_naam, 1, 60);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Naam persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_naam
                    || ']');
              ELSE
                 IF (v_prs_perslid_naam IS NULL)
                 THEN
                    v_ongeldig := 1;
                    fac.imp_writelog (p_import_key,
                                      'E',
                                      v_aanduiding || 'Naam persoon onbekend',
                                      'Naam persoon moet worden opgegeven');
                 END IF;
              END IF;

              --
              v_errorhint := 'Ongeldige tussenvoegsel persoon';
              v_prs_perslid_tussenvoegsel := TRIM (v_prs_perslid_tussenvoegsel);

              IF LENGTH (v_prs_perslid_tussenvoegsel) > 10
              THEN
                 v_prs_perslid_tussenvoegsel :=
                    SUBSTR (v_prs_perslid_tussenvoegsel, 1, 10);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Tussenvoegsel persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_tussenvoegsel
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige voorletters persoon';
              v_prs_perslid_voorletters := TRIM (v_prs_perslid_voorletters);

              IF LENGTH (v_prs_perslid_voorletters) > 15
              THEN
                 v_prs_perslid_voorletters :=
                    SUBSTR (v_prs_perslid_voorletters, 1, 15);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Voorletters persoon zijn te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_voorletters
                    || ']');
              END IF;

              --
              v_errorhint := 'Voornaam persoon';
              v_prs_perslid_voornaam := TRIM (v_prs_perslid_voornaam);

              IF LENGTH (v_prs_perslid_voornaam) > 30
              THEN
                 v_prs_perslid_voornaam :=
                    SUBSTR (v_prs_perslid_voornaam, 1, 30);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Voornaam persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_voornaam
                    || ']');
              END IF;

              v_errorhint := 'Ongeldige partnernaam persoon';
              v_prs_perslid_partner_naam := TRIM (v_prs_perslid_partner_naam);

              --
              IF LENGTH (v_prs_perslid_partner_naam) > 60
              THEN
                 v_prs_perslid_partner_naam := SUBSTR (v_prs_perslid_partner_naam, 1, 60);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Partnernaam is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_partner_naam
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige tussenvoegsel partner';
              v_prs_perslid_partner_tussenv := TRIM (v_prs_perslid_partner_tussenv);

              IF LENGTH (v_prs_perslid_partner_tussenv) > 10
              THEN
                 v_prs_perslid_partner_tussenv :=
                    SUBSTR (v_prs_perslid_partner_tussenv, 1, 10);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Tussenvoegsel partner is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_partner_tussenv
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldig geslacht';
              v_prs_perslid_geslacht := TRIM (v_prs_perslid_geslacht);

              IF LENGTH (v_prs_perslid_geslacht) > 1
              THEN
                 SELECT DECODE(UPPER(v_prs_perslid_geslacht), 'MAN', '1', 'VROUW', '0', NULL)
                   INTO v_prs_perslid_geslacht
                   FROM DUAL;
              ELSE
                 IF fac.safe_to_number(v_prs_perslid_geslacht) IS NULL
                 THEN
                    SELECT DECODE(UPPER(v_prs_perslid_geslacht), 'M', '1', 'V', '0', NULL)
                      INTO v_prs_perslid_geslacht
                      FROM DUAL;
                 END IF;
              END IF;

              --
              v_errorhint := 'Ongeldig dienstverband';
              v_prs_perslid_dienstverband := TRIM (v_prs_perslid_dienstverband);

              IF (v_prs_perslid_dienstverband IS NOT NULL)
              THEN
                 BEGIN
                    v_prs_perslid_dienstv_num :=
                       TO_NUMBER (v_prs_perslid_dienstverband);
                 EXCEPTION
                    WHEN OTHERS
                    THEN
                       v_ongeldig := 1;
                       oracle_err_num := SQLCODE;
                       oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
                       v_errormsg :=
                          'Error ' || oracle_err_num || '/' || oracle_err_mes;
                       fac.imp_writelog (p_import_key,
                                         'E',
                                         v_aanduiding || v_errormsg,
                                         v_errorhint);
                 END;
              END IF;

              --
              v_errorhint := 'Ongeldige titel persoon';
              v_prs_perslid_titel := TRIM (v_prs_perslid_titel);

              IF LENGTH (v_prs_perslid_titel) > 15
              THEN
                 v_prs_perslid_titel := SUBSTR (v_prs_perslid_titel, 1, 15);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Titel persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_titel
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige telefoonnr. persoon';
              v_prs_perslid_telefoonnr := TRIM (v_prs_perslid_telefoonnr);

              IF LENGTH (v_prs_perslid_telefoonnr) > 20
              THEN
                 v_prs_perslid_telefoonnr :=
                    SUBSTR (v_prs_perslid_telefoonnr, 1, 20);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Telefoonnr. persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_telefoonnr
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige mobielnr. persoon';
              v_prs_perslid_mobiel := TRIM (v_prs_perslid_mobiel);

              IF LENGTH (v_prs_perslid_mobiel) > 20
              THEN
                 v_prs_perslid_mobiel := SUBSTR (v_prs_perslid_mobiel, 1, 20);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Mobielnr. persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_mobiel
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige email persoon';
              v_prs_perslid_email := TRIM (v_prs_perslid_email);

              IF LENGTH (v_prs_perslid_email) > 200
              THEN
                 v_prs_perslid_email := SUBSTR (v_prs_perslid_email, 1, 200);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Email persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_email
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige functie persoon';
              v_prs_srtperslid_omschrijving :=
                 TRIM (v_prs_srtperslid_omschrijving);

              IF LENGTH (v_prs_srtperslid_omschrijving) > 100
              THEN
                 v_prs_srtperslid_omschrijving :=
                    SUBSTR (v_prs_srtperslid_omschrijving, 1, 100);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Functie-aanduiding persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_srtperslid_omschrijving
                    || ']');
              ELSE
                 IF (v_prs_srtperslid_omschrijving IS NULL)
                 THEN
                    v_ongeldig := 1;
                    fac.imp_writelog (
                       p_import_key,
                       'E',
                       v_aanduiding || 'Functie persoon onbekend',
                       'Functie persoon moet worden opgegeven');
                 END IF;
              END IF;

              --
              v_errorhint := 'Ongeldige persoonnr.';
              v_prs_perslid_nr := TRIM (v_prs_perslid_nr);

              IF LENGTH (v_prs_perslid_nr) > 16
              THEN
                 v_prs_perslid_nr := SUBSTR (v_prs_perslid_nr, 1, 16);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Persoonnr. persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_nr
                    || ']');
              END IF;

              --
              v_errorhint := 'Ongeldige loginnaam';
              v_prs_perslid_oslogin := TRIM (v_prs_perslid_oslogin);

              IF LENGTH (v_prs_perslid_oslogin) > 256
              THEN
                 v_prs_perslid_oslogin := SUBSTR (v_prs_perslid_oslogin, 1, 256);
                 fac.imp_writelog (
                    p_import_key,
                    'W',
                    v_aanduiding || 'Loginnaam persoon is te lang',
                       'Aanduiding wordt afgebroken tot ['
                    || v_prs_perslid_oslogin
                    || ']');
              END IF;

              v_errorhint := 'Ongeldig wachtwoord';
              v_prs_perslid_wachtwoord := TRIM (v_prs_perslid_wachtwoord);
              --
              -- Insert geformatteerde import record
              IF v_ongeldig = 0
              THEN
                 v_errorhint := 'Toevoegen record';
                 v_errormsg :=
                       'Fout bij toevoegen te impoteren bedrijf/afdeling ['
                    || v_prs_afdeling_naam
                    || ']';

                 INSERT INTO fac_imp_perslid (alg_locatie_code,
                                              alg_gebouw_code,
                                              alg_verdieping_volgnr,
                                              alg_ruimte_nr,
                                              prs_werkplek_volgnr,
                                              prs_werkplek_omschrijving,
                                              prs_afdeling_naam,
                                              prs_kostenplaats_nr,
                                              prs_perslid_naam,
                                              prs_perslid_tussenvoegsel,
                                              prs_perslid_voornaam,
                                              prs_perslid_voorletters,
                                              prs_perslid_partner_naam,
                                              prs_perslid_partner_tussenv,
                                              prs_perslid_naamgebruik_code,
                                              prs_perslid_geslacht,
                                              prs_perslid_telefoonnr,
                                              prs_perslid_mobiel,
                                              prs_perslid_email,
                                              prs_perslid_dienstverband,
                                              prs_perslid_nr,
                                              prs_srtperslid_omschrijving,
                                              prs_perslid_oslogin,
                                              prs_perslid_wachtwoord,
                                              prs_perslid_titel,
                                              prs_perslid_apikey,
                                              prs_kenmerk1,
                                              prs_kenmerk2,
                                              prs_kenmerk3,
                                              prs_kenmerk4,
                                              prs_kenmerk5,
                                              prs_kenmerk6,
                                              prs_kenmerk7,
                                              prs_kenmerk8,
                                              prs_kenmerk9,
                                              prs_kenmerk10,
                                              prs_kenmerk11,
                                              prs_kenmerk12,
                                              prs_kenmerk13,
                                              prs_kenmerk14,
                                              prs_kenmerk15,
                                              prs_kenmerk16,
                                              prs_kenmerk17,
                                              prs_kenmerk18,
                                              prs_kenmerk19,
                                              prs_kenmerk20,
                                              fac_import_key,
                                              fac_imp_file_index)
                     VALUES (v_alg_locatie_code,
                             v_alg_gebouw_code,
                             v_alg_verdieping_volgnr,
                             v_alg_ruimte_nr,
                             v_prs_werkplek_volgnr,
                             v_prs_werkplek_omschrijving,
                             v_prs_afdeling_naam,
                             v_prs_kostenplaats_nr,
                             v_prs_perslid_naam,
                             v_prs_perslid_tussenvoegsel,
                             v_prs_perslid_voornaam,
                             v_prs_perslid_voorletters,
                             v_prs_perslid_partner_naam,
                             v_prs_perslid_partner_tussenv,
                             COALESCE(fac.safe_to_number(v_prs_naamgebruik_code), 0),
                             v_prs_perslid_geslacht,
                             v_prs_perslid_telefoonnr,
                             v_prs_perslid_mobiel,
                             v_prs_perslid_email,
                             v_prs_perslid_dienstverband,
                             v_prs_perslid_nr,
                             v_prs_srtperslid_omschrijving,
                             v_prs_perslid_oslogin,
                             v_prs_perslid_wachtwoord,
                             v_prs_perslid_titel,
                             v_prs_perslid_apikey,
                             DECODE(v_prs_kenmerk_key1,  NULL, v_prs_kenmerk1,  TO_CHAR(v_prs_kenmerk_key1)  || '=' || SUBSTR(v_prs_kenmerk1,  1, 3980)),
                             DECODE(v_prs_kenmerk_key2,  NULL, v_prs_kenmerk2,  TO_CHAR(v_prs_kenmerk_key2)  || '=' || SUBSTR(v_prs_kenmerk2,  1, 3980)),
                             DECODE(v_prs_kenmerk_key3,  NULL, v_prs_kenmerk3,  TO_CHAR(v_prs_kenmerk_key3)  || '=' || SUBSTR(v_prs_kenmerk3,  1, 3980)),
                             DECODE(v_prs_kenmerk_key4,  NULL, v_prs_kenmerk4,  TO_CHAR(v_prs_kenmerk_key4)  || '=' || SUBSTR(v_prs_kenmerk4,  1, 3980)),
                             DECODE(v_prs_kenmerk_key5,  NULL, v_prs_kenmerk5,  TO_CHAR(v_prs_kenmerk_key5)  || '=' || SUBSTR(v_prs_kenmerk5,  1, 3980)),
                             DECODE(v_prs_kenmerk_key6,  NULL, v_prs_kenmerk6,  TO_CHAR(v_prs_kenmerk_key6)  || '=' || SUBSTR(v_prs_kenmerk6,  1, 3980)),
                             DECODE(v_prs_kenmerk_key7,  NULL, v_prs_kenmerk7,  TO_CHAR(v_prs_kenmerk_key7)  || '=' || SUBSTR(v_prs_kenmerk7,  1, 3980)),
                             DECODE(v_prs_kenmerk_key8,  NULL, v_prs_kenmerk8,  TO_CHAR(v_prs_kenmerk_key8)  || '=' || SUBSTR(v_prs_kenmerk8,  1, 3980)),
                             DECODE(v_prs_kenmerk_key9,  NULL, v_prs_kenmerk9,  TO_CHAR(v_prs_kenmerk_key9)  || '=' || SUBSTR(v_prs_kenmerk9,  1, 3980)),
                             DECODE(v_prs_kenmerk_key10, NULL, v_prs_kenmerk10, TO_CHAR(v_prs_kenmerk_key10) || '=' || SUBSTR(v_prs_kenmerk10, 1, 3980)),
                             DECODE(v_prs_kenmerk_key11, NULL, v_prs_kenmerk11, TO_CHAR(v_prs_kenmerk_key11) || '=' || SUBSTR(v_prs_kenmerk11, 1, 3980)),
                             DECODE(v_prs_kenmerk_key12, NULL, v_prs_kenmerk12, TO_CHAR(v_prs_kenmerk_key12) || '=' || SUBSTR(v_prs_kenmerk12, 1, 3980)),
                             DECODE(v_prs_kenmerk_key13, NULL, v_prs_kenmerk13, TO_CHAR(v_prs_kenmerk_key13) || '=' || SUBSTR(v_prs_kenmerk13, 1, 3980)),
                             DECODE(v_prs_kenmerk_key14, NULL, v_prs_kenmerk14, TO_CHAR(v_prs_kenmerk_key14) || '=' || SUBSTR(v_prs_kenmerk14, 1, 3980)),
                             DECODE(v_prs_kenmerk_key15, NULL, v_prs_kenmerk15, TO_CHAR(v_prs_kenmerk_key15) || '=' || SUBSTR(v_prs_kenmerk15, 1, 3980)),
                             DECODE(v_prs_kenmerk_key16, NULL, v_prs_kenmerk16, TO_CHAR(v_prs_kenmerk_key16) || '=' || SUBSTR(v_prs_kenmerk16, 1, 3980)),
                             DECODE(v_prs_kenmerk_key17, NULL, v_prs_kenmerk17, TO_CHAR(v_prs_kenmerk_key17) || '=' || SUBSTR(v_prs_kenmerk17, 1, 3980)),
                             DECODE(v_prs_kenmerk_key18, NULL, v_prs_kenmerk18, TO_CHAR(v_prs_kenmerk_key18) || '=' || SUBSTR(v_prs_kenmerk18, 1, 3980)),
                             DECODE(v_prs_kenmerk_key19, NULL, v_prs_kenmerk19, TO_CHAR(v_prs_kenmerk_key19) || '=' || SUBSTR(v_prs_kenmerk19, 1, 3980)),
                             DECODE(v_prs_kenmerk_key20, NULL, v_prs_kenmerk20, TO_CHAR(v_prs_kenmerk_key20) || '=' || SUBSTR(v_prs_kenmerk20, 1, 3980)),
                             rec1.fac_import_key,
                             rec1.fac_imp_file_index);

                 v_count_import := v_count_import + 1;
              END IF;
           END IF;
        END;
     END LOOP;

     IF v_header_is_valid = 0
     THEN
        fac.imp_writelog (p_import_key,
                          'E',
                          v_aanduiding || 'Ongeldig importbestand',
                          'Geen geldige headerregel aanwezig');
     ELSE
        fac.imp_writelog (
           p_import_key,
           'S',
           'Persoon: aantal ingelezen regels: ' || TO_CHAR (v_count_tot),
           '');
        fac.imp_writelog (
           p_import_key,
           'S',
           'Persoon: aantal ongeldige importregels: '
           || TO_CHAR (v_count_tot - v_count_import),
           '');
     END IF;

     COMMIT;
  EXCEPTION
     WHEN OTHERS
     THEN
        oracle_err_num := SQLCODE;
        oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
        v_errormsg := 'Error ' || oracle_err_num || '/' || oracle_err_mes;
        fac.imp_writelog (p_import_key,
                          'E',
                          v_aanduiding || v_errormsg,
                          v_errorhint);
  END;

  -- Procedure om generiek personen in te lezen of aan te passen.
  -- p_sleutelkolom    Bevat het veld die als sleutel bij de import dient.
  --                     NR     - personeelsnummer
  --                     EMAIL  - emailadres
  --                     LOGIN  - logincode
  --                     APIKEY - API-key voor distributie van persoonsgegevens over FACILITORs
  -- p_alg_type        Werkplekken binnen dit niveau verwijderen
  --                     NULL      - geen werkplekken verwijderen
  --                     A         - altijd vaste werkplek verwijderen
  --                     R,V,G,L,D - werkplek(en) op dit niveau verwijderen
  PROCEDURE update_perslid (p_import_key         IN NUMBER,
                            p_sleutelkolom       IN VARCHAR2,
                            p_alg_type           IN VARCHAR2,
                            p_import_kenmerk     IN NUMBER DEFAULT 0)
  IS
     c_fielddelimitor   VARCHAR2 (2) := fac.import_delimiter(p_import_key);

     v_errormsg         VARCHAR2 (1000);
     v_errorhint        VARCHAR2 (1000);
     oracle_err_num     NUMBER;
     oracle_err_mes     VARCHAR2 (200);
     v_aanduiding       VARCHAR2 (200);

     v_count            NUMBER (10);
     v_ongeldig         NUMBER (1);
     v_count_update     NUMBER (10);
     v_count_error      NUMBER (10);
     v_count_tot        NUMBER (10);
     v_wpcount_error    NUMBER (10);

     --
     v_perslid_key      NUMBER (10);
     v_afdeling_key     NUMBER (10);
     v_kostenplaats_key NUMBER (10);
     v_srtperslid_key   NUMBER (10);
     v_prs_perslid_naam VARCHAR2(200);
     v_prs_perslid_tussenvoegsel VARCHAR2(200);

     v_locatie_key      NUMBER (10);
     v_gebouw_key       NUMBER (10);
     v_verdieping_key   NUMBER (10);
     v_ruimte_key       NUMBER (10);
     v_space            VARCHAR2(1);


     CURSOR cSPERSLID
     IS
          SELECT MIN (prs_srtperslid_omschrijving) prs_srtperslid_omschrijving
            FROM fac_imp_perslid i
           WHERE NOT EXISTS
                    (SELECT prs_srtperslid_key
                       FROM prs_srtperslid sp
                      WHERE UPPER (sp.prs_srtperslid_omschrijving) =
                               UPPER (i.prs_srtperslid_omschrijving)
                        AND prs_srtperslid_verwijder IS NULL)
        GROUP BY UPPER (prs_srtperslid_omschrijving);

     recSPersLid        cSPersLid%ROWTYPE;

     CURSOR cPERSLID
     IS
        SELECT * FROM fac_imp_perslid;

     recPersLid         cPersLid%ROWTYPE;

    -- SUBPROC
    PROCEDURE upsertkenmerk_imp(p_perslid_key   IN NUMBER,
                                p_kenmerkwaarde IN VARCHAR2)
    AS
        ccount             NUMBER;
        v_sql              VARCHAR2(1000);
        v_cursor           INTEGER;
        v_rowsprocessed    NUMBER DEFAULT 0;
        v_waarde           prs_kenmerklink.prs_kenmerklink_waarde%TYPE;
        v_kenmerk_key      prs_kenmerk.prs_kenmerk_key%TYPE;
        v_kenmerk_type     prs_kenmerk.prs_kenmerk_kenmerktype%TYPE;
        v_kenmerk_niveau   prs_kenmerk.prs_kenmerk_niveau%TYPE;
        v_kenmerk_waarde   prs_kenmerklink.prs_kenmerklink_waarde%TYPE;
        v_objectnaam       fac_kenmerkdomein.fac_kenmerkdomein_objectnaam%TYPE;
        v_kolomnaam        fac_kenmerkdomein.fac_kenmerkdomein_kolomnaam%TYPE;
        v_kolomtxt         fac_kenmerkdomein.fac_kenmerkdomein_kolomtxt%TYPE;
        v_kenmerklink_key  prs_kenmerklink.prs_kenmerklink_key%TYPE;
    BEGIN
        v_kenmerk_key := fac.safe_to_number(SUBSTR (p_kenmerkwaarde, 1, INSTR (p_kenmerkwaarde, '=') - 1));
        v_kenmerk_waarde := SUBSTR (p_kenmerkwaarde, INSTR (p_kenmerkwaarde, '=') + 1);

        IF v_kenmerk_key IS NOT NULL AND v_kenmerk_waarde IS NOT NULL
        THEN
            v_errormsg := 'Fout bij bepalen kenmerk [' || v_kenmerk_key || ']';

            SELECT prs_kenmerk_niveau
                 , prs_kenmerk_kenmerktype
              INTO v_kenmerk_niveau
                 , v_kenmerk_type
              FROM prs_kenmerk
             WHERE prs_kenmerk_key = v_kenmerk_key
               AND prs_kenmerk_verwijder IS NULL;

            IF p_kenmerkwaarde IS NOT NULL
            THEN
                IF v_kenmerk_type IN ('R', 'r', 'S')
                THEN
                    v_errormsg := 'Fout bij bepalen eigen tabel';

                    SELECT COUNT (*)
                      INTO ccount
                      FROM prs_kenmerk k,
                           fac_kenmerkdomein d
                     WHERE k.prs_kenmerk_key = v_kenmerk_key
                       AND k.prs_kenmerk_niveau = v_kenmerk_niveau
                       AND k.fac_kenmerkdomein_key = d.fac_kenmerkdomein_key
                       AND d.fac_usrtab_key IS NOT NULL;

                    v_errormsg := 'Fout bij bepalen nieuwe waarde [' || p_kenmerkwaarde || ']';

                    IF ccount = 1
                    THEN                                                          -- Eigen tabel
                        SELECT TO_CHAR(ud.fac_usrdata_key)
                          INTO v_waarde
                          FROM prs_kenmerk k,
                               fac_kenmerkdomein d,
                               fac_v_aanwezigusrdata ud
                         WHERE k.prs_kenmerk_key = v_kenmerk_key
                           AND k.prs_kenmerk_niveau = v_kenmerk_niveau
                           AND k.fac_kenmerkdomein_key = d.fac_kenmerkdomein_key
                           AND d.fac_usrtab_key = ud.fac_usrtab_key
                           AND UPPER(TRIM(ud.fac_usrdata_omschr)) = UPPER(v_kenmerk_waarde);
                    ELSE                                                         -- FACILITOR view/tabel
                        SELECT d.fac_kenmerkdomein_objectnaam,
                               d.fac_kenmerkdomein_kolomnaam,
                               d.fac_kenmerkdomein_kolomtxt
                          INTO v_objectnaam,
                               v_kolomnaam,
                               v_kolomtxt
                          FROM prs_kenmerk k,
                               fac_kenmerkdomein d
                         WHERE k.prs_kenmerk_key = v_kenmerk_key
                           AND k.prs_kenmerk_niveau = v_kenmerk_niveau
                           AND k.fac_kenmerkdomein_key = d.fac_kenmerkdomein_key
                           AND d.fac_usrtab_key IS NULL;

                         v_sql := 'SELECT MAX(' || v_kolomnaam || ')'
                               || '  FROM '     || v_objectnaam
                               || ' WHERE UPPER(TRIM(' || v_kolomtxt || ')) = UPPER(:pwaarde)';

                         v_cursor := DBMS_SQL.open_cursor;
                         DBMS_SQL.parse (v_cursor, v_sql, DBMS_SQL.native);
                         DBMS_SQL.BIND_VARIABLE(v_cursor, ':pwaarde', v_kenmerk_waarde);
                         DBMS_SQL.define_column(v_cursor, 1, v_waarde, 255);
                         v_rowsprocessed := DBMS_SQL.execute_and_fetch (v_cursor);
                         DBMS_SQL.column_value (v_cursor, 1, v_waarde);
                         DBMS_SQL.close_cursor(v_cursor);
                    END IF;
                ELSE                                 -- C(Karakter)/D(Datum)/N(Numeriek)/X(Bestandsnaam)
                    v_waarde := v_kenmerk_waarde;
                END IF;

                v_errormsg := 'Fout bij bepalen huidige waarde';

                SELECT COUNT(*),
                       MAX(prs_kenmerklink_key)
                  INTO ccount,
                       v_kenmerklink_key
                  FROM prs_v_aanwezigkenmerklink
                 WHERE prs_link_key = p_perslid_key
                   AND prs_kenmerk_key = v_kenmerk_key
                   and prs_kenmerklink_niveau = v_kenmerk_niveau;

                IF v_kenmerk_type = 'N'  -- Alleen voor numerieke waarden de decimale komma vervangen door punt.
                THEN
                    v_waarde := REPLACE (v_waarde, ',', '.');
                END IF;

                IF ccount = 0
                THEN
                    v_errormsg := 'Fout bij toevoegen waarde [' || v_waarde || ']'
                               || ' voor perslid_key=' || TO_CHAR(p_perslid_key)
                               || ', kenmerk_key=' || TO_CHAR(v_kenmerk_key)
                               || ', link_niveau=' || v_kenmerk_niveau;

                    INSERT INTO prs_kenmerklink (prs_link_key,
                                                 prs_kenmerk_key,
                                                 prs_kenmerklink_niveau,
                                                 prs_kenmerklink_waarde)
                    VALUES (p_perslid_key,
                            v_kenmerk_key,
                            v_kenmerk_niveau,
                            v_waarde);
                ELSE
                    v_errormsg := 'Fout bij bijwerken waarde [' || v_waarde || ']'
                               || ' voor kenmerklink_key=' || TO_CHAR(v_kenmerklink_key);

                    UPDATE prs_kenmerklink
                       SET prs_kenmerklink_waarde = v_waarde
                     WHERE prs_kenmerklink_key = v_kenmerklink_key;
                END IF;
            ELSE
                -- Verwijder kenmerken die al bestaan maar met de nieuwe import leeg zijn.
                DELETE prs_kenmerklink
                 WHERE prs_kenmerk_key = v_kenmerk_key
                   AND prs_link_key = p_perslid_key;
            END IF;
        END IF;
    EXCEPTION
        WHEN OTHERS
        THEN
            oracle_err_num := SQLCODE;
            oracle_err_mes := SUBSTR(SQLERRM, 1, 200);
            v_errormsg := v_errormsg || ' (error ' || oracle_err_num || '/' || oracle_err_mes || ')';
            fac.imp_writelog (p_import_key,
                              'W',
                              v_aanduiding || v_errormsg,
                              'upsertkenmerk_imp');

    END; -- upsertkenmerk_imp

  BEGIN
     v_count_update := 0;
     v_count_tot := 0;
     v_count_error := 0;
     v_wpcount_error := 0;

     FOR recSPersLid IN cSPersLid
     LOOP
        BEGIN
           v_aanduiding := '';
           v_errormsg := '';
           v_errorhint := '';
           v_count_tot := v_count_tot + 1;

           v_aanduiding := recSPersLid.PRS_SRTPERSLID_OMSCHRIJVING;

           v_errorhint := 'Zoek in verwijderde functies';
           SELECT MAX(prs_srtperslid_key)
             INTO v_srtperslid_key
             FROM prs_srtperslid sp
            WHERE UPPER (sp.prs_srtperslid_omschrijving) = UPPER (recSPersLid.prs_srtperslid_omschrijving);

           IF v_srtperslid_key IS NULL
           THEN
              v_errorhint := 'Fout bij toevoegen functie';

              INSERT INTO prs_srtperslid (prs_srtperslid_omschrijving)
                   VALUES (recSPersLid.prs_srtperslid_omschrijving);
           ELSE
              v_errorhint := 'Reanimeer functie';
              UPDATE prs_srtperslid SET prs_srtperslid_verwijder = NULL WHERE prs_srtperslid_key = v_srtperslid_key;
           END IF;

           COMMIT;
        EXCEPTION
           WHEN OTHERS
           THEN
              v_count_error := v_count_error + 1;
              oracle_err_num := SQLCODE;
              oracle_err_mes := SUBSTR (SQLERRM, 1, 200);
              v_errormsg := ' (ORACLE error number = <'
                         || ORACLE_err_num
                         || '> ORACLE error message = <'
                         || ORACLE_err_mes
                         || '>)';

              fac.imp_writelog (p_import_key,
                                'E',
                                v_aanduiding || v_errormsg,
                                v_errorhint);

              COMMIT;                                          -- tbv logging
        END;
     END LOOP;

     fac.imp_writelog (
        p_import_key,
        'S',
        'Personeelsfunctie: toegevoegde regels zonder foutmelding: '
        || TO_CHAR (v_count_tot - v_count_error),
        '');

     fac.imp_writelog (
        p_import_key,
        'S',
        'Personeelsfunctie: toegevoegde regels met foutmelding: '
        || TO_CHAR (v_count_error),
        '');
     COMMIT;                                                       -- logging


     v_count_update := 0;
     v_count_tot := 0;
     v_count_error := 0;

     FOR recPersLid IN cPersLid
     LOOP
        BEGIN
           v_aanduiding := '';
           v_errormsg := '';
           v_errorhint := '';
           v_count_tot := v_count_tot + 1;

           v_aanduiding := recPersLid.prs_perslid_naam || '|'
                        || recPersLid.prs_perslid_voornaam || '| ';
           v_errormsg := '';

           v_errorhint := 'Fout bij bepalen functie';

           SELECT prs_srtperslid_key
             INTO v_srtperslid_key
             FROM prs_srtperslid
            WHERE prs_srtperslid_verwijder IS NULL
                  AND UPPER (prs_srtperslid_omschrijving) =
                      UPPER (recPersLid.prs_srtperslid_omschrijving);

           v_errorhint :=
                 'Afdeling niet gevonden ['
              || recPersLid.prs_afdeling_naam
              || ']';

           SELECT a.prs_afdeling_key
             INTO v_afdeling_key
             FROM prs_v_aanwezigafdeling_boom b, prs_afdeling a
            WHERE UPPER (a.prs_afdeling_naam) = UPPER (recPersLid.prs_afdeling_naam)
              AND a.prs_afdeling_verwijder IS NULL
              AND a.prs_afdeling_key = b.prs_afdeling_key;

           IF (recPersLid.prs_kostenplaats_nr IS NOT NULL)
           THEN
              v_errorhint :=
                   'Kostenplaats niet gevonden ['
                 || recPersLid.prs_kostenplaats_nr
                 || ']';

              SELECT k.prs_kostenplaats_key
                INTO v_kostenplaats_key
                FROM prs_v_aanwezigkostenplaats k
               WHERE UPPER(prs_kostenplaats_nr) = UPPER(recPerslid.prs_kostenplaats_nr);
           ELSE
              v_kostenplaats_key := NULL;
           END IF;

           v_space := '';
           -- kijk hoe we met partnernamen moeten omgaan:
           IF recPersLid.prs_perslid_naamgebruik_code = 0
           THEN
              -- normaal gebruik van naam. Eigen naam wordt gebruikt
              v_prs_perslid_naam := recPersLid.prs_perslid_naam;
              v_prs_perslid_tussenvoegsel := recPersLid.prs_perslid_tussenvoegsel;
           ELSIF recPersLid.prs_perslid_naamgebruik_code = 1
           THEN
              -- personen die de geboortenaam van de partner icm de eigen naam willen gebruiken
              IF recPersLid.prs_perslid_tussenvoegsel IS NOT NULL
              THEN
                 v_space := ' ';
              END IF;
              v_prs_perslid_naam := recPersLid.prs_perslid_partner_naam || ' - ' || recPersLid.prs_perslid_tussenvoegsel || v_space || recPersLid.prs_perslid_naam;
              v_prs_perslid_tussenvoegsel := recPersLid.prs_perslid_partner_tussenv;
           ELSIF recPersLid.prs_perslid_naamgebruik_code = 2
           THEN
              -- personen die de geboortenaam van de partner willen gebruiken
              v_prs_perslid_naam := recPersLid.prs_perslid_partner_naam;
              v_prs_perslid_tussenvoegsel := recPersLid.prs_perslid_partner_tussenv;
           ELSIF recPersLid.prs_perslid_naamgebruik_code = 3
           THEN
              -- personen die de eigen naam icm de geboortenaam van de partner willen gebruiken
              IF recPersLid.prs_perslid_partner_tussenv IS NOT NULL
              THEN
                 v_space := ' ';
              END IF;
              v_prs_perslid_naam := recPersLid.prs_perslid_naam || ' - ' || recPersLid.prs_perslid_partner_tussenv || v_space || recPersLid.prs_perslid_partner_naam;
              v_prs_perslid_tussenvoegsel := recPersLid.prs_perslid_tussenvoegsel;
           END IF;

           IF length(v_prs_perslid_naam) > 60
           THEN
              v_prs_perslid_naam := SUBSTR(v_prs_perslid_naam, 1,60);
              fac.imp_writelog (
                   p_import_key,
                   'W',
                   recPersLid.prs_perslid_naam || '|' || recPersLid.prs_perslid_voornaam || '| ' || 'Samengestelde achternaam is te lang',
                    'Aanduiding wordt afgebroken tot ['
                 || v_prs_perslid_naam
                 || ']');
           END IF;

           -- p_sleutelkolom
           --   NR     = prs_perslid_nr
           --   EMAIL  = prs_perslid_email
           --   LOGIN  = prs_perslid_oslogin
           --   APIKEY = prs_perslid_apikey
           v_errorhint := 'Kijken of de persoon al bestaat';

           SELECT MAX (prs_perslid_key), COUNT ( * )
             INTO v_perslid_key, v_count
             FROM prs_perslid
            WHERE prs_perslid_verwijder IS NULL
              AND (  (   p_sleutelkolom IS NULL
                     AND UPPER (prs_perslid_naam) = UPPER (recPersLid.prs_perslid_naam)
                     AND UPPER (prs_perslid_voornaam) = UPPER (recPersLid.prs_perslid_voornaam)
                     )
                  OR (  UPPER (p_sleutelkolom) = 'NR'     AND UPPER (prs_perslid_nr) = UPPER (recPersLid.prs_perslid_nr)
                     OR UPPER (p_sleutelkolom) = 'EMAIL'  AND UPPER (prs_perslid_email) = UPPER (recPersLid.prs_perslid_email)
                     OR UPPER (p_sleutelkolom) = 'LOGIN'  AND UPPER (prs_perslid_oslogin) = UPPER (recPersLid.prs_perslid_oslogin)
                     OR UPPER (p_sleutelkolom) = 'APIKEY' AND UPPER (prs_perslid_apikey) = UPPER (recPersLid.prs_perslid_apikey)
                     )
                  );

           IF (v_count = 0)
           THEN
              v_errorhint := 'Fout bij toevoegen persoon';

              INSERT INTO prs_perslid (prs_perslid_module,
                                       prs_srtperslid_key,
                                       prs_afdeling_key,
                                       prs_kostenplaats_key,
                                       prs_perslid_naam,
                                       prs_perslid_voorletters,
                                       prs_perslid_tussenvoegsel,
                                       prs_perslid_voornaam,
                                       prs_perslid_telefoonnr,
                                       prs_perslid_mobiel,
                                       prs_perslid_email,
                                       prs_perslid_nr,
                                       prs_perslid_geslacht,
                                       prs_perslid_titel,
                                       prs_perslid_dienstverband,
                                       prs_perslid_oslogin,
                                       prs_perslid_apikey)
                  VALUES ('PRS',
                          v_srtperslid_key,
                          v_afdeling_key,
                          v_kostenplaats_key,
                          v_prs_perslid_naam,
                          recPersLid.prs_perslid_voorletters,
                          v_prs_perslid_tussenvoegsel,
                          recPersLid.prs_perslid_voornaam,
                          recPersLid.prs_perslid_telefoonnr,
                          recPersLid.prs_perslid_mobiel,
                          recPersLid.prs_perslid_email,
                          recPersLid.prs_perslid_nr,
                          recPersLid.prs_perslid_geslacht,
                          recPersLid.prs_perslid_titel,
                          recPersLid.prs_perslid_dienstverband,
                          recPersLid.prs_perslid_oslogin,
                          recPersLid.prs_perslid_apikey)
               RETURNING prs_perslid_key
                    INTO v_perslid_key;

               prs.setpassword(v_perslid_key, recPersLid.prs_perslid_wachtwoord);

              COMMIT;
              v_count_update := v_count_update + 1;
           ELSIF v_count = 1
           THEN
              UPDATE prs_perslid
                 SET prs_srtperslid_key = v_srtperslid_key,
                     prs_afdeling_key = v_afdeling_key,
                     prs_perslid_naam = v_prs_perslid_naam,
                     prs_perslid_inactief = NULL, -- altijd potentieel reanimeren bij import, naam zal ook geen INACTIEF: prefix meer bevatten
                     prs_perslid_voorletters = recPersLid.prs_perslid_voorletters,
                     prs_perslid_tussenvoegsel = v_prs_perslid_tussenvoegsel,
                     prs_perslid_voornaam = recPersLid.prs_perslid_voornaam,
                     prs_perslid_nr = recPersLid.prs_perslid_nr,
                     prs_perslid_dienstverband = recPersLid.prs_perslid_dienstverband,
                     prs_perslid_geslacht = recPersLid.prs_perslid_geslacht,
                     prs_perslid_titel = recPersLid.prs_perslid_titel,
                     prs_perslid_telefoonnr = recPersLid.prs_perslid_telefoonnr,
                     prs_perslid_mobiel = recPersLid.prs_perslid_mobiel,
                     prs_perslid_email = recPersLid.prs_perslid_email,
                     prs_perslid_oslogin = recPersLid.prs_perslid_oslogin,
                     prs_perslid_apikey = recPersLid.prs_perslid_apikey
               WHERE prs_perslid_key = v_perslid_key;

              IF recPersLid.prs_perslid_wachtwoord IS NOT NULL
              THEN
                 prs.setpassword(v_perslid_key, recPersLid.prs_perslid_wachtwoord);
              END IF;
           END IF;

           -- Voor CUST-postprocessing (van de kenmerken) is het handig te onthouden:
           UPDATE fac_imp_perslid
              SET prs_perslid_key = v_perslid_key
            WHERE fac_import_key = recPersLid.fac_import_key
               AND fac_imp_file_index = recPersLid.fac_imp_file_index;

           COMMIT;                      -- persoon in ieder geval toegevoegd.

           IF (p_import_kenmerk = 1)
           THEN
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk1);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk2);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk3);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk4);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk5);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk6);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk7);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk8);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk9);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk10);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk11);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk12);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk13);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk14);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk15);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk16);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk17);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk18);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk19);
              upsertkenmerk_imp(v_perslid_key, recPersLid.prs_kenmerk20);
           END IF;

           v_aanduiding := recPersLid.prs_perslid_nr || '|'
                        || recPersLid.prs_perslid_naam || '|'
                        || recPersLid.prs_perslid_voornaam || '|'
                        || recPersLid.alg_locatie_code || '|'
                        || recPersLid.alg_gebouw_code  || '|'
                        || recPersLid.alg_verdieping_volgnr || '|'
                        || recPersLid.alg_ruimte_nr || ' - ';

           v_locatie_key := NULL;
           v_gebouw_key := NULL;
           v_verdieping_key := NULL;
           v_ruimte_key := NULL;

           v_errorhint := 'Fout bij bepalen locatie';
           SELECT   MAX(alg_locatie_key)
             INTO   v_locatie_key
             FROM   alg_v_aanweziglocatie
            WHERE   UPPER (alg_locatie_code) = UPPER (recPersLid.alg_locatie_code);

           v_errorhint := 'Fout bij bepalen gebouw';
           SELECT   MAX(alg_gebouw_key)
             INTO   v_gebouw_key
             FROM   alg_v_aanweziggebouw
            WHERE   UPPER (alg_gebouw_code) = UPPER (recPersLid.alg_gebouw_code)
                    AND alg_locatie_key = v_locatie_key;

           v_errorhint := 'Fout bij bepalen verdieping';
           SELECT   MAX(alg_verdieping_key)
             INTO   v_verdieping_key
             FROM   alg_v_aanwezigverdieping
            WHERE   UPPER (alg_verdieping_volgnr) = UPPER (recPersLid.alg_verdieping_volgnr)
                    AND alg_gebouw_key = v_gebouw_key;

           v_errorhint := 'Fout bij bepalen beoogde ruimte';
           SELECT   MAX(alg_ruimte_key)
             INTO   v_ruimte_key
             FROM   alg_v_aanwezigruimte r
            WHERE   r.alg_ruimte_upper_nr = UPPER (recPersLid.alg_ruimte_nr)
                    AND r.alg_verdieping_key = v_verdieping_key;

           -- standaard ruimte moet door cust gedeelte van deFout bij bepalen beoogde ruimte import ingevuld worden.

           -- als er een locatie ingevuld is willen we ook een ruimte vinden.
           IF v_ruimte_key IS NULL AND recPersLid.alg_locatie_code IS NOT NULL
           THEN
              fac.imp_writelog (p_import_key,
                                'W',
                                v_aanduiding || ' Ruimte kan niet gevonden worden',
                                'Controleer locatie,gebouw en verdieping');
           END IF;

           -- fouten bij het bepalen van de werkplek worden als waarschuwing weergegeven.
           BEGIN
               v_errorhint := 'Fout bij het aanpassen van de werkplek';
               PRS.movetoruimte (v_perslid_key, v_ruimte_key, p_alg_type);
           EXCEPTION WHEN OTHERS
           THEN
              v_wpcount_error := v_wpcount_error + 1;
              oracle_err_num := SQLCODE;
              oracle_err_mes := SUBSTR (SQLERRM, 1, 200);
              v_errormsg := ' (ORACLE error number = <' || ORACLE_err_num || '> ORACLE error message = <' || ORACLE_err_mes || '>)';
              fac.imp_writelog (p_import_key, 'W', v_aanduiding || v_errormsg, v_errorhint);
           END;

        EXCEPTION WHEN OTHERS
        THEN
           v_count_error := v_count_error + 1;
           oracle_err_num := SQLCODE;
           oracle_err_mes := SUBSTR (SQLERRM, 1, 200);
           v_errormsg := ' (ORACLE error number = <' || ORACLE_err_num || '> ORACLE error message = <' || ORACLE_err_mes || '>)';
           fac.imp_writelog (p_import_key, 'E', v_aanduiding || v_errormsg, v_errorhint);
           COMMIT;                                          -- tbv logging
        END;

     END LOOP;

     fac.imp_writelog (
        p_import_key,
        'S',
        'Persoon: verwerkte regels zonder foutmelding: '
        || TO_CHAR (v_count_tot - v_count_error),
        '');

     fac.imp_writelog (
        p_import_key,
        'S',
        'Persoon: verwerkte regels met foutmelding: '
        || TO_CHAR (v_count_error),
        '');

     fac.imp_writelog (
        p_import_key,
        'S',
        'Werkplek: verwerkte regels met foutmelding: '
        || TO_CHAR (v_wpcount_error),
        '');
  END update_perslid;


  PROCEDURE delete_perslid (p_import_key     IN NUMBER,
                            p_perslid_key    IN NUMBER)
  IS
     v_errormsg       VARCHAR2 (1000);
     v_errorhint      VARCHAR2 (1000);
     oracle_err_num   NUMBER;
     oracle_err_mes   VARCHAR2 (200);

     v_count          NUMBER (10);

     --
     v_perslid_naam   VARCHAR (100);
     v_perslid_nr     VARCHAR (30);
  BEGIN
     BEGIN
        v_errormsg := 'Verwijderen van de persoon is NIET gelukt';
        v_errorhint :=
              'Heeft de persoon met prs_perslid_key '
           || TO_CHAR (p_perslid_key)
           || ' historie?';

        SELECT prs_perslid_naam_full, prs_perslid_nr
          INTO v_perslid_naam, v_perslid_nr
          FROM prs_perslid p, prs_v_perslid_fullnames pf
         WHERE p.prs_perslid_key = pf.prs_perslid_key
               AND p.prs_perslid_key = p_perslid_key;

        -- *** Budgethouderschap ***
        -- Voor hoeveel kostenplaatsen is deze persoon budgethouder?
        SELECT COUNT ( * )
          INTO v_count
          FROM prs_kostenplaats
         WHERE prs_perslid_key = p_perslid_key;

        IF (v_count > 0)
        THEN
           UPDATE prs_kostenplaats
              SET prs_perslid_key = NULL
            WHERE prs_perslid_key = p_perslid_key;

           fac.imp_writelog (
              p_import_key,
              'I',
                 'Budgethouderschap van te verwijderen persoon ('
              || v_count
              || ' stuks) vervallen.',
              'Naam/persoonsnr: ' || v_perslid_naam || '/' || v_perslid_nr);
        END IF;

        -- *** Vervangers ***
        -- koppelingen met vervangers dienen ook verwijderd te worden
        SELECT COUNT ( * )
          INTO v_count
          FROM prs_collega
         WHERE prs_perslid_key = p_perslid_key
               OR prs_perslid_key_alt = p_perslid_key;

        IF (v_count > 0)
        THEN
           DELETE FROM prs_collega
                 WHERE prs_perslid_key = p_perslid_key
                       OR prs_perslid_key_alt = p_perslid_key;

           fac.imp_writelog (
              p_import_key,
              'I',
              'Te verwijderen persoon heeft vervanger(s). Koppeling(en) verwijderd.',
              'Naam/persoonsnr: ' || v_perslid_naam || '/' || v_perslid_nr);
        END IF;

        -- *** werkplekken ***
        -- per 5.3.2 worden impliciete werkplekken via trigger verwijderd!

        DELETE prs_perslidwerkplek
         WHERE prs_perslid_key = p_perslid_key;

        -- *** Verplichtingen ***
        SELECT COUNT ( * )
          INTO v_count
          FROM prs_v_verplichting_refcheck vp
         WHERE vp.prs_perslid_key = p_perslid_key;

        IF v_count = 0
        THEN
           -- Persoon heeft geen enkele (actuele of historische) verplichting
           v_errorhint :=
              'Verwijderen van persoon met key ' || TO_CHAR (p_perslid_key);

           -- Referenties in tabellen naar deze pers_perslid_key moeten eerst verwijderd worden.
           -- Door cascade verwijderen van deze record onstaan audits op die tabellen die audit tracking hebben.
           -- Daardoor onstaan "ORxA-04091:table VLKC.FAC_AUDIT is mutating, trigger/function may not see it" foutmeldingen
           -- op de delete van de prs_perslid_key uit de prs_perslid tabel.
           -- De tabellen prs_kostenplaats, prs_kostenplaatsgrp, prs_perslidkostenplaats en fac_gebruikersgroep hebben een prs_perslid_key referentie en audit tracking.
           DELETE FROM prs_kostenplaats
                 WHERE prs_perslid_key = p_perslid_key;
           DELETE FROM prs_kostenplaatsgrp
                 WHERE prs_perslid_key = p_perslid_key;
           DELETE FROM prs_perslidkostenplaats
                 WHERE prs_perslid_key = p_perslid_key;
           DELETE FROM fac_gebruikersgroep
                 WHERE prs_perslid_key = p_perslid_key;

           DELETE FROM prs_perslid
                 WHERE prs_perslid_key = p_perslid_key;

           fac.imp_writelog (
              p_import_key,
              'I',
              'Persoon verwijderd.',
                 'Achternaam/persoonsnr: '
              || v_perslid_naam
              || '/'
              || v_perslid_nr);
        ELSE
           -- Controleer of er ACTUELE verplichtingen zijn
           SELECT COUNT ( * )
             INTO v_count
             FROM prs_v_verplichting_keys vp
            WHERE vp.prs_perslid_key = p_perslid_key;

           IF v_count > 0
           THEN
              UPDATE prs_perslid
                 SET prs_perslid_naam =
                        SUBSTR ('INACTIEF:' || prs_perslid_naam, 1, 60),
                     prs_perslid_inactief = SYSDATE,
                     prs_perslid_oslogin = NULL,
                     prs_perslid_oslogin2 = NULL
               WHERE prs_perslid_key = p_perslid_key
                     AND prs_perslid_naam NOT LIKE 'INACTIEF:%';

              fac.imp_writelog (
                 p_import_key,
                 'I',
                 'Persoon als INACTIEF gemarkeerd of was al INACTIEF gemarkeerd.',
                    'Achternaam/persoonsnr: '
                 || v_perslid_naam
                 || '/'
                 || v_perslid_nr);
           ELSE
              BEGIN
                 UPDATE prs_perslid
                    SET prs_perslid_verwijder = SYSDATE
                  WHERE prs_perslid_key = p_perslid_key;

                 fac.imp_writelog (
                    p_import_key,
                    'I',
                    'Persoon geïnactiveerd.',
                       'Achternaam/persoonsnr: '
                    || v_perslid_naam
                    || '/'
                    || v_perslid_nr);
              EXCEPTION
                 WHEN OTHERS
                 THEN
                    -- Kennelijk heeft de persoon toch ernstige verplichtingen
                    v_errorhint :=
                          'Persoon heeft nog (max. '
                       || TO_CHAR (v_count)
                       || ') verplichtingen. Naam/persoonsnr: '
                       || v_perslid_naam
                       || '/'
                       || v_perslid_nr;
                    fac.imp_writelog (p_import_key,
                                      'I',
                                      'Inactiveren persoon is niet gelukt',
                                      v_errorhint);
              END;
           END IF;
        END IF;
     EXCEPTION
        WHEN OTHERS
        THEN
           oracle_err_num := SQLCODE;
           oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
           v_errormsg :=
                 '(ORACLE error '
              || oracle_err_num
              || '/'
              || oracle_err_mes
              || ')';
           fac.imp_writelog (p_import_key,
                             'E',
                             v_errormsg,
                             v_errorhint);
     END;
  END delete_perslid;

   -- Verwijder ook alle children
   -- Let wel dat de trigger van alles kan tegengaan (nog personen, objecten enz.)
   PROCEDURE set_afdeling_verwijder (p_afdeling_key IN NUMBER)
   AS
   BEGIN
      UPDATE prs_afdeling
         SET prs_afdeling_verwijder = SYSDATE
       WHERE prs_afdeling_verwijder IS NULL
         AND prs_afdeling_key IN (   SELECT prs_afdeling_key
                                       FROM prs_afdeling
                                 START WITH prs_afdeling_key = p_afdeling_key
                                 CONNECT BY PRIOR prs_afdeling_key = prs_afdeling_parentkey);
   END;


   FUNCTION combinatievalidatie (p_kp_key IN NUMBER, p_ksrt_key IN NUMBER, p_disc_key IN NUMBER)
      RETURN BOOLEAN
   AS
      l_dummy            prs_kostencombinatie.prs_kostencombinatie_key%TYPE;
      l_kp_key           prs_kostenplaats.prs_kostenplaats_key%TYPE;
      l_ksrt_key         prs_kostensoort.prs_kostensoort_key%TYPE;
      l_disc_key         mld_stdmelding.mld_ins_discipline_key%TYPE;
      l_combination_OK   BOOLEAN DEFAULT FALSE;                                         -- Start de afvalrace met FALSE.
      l_kpgrp_key        prs_kostenplaatsgrp.prs_kostenplaatsgrp_key%TYPE DEFAULT -1;
   BEGIN
      l_kp_key := p_kp_key;
      l_ksrt_key := p_ksrt_key;
      l_disc_key := p_disc_key;

      -- Als de kostensoort niet werd meegegeven dan deze proberen zelf te bepalen.
      IF l_ksrt_key IS NULL AND l_disc_key IS NOT NULL
      THEN
         SELECT prs_kostensoort_key
           INTO l_ksrt_key
           FROM ins_tab_discipline
          WHERE ins_discipline_key = l_disc_key;
      END IF;

      -- Start de afvalrace.
      IF l_kp_key IS NULL OR l_ksrt_key IS NULL
      THEN
         l_combination_OK := TRUE;
      END IF;

      IF NOT l_combination_OK
      THEN
         BEGIN
            SELECT prs_kostenplaatsgrp_key
              INTO l_kpgrp_key
              FROM prs_kostenplaats
             WHERE prs_kostenplaats_key = l_kp_key;
            -- het is goed als er geen groep gedefinieerd is
            l_combination_OK := l_kpgrp_key IS NULL;
         EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
               NULL;
         END;
      END IF;

      IF NOT l_combination_OK
      THEN
         BEGIN
            -- Geldt er uberhaupt een restrictie op deze kostensoort?
            SELECT DISTINCT 1
              INTO l_dummy
              FROM prs_kostencombinatie kc
             WHERE kc.prs_kostensoort_key = l_ksrt_key;
         EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
               l_combination_OK := TRUE;
         END;
      END IF;

      IF NOT l_combination_OK
      THEN
         BEGIN
            SELECT prs_kostencombinatie_key
              INTO l_dummy
              FROM prs_kostencombinatie kc
             WHERE kc.prs_kostenplaatsgrp_key = l_kpgrp_key
               AND kc.prs_kostensoort_key = l_ksrt_key;
            -- Er is een geldige combinatie gevonden.
            l_combination_OK := TRUE;
         EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
               NULL;
         END;
      END IF;

      RETURN l_combination_OK;
   END;

   PROCEDURE personen_inactief_schonen
   AS
      CURSOR c1
      IS
         SELECT '[' || TO_CHAR (p.prs_perslid_key) || '|' || p.prs_perslid_email || '|' || pf.prs_perslid_naam_full || '] '    aanduiding
              , p.prs_perslid_key
              , COUNT (vp.prs_perslid_key) aant
           FROM prs_v_aanwezigperslid p
              , prs_v_verplichting_keys vp
              , prs_v_perslid_fullnames pf
          WHERE p.prs_perslid_key = vp.prs_perslid_key(+) -- Actuele verplichtingen?
            AND p.prs_perslid_key = pf.prs_perslid_key
            AND COALESCE (p.prs_perslid_inactief, SYSDATE) < TRUNC (SYSDATE)
      --    AND p.prs_perslid_externid IS NOT NULL                    -- SCIM-populatie!
          GROUP BY '[' || TO_CHAR (p.prs_perslid_key) || '|' || p.prs_perslid_email || '|' || pf.prs_perslid_naam_full || '] '
                 , p.prs_perslid_key
          ORDER BY 2;

      v_errormsg         VARCHAR2(1000);
      oracle_err_num     NUMBER;
      oracle_err_mes     VARCHAR2(200);
      v_count_del        NUMBER(10);
      v_schedular_user   NUMBER(10) := NULL;
   BEGIN
      v_count_del := 0;
      FOR rec IN c1
      LOOP
         BEGIN
            IF rec.aant = 0
            THEN
               v_errormsg := 'Fout schonen collega';
               DELETE
                 FROM prs_collega
                WHERE prs_perslid_key = rec.prs_perslid_key
                   OR prs_perslid_key_alt = rec.prs_perslid_key;

               v_errormsg := 'Fout schonen perslid';
               UPDATE prs_perslid
                  SET prs_perslid_verwijder = SYSDATE
                WHERE prs_perslid_key = rec.prs_perslid_key;

               fac.trackaction ('PRSDEL', rec.prs_perslid_key, v_schedular_user, NULL, NULL);

               v_count_del := v_count_del + 1;
               IF MOD (v_count_del, 1000) = 0
               THEN
                  COMMIT;
               END IF;
            ELSE
               fac.writelog ('PRS_PERSLID_SCHONEN', 'I', rec.aanduiding || '/#Verplichtingen: ' || TO_CHAR (rec.aant), 'Persoon niet geschoond');
            END IF;
         EXCEPTION
            WHEN OTHERS
            THEN  -- Kennelijk heeft persoon toch nog ernstige verplichtingen!
               oracle_err_num := SQLCODE;
               oracle_err_mes := SUBSTR (SQLERRM, 1, 200);
               v_errormsg := v_errormsg || ' ORACLE (error ' || oracle_err_num || '/' || oracle_err_mes || ')';
               fac.writelog ('PRS_PERSLID_SCHONEN', 'W', rec.aanduiding || v_errormsg, 'Fout schonen persoon');
         END;
      END LOOP;
      fac.writelog ('PRS_PERSLID_SCHONEN', 'S', 'Personen/#geschoond: ' || TO_CHAR (v_count_del), '');
      COMMIT;
   EXCEPTION
      WHEN OTHERS
      THEN
         oracle_err_num := SQLCODE;
         oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
         v_errormsg := v_errormsg || ' ORACLE (error ' || oracle_err_num || '/' || oracle_err_mes || ')';
         fac.writelog ('PRS_PERSLID_SCHONEN', 'E', v_errormsg, '');
         COMMIT;
   END;

   PROCEDURE personen_vervangers_schonen
   AS
      v_count_del        NUMBER(10);
   BEGIN
      v_count_del := 0;

      DELETE
        FROM prs_collega
       WHERE prs_collega_vervaldatum < TRUNC(SYSDATE);
      v_count_del := SQL%ROWCOUNT;

      IF v_count_del > 0
      THEN
         fac.writelog ('PRS_COLLEGA_SCHONEN', 'S', 'Vervangers/#geschoond: ' || TO_CHAR (v_count_del), '');
      END IF;
   END;

END prs;
/

REGISTERRUN('$Id$')
#endif // PRS