#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);

   FUNCTION combinatievalidatie (p_kp_key IN NUMBER, p_ksrt_key IN NUMBER, p_disc_key IN NUMBER) RETURN BOOLEAN;
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 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;

      IF (lkpverantwkey = -1 OR lkpverantwkey = pexcludekey OR lexcludeisvervanger = 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.
   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 NOT EXISTS
                               (SELECT prs_perslid_key
                                  FROM fac_tracking t,
                                       fac_srtnotificatie st
                                 WHERE t.fac_srtnotificatie_key = st.fac_srtnotificatie_key
                                   AND st.fac_srtnotificatie_code = 'BESFIT'
                                   AND fac_tracking_refkey = b.bes_bestelling_key)
                      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_dummy 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 (1);
     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_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 (256);
     v_prs_kenmerk2                  VARCHAR2 (256);
     v_prs_kenmerk3                  VARCHAR2 (256);
     v_prs_kenmerk4                  VARCHAR2 (256);
     v_prs_kenmerk5                  VARCHAR2 (256);
     v_prs_kenmerk6                  VARCHAR2 (256);
     v_prs_kenmerk7                  VARCHAR2 (256);
     v_prs_kenmerk8                  VARCHAR2 (256);
     v_prs_kenmerk9                  VARCHAR2 (256);
     v_prs_kenmerk10                 VARCHAR2 (256);
     v_prs_kenmerk11                 VARCHAR2 (256);
     v_prs_kenmerk12                 VARCHAR2 (256);
     v_prs_kenmerk13                 VARCHAR2 (256);
     v_prs_kenmerk14                 VARCHAR2 (256);
     v_prs_kenmerk15                 VARCHAR2 (256);
     v_prs_kenmerk16                 VARCHAR2 (256);
     v_prs_kenmerk17                 VARCHAR2 (256);
     v_prs_kenmerk18                 VARCHAR2 (256);
     v_prs_kenmerk19                 VARCHAR2 (256);
     v_prs_kenmerk20                 VARCHAR2 (256);
     v_alg_verdieping_volgnr_num     NUMBER;
     v_prs_werkplek_volgnr_num       NUMBER;
     v_prs_perslid_dienstv_num       NUMBER;

     v_seq_of_columns                VARCHAR2 (200);

     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;
  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
     DELETE FROM   fac_imp_perslid;

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

     -- Init
     v_fielddelimitor := ';';
     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 de te importeren kolommen in de CSV uitlezen uit v_seq_of_columns
        fac.imp_getfield (v_seq_of_columns,
                          v_fielddelimitor,
                          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
              IF UPPER (v_newline) LIKE UPPER (p_header)
              THEN
                 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_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 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) > 15
              THEN
                 v_prs_perslid_telefoonnr :=
                    SUBSTR (v_prs_perslid_telefoonnr, 1, 15);
                 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) > 15
              THEN
                 v_prs_perslid_mobiel := SUBSTR (v_prs_perslid_mobiel, 1, 15);
                 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) > 60
              THEN
                 v_prs_srtperslid_omschrijving :=
                    SUBSTR (v_prs_srtperslid_omschrijving, 1, 60);
                 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) > 30
              THEN
                 v_prs_perslid_oslogin := SUBSTR (v_prs_perslid_oslogin, 1, 30);
                 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_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_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,
                             v_prs_kenmerk1,
                             v_prs_kenmerk2,
                             v_prs_kenmerk3,
                             v_prs_kenmerk4,
                             v_prs_kenmerk5,
                             v_prs_kenmerk6,
                             v_prs_kenmerk7,
                             v_prs_kenmerk8,
                             v_prs_kenmerk9,
                             v_prs_kenmerk10,
                             v_prs_kenmerk11,
                             v_prs_kenmerk12,
                             v_prs_kenmerk13,
                             v_prs_kenmerk14,
                             v_prs_kenmerk15,
                             v_prs_kenmerk16,
                             v_prs_kenmerk17,
                             v_prs_kenmerk18,
                             v_prs_kenmerk19,
                             v_prs_kenmerk20,
                             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 (1) := ';';

     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_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_kenmerk          VARCHAR2(60);
        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_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
        IF p_kenmerkwaarde IS NOT NULL
        THEN
            v_errormsg := 'Fout bij bepalen kenmerk [' || p_kenmerkwaarde || ']';

            v_kenmerk := SUBSTR(p_kenmerkwaarde, 1, INSTR(p_kenmerkwaarde, '=') - 1);
            v_waarde  := SUBSTR(p_kenmerkwaarde, INSTR(p_kenmerkwaarde, '=') + 1);

            IF fac.safe_to_number (v_kenmerk) IS NULL
            THEN
               SELECT k.prs_kenmerk_key,
                      k.prs_kenmerk_kenmerktype,
                      k.prs_kenmerk_niveau
                 INTO v_kenmerk_key,
                      v_kenmerk_type,
                      v_kenmerk_niveau
                 FROM (  SELECT ks.prs_kenmerk_key,
                                ks.prs_kenmerk_kenmerktype,
                                ks.prs_kenmerk_niveau,
                                ks.prs_kenmerk_volgnr
                           FROM prs_v_aanwezigkenmerk ks
                          WHERE ks.prs_kenmerk_kenmerktype IN ('C', 'D', 'N', 'R', 'S', 'X', 'B', 'V')
                            AND COALESCE(UPPER(ks.prs_kenmerk_omschrijving), ks.prs_kenmerk_upper) = UPPER(v_kenmerk)
                          ORDER BY ks.prs_kenmerk_volgnr
                      ) k
                WHERE ROWNUM = 1;
            ELSE
                SELECT k.prs_kenmerk_key,
                       k.prs_kenmerk_kenmerktype,
                       k.prs_kenmerk_niveau
                  INTO v_kenmerk_key,
                       v_kenmerk_type,
                       v_kenmerk_niveau
                  FROM prs_v_aanwezigkenmerk k
                 WHERE k.prs_kenmerk_key = v_kenmerk
                   AND k.prs_kenmerk_kenmerktype IN ('C', 'D', 'N', 'R', 'S', 'X', 'B', 'V')
                 ORDER BY k.prs_kenmerk_volgnr;
            END IF;

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

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

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

                    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.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_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.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_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)
                    NULL; -- v_waarde := p_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;

                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;

           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_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_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_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_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;

   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;

END prs;
/

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