#ifdef CND
/*
 * $Revision$
 * $Id$
 */

 -- If all scores are uptodate, the next statement should have no result
-- SELECT ins_deel_key,
--        ins_deel_mjb_score1,
--        cnd.calculate_cond_score (ins_deel_key) cond,
--        ins_deel_mjb_score2,
--        cnd.calculate_prio_score (ins_deel_key) prio
--   FROM ins_deel
--  WHERE     (ins_deel_mjb_score1 IS NOT NULL OR ins_deel_mjb_score2 IS NOT NULL)
--        AND (   ins_deel_mjb_score1 <> cnd.calculate_cond_score (ins_deel_key)
--             OR ins_deel_mjb_score2 <> cnd.calculate_prio_score (ins_deel_key));
-- Note: this might take about 8 seconds/100 objects (depending on whatever)
--
-- Wat is het verhaal van de Facilitor-conditiemetingen?
-- - Er zijn objectgebonden meldingen met eigenschappen (cnd_ini.sql) die de conditiescore/prioriteit van een object (of "element") bepalen
-- - Er zijn 2 werkwijzen, nu aangeduid met setting cnd_gebreken_scoremethode
-- - - 1: deze meldingen stellen een meting voor, een inspectie, een opname. Die bepaalt dan de scores en je maakt vervolgmeldingen om te herstellen;
-- -      daar telde iedere melding mee ongeacht de status (behalve vervallen of verwerkt(?))
-- - - 2: deze meldingen constateren een gebrek, dat de scores bepaalt maar tegelijkertijd de melding is om het te herstellen. Afgemeld is het gebrek weg.
-- -      als zo'n melding geaccepteerd/in behandeling is (status 0,4,7) telt die mee voor de score, anders niet
--
-- Onze berekening van de scores is nu stateless, d.w.z. je kunt de huidige score op elk moment herberekenen tot hetzelfde resultaat.
-- Dat is principieel anders dan het was: je mocht eenmalig berekenen op bepaalde triggermomenten, maar daarbuiten niet meer, berekeningen waren niet reproduceerbaar.
-- Gebrekmeldingen die Verwerkt(6) of Afgewezen(1) zijn beschouwen we totaal niet, die halen we direct al weg uit de processing, die bestaan niet.
--
-- - de score van een object kan dus wijzigen indien er een bijbehorende gebrekmelding van/naar die status gaat of anderszins verandert (verwijderd bv)
--   de resterende gebreken bepalen dan de actuele score
-- - als er geen gebreken zijn dan is de score onbekend (nooit gebrek geweest) of nieuwstaat (1)
-- - er kan ook een "Geen Gebrek" melding gedaan worden, die alles reset: oudere gebreken Verwerkt en score naar 1.
--
-- - Dus: je kunt in principe op elk moment de score van een object bepalen obv de meldingen van dat moment
-- - middels triggers of aanroepen (in ASP of waar nodig) forceren we herberekening. Veranderingen worden getrackt
--   indien de score(s) ook daadwerkelijk veranderen
-- - gebreken kunnen ook in bulk geimporteerd worden
--


CREATE OR REPLACE PACKAGE cnd
AS
    -- Package-globals
    gsrtdisckey       NUMBER := fac.getsetting ('cnd_gebreken_srtdisc_key');
    gcndusagemodel    NUMBER := fac.getsetting ('cnd_usage_model');
    gcndscoremethod   NUMBER := fac.getsetting ('cnd_scoremethod');

    -- Fair change you will never need these functions from the outside (hence might be skipped here)
    FUNCTION nen2767_meth12_cond_score (p_ernst IN NUMBER, p_intens IN NUMBER, p_omvang IN NUMBER)
        RETURN NUMBER;

    FUNCTION nen2767_meth3_cond_score (p_cond_score_corr_str IN VARCHAR2, p_omvang_str IN VARCHAR2)
        RETURN NUMBER;

    FUNCTION nen2767_corr_cond_score (p_cond_score IN NUMBER)
        RETURN NUMBER;

    FUNCTION nen2767_cond_herleiding (p_cond_tussen_score IN NUMBER)
        RETURN NUMBER;

    -- These primitives may be convenient
    FUNCTION calculate_prio_score (p_deel_key IN NUMBER, p_mld_key IN NUMBER DEFAULT NULL)
        RETURN NUMBER;

    FUNCTION calculate_cond_score (p_deel_key IN NUMBER, p_mld_key IN NUMBER DEFAULT NULL)
        RETURN NUMBER;

    -- Call this procedure to update the score of p_deel_key based on actual 'gebreken'-meldingen
    PROCEDURE update_mjb_scores (p_deel_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL);

    -- Call this procedure to update scores of objects possible affected by p_melding_key
    PROCEDURE process_mjb_score_effects (p_melding_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL);

    -- Call this procedure to reset all active gebreken-melding on an object (because is has been replaced)
    PROCEDURE resetgebreken (p_deel_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL);

    -- Call this procedure after closing an (MJB)-task, to check whether it is the last task and all gebreken should be reset
    PROCEDURE process_mjb_gebreken (p_deelsrtcontrole_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL);

    -- Call this procedure to update aggregate scores (for a location/building)
    PROCEDURE update_aggr_scores (p_locatie_key IN NUMBER DEFAULT NULL, p_gebouw_key IN NUMBER DEFAULT NULL);

END;
/

CREATE OR REPLACE PACKAGE BODY cnd
AS
    -- Get the key that corresponds to the given value in the given user-table
    -- Returns NULL if that does not exist
    FUNCTION get_usrdata_key (p_usrtab_object IN VARCHAR2, p_usrdata_code IN VARCHAR2)
        RETURN NUMBER
    AS
        v_usrdata_key   fac_usrdata.fac_usrdata_key%TYPE;
    BEGIN
        SELECT fac_usrdata_key
          INTO v_usrdata_key
          FROM fac_usrtab ut, fac_usrdata ud
         WHERE     ut.fac_usrtab_key = ud.fac_usrtab_key
               AND ut.fac_usrtab_object = UPPER (p_usrtab_object)
               AND ud.fac_usrdata_upper = UPPER (p_usrdata_code)
               AND fac_usrdata_verwijder IS NULL;
        RETURN v_usrdata_key;
    END;
    -- Levert de conditiescore (1..5) op basis van de ernst, intensiteit en omvang.
    FUNCTION nen2767_meth12_cond_score (p_ernst IN NUMBER, p_intens IN NUMBER, p_omvang IN NUMBER)
        RETURN NUMBER
    AS
        v_result                      NUMBER;
        v_ernstig_gebrek_key          NUMBER;
        v_serieus_gebrek_key          NUMBER;
        v_gering_gebrek_key           NUMBER;
        v_begin_intensiteit_key       NUMBER;
        v_gevorderd_intensiteit_key   NUMBER;
        v_eind_intensiteit_key        NUMBER;
    BEGIN
        v_ernstig_gebrek_key := get_usrdata_key ('USR_ERNST', 'E - Ernstig gebrek');
        v_serieus_gebrek_key := get_usrdata_key ('USR_ERNST', 'S - Serieus gebrek');
        v_gering_gebrek_key := get_usrdata_key ('USR_ERNST', 'G - Gering gebrek');
        v_begin_intensiteit_key := get_usrdata_key ('USR_INTENSITEIT', '1 - Beginstadium');
        v_gevorderd_intensiteit_key :=
            get_usrdata_key ('USR_INTENSITEIT', '2 - Gevorderd stadium');
        v_eind_intensiteit_key := get_usrdata_key ('USR_INTENSITEIT', '3 - Eindstadium');
        v_result := NULL;
        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'nen2767_meth12_cond_score');
        CASE
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 1;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 2;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 3;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 4;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 2;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 3;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 4;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 5;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 2;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 3;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 4;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 5;
            WHEN     p_ernst = v_ernstig_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 6;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 1;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 1;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 2;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 3;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 1;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 2;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 3;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 4;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 2;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 3;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 4;
            WHEN     p_ernst = v_serieus_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 5;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_begin_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 2;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 2;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_gevorderd_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 3;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 2
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 10
            THEN
                v_result := 1;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 30
            THEN
                v_result := 2;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang < 70
            THEN
                v_result := 3;
            WHEN     p_ernst = v_gering_gebrek_key
                 AND p_intens = v_eind_intensiteit_key
                 AND p_omvang <= 100
            THEN
                v_result := 4;
        END CASE;
        RETURN v_result;
    EXCEPTION
        WHEN OTHERS                                                         -- dit mag nooit van Jos
        THEN
            DBMS_OUTPUT.put_line ('Als je dit ziet zocht je je de blubber#1');
            RETURN NULL;
    END;
    -- NEN2767-2. - Functie die de conditiescore berekent als de gebreken zeker weten verschillen in ernst en intensiteit
    FUNCTION nen2767_meth3_cond_score (p_cond_score_corr_str IN VARCHAR2, p_omvang_str IN VARCHAR2)
        RETURN NUMBER
    AS
        v_result                NUMBER (10, 4);
        v_cond_score_corr_str   VARCHAR2 (255);
        v_omvang_str            VARCHAR2 (255);
        v_fielddelimitor        VARCHAR2 (1);
        l_cond_score_corr       NUMBER (10, 2);
        l_omvang                NUMBER (10);
        l_som_omvang            NUMBER (10);
    BEGIN
        v_result := 0;
        v_fielddelimitor := ';';
        l_som_omvang := 0;
        v_cond_score_corr_str := p_cond_score_corr_str;
        v_omvang_str := p_omvang_str;
        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'nen2767_meth3_cond_score');
        WHILE (v_cond_score_corr_str IS NOT NULL AND v_omvang_str IS NOT NULL)
        LOOP
            BEGIN
                fac.imp_getfield (v_cond_score_corr_str, v_fielddelimitor, l_cond_score_corr);
                fac.imp_getfield (v_omvang_str, v_fielddelimitor, l_omvang);
                v_result :=
                      v_result
                    + (fac.safe_to_number (l_cond_score_corr) * fac.safe_to_number (l_omvang));
                l_som_omvang := l_som_omvang + fac.safe_to_number (l_omvang);
            END;
        END LOOP;
        v_result := ROUND (v_result / l_som_omvang, 4);
        v_result := cnd.nen2767_cond_herleiding (v_result);
        RETURN v_result;
    EXCEPTION
        WHEN OTHERS
        THEN
            DBMS_OUTPUT.put_line ('Als je dit ziet zocht je je de blubber#2');
            RETURN NULL;
    END;
    -- Berekent de correctiefactor (hoe zwaar een conditiescore meetelt) volgens NEN2767 tabel B.1
	-- wat nodig is wanneer er 2 of meer gebreken met verschillende ernst/intensiteit op hetzelfde object
	-- zijn geregistreerd.
    FUNCTION nen2767_corr_cond_score (p_cond_score IN NUMBER)
        RETURN NUMBER
    AS
        v_result   NUMBER (4, 2);
    BEGIN
        CASE
            WHEN p_cond_score = 0.5
            THEN
                v_result := 0.8;
            WHEN p_cond_score = 1
            THEN
                v_result := 1;
            WHEN p_cond_score = 1.5
            THEN
                v_result := 1.01;
            WHEN p_cond_score = 2
            THEN
                v_result := 1.02;
            WHEN p_cond_score = 2.5
            THEN
                v_result := 1.07;
            WHEN p_cond_score = 3
            THEN
                v_result := 1.1;
            WHEN p_cond_score = 3.5
            THEN
                v_result := 1.2;
            WHEN p_cond_score = 4
            THEN
                v_result := 1.3;
            WHEN p_cond_score = 4.5
            THEN
                v_result := 1.5;
            WHEN p_cond_score = 5
            THEN
                v_result := 1.7;
            WHEN p_cond_score = 5.5
            THEN
                v_result := 1.85;
            WHEN p_cond_score = 6
            THEN
                v_result := 2;
        END CASE;
        RETURN v_result;
    END;
    -- Herleidt de samengestelde conditie volgens NEN2767 tabel B.2
    -- Er gaat een getal in en er komt een getal (conditiescore) tussen 1 en 6 uit
    -- Met l_halfscores op 1 (WOMD#60881) gebruiken we in afwijking van de NEN ook halfjes.
    FUNCTION nen2767_cond_herleiding (p_cond_tussen_score IN NUMBER)
        RETURN NUMBER
    AS
        v_result   NUMBER (4,1);
        l_halfscores BOOLEAN := fac.getsetting('cnd_use_halfscores') = 1;
    BEGIN
        CASE
            WHEN p_cond_tussen_score <= 1.01
            THEN
                v_result := 1;
            WHEN l_halfscores AND p_cond_tussen_score <= 1.02
            THEN
                v_result := 1.5;
            WHEN p_cond_tussen_score <= 1.04
            THEN
                v_result := 2;
            WHEN l_halfscores AND p_cond_tussen_score <= 1.09
            THEN
                v_result := 2.5;
            WHEN p_cond_tussen_score <= 1.15
            THEN
                v_result := 3;
            WHEN l_halfscores AND p_cond_tussen_score <= 1.20
            THEN
                v_result := 3.5;
            WHEN p_cond_tussen_score <= 1.4
            THEN
                v_result := 4;
            WHEN l_halfscores AND p_cond_tussen_score <= 1.58
            THEN
                v_result := 4.5;
            WHEN p_cond_tussen_score <= 1.78
            THEN
                v_result := 5;
            WHEN l_halfscores AND p_cond_tussen_score <= 1.88
            THEN
                v_result := 5.5;
            ELSE
                v_result := 6;
        END CASE;
        RETURN v_result;
    END;
    -- Bepaalt de conditiescore van een object p_deel_key met inachtneming van alle geregistreerd (actuele) gebreken
    -- Optionele mld_key biedt de mogelijkheid om de score te bepalen alsof dit het enige gebrek is,
    -- waarmee je de ongewogen bijdrage van dit gebrek/deze melding aan de conditiescore van het object kunt bepalen
    -- Qua statussen telt als gebrek mee:
    -- gcndusagemodel = 1: wel 0,4,5,7 niet 1,2,6
    -- gcndusagemodel = 2: wel 0,4,7 niet 1,2,5,6
    -- statussen 1 en 6 zijn al vroeg weggefilterd in cnd_v_nen2767_per_srtgebrek, 2 moet dus ook nooit
    -- en verder verschilt het dan netto alleen in status 5
    FUNCTION calculate_cond_score (p_deel_key IN NUMBER, p_mld_key IN NUMBER DEFAULT NULL)
        RETURN NUMBER
    AS
        lcondscore        NUMBER := NULL;
        lnrgebreken       NUMBER;
    BEGIN
        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'cnd.calculate_cond_score uses CND model: ' || gcndusagemodel ||
        ' Scoremethode: ' || gcndscoremethod);
        IF gcndscoremethod = 1                                                       -- Strictly NEN
        THEN
            -- Gebrekmeldingen bepalen de scores ongeacht status
            -- Deze beide varianten combineren in 1 query leidt onvoorspelbaar tot performance issues
            -- Gesplitst is het daarom beter
            IF p_mld_key IS NULL
            THEN
                SELECT COUNT (*)
                  INTO lnrgebreken
                  FROM cnd_v_nen2767_per_srtgebrek
                 WHERE     (gcndusagemodel = 1 OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                       AND mld_melding_status <> 2                        -- nieuw telt nog niet mee
                       AND ins_deel_key = p_deel_key;
            ELSE
                SELECT COUNT (*)
                  INTO lnrgebreken
                  FROM cnd_v_nen2767_per_srtgebrek
                 WHERE     (gcndusagemodel = 1 OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                       AND mld_melding_status <> 2                        -- nieuw telt nog niet mee
                       AND mld_melding_key = p_mld_key;
            END IF;

            IF lnrgebreken = 0
            THEN
                DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Geen gebreken');
                lcondscore := 1;
            ELSE
                DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||lnrgebreken || ' gebrek(en)');
                -- NEN2767 berekenmethode 1 en 2: de  gebreken op betreffende object hebben allemaal dezelfde ernst en intensiteit;
                -- Misschien kan die controle sneller, door te kijken of de count van de groepering (de distinct) gelijk is aan 1?
                BEGIN
                    -- Idem. Gesplitst is het sneller
                    IF p_mld_key IS NULL
                    THEN
                          SELECT cnd.nen2767_meth12_cond_score (ernst,
                                                                intensiteit,
                                                                LEAST (100, SUM (omvang)))
                            INTO lcondscore
                            FROM cnd_v_nen2767_per_srtgebrek
                           WHERE     (   gcndusagemodel = 1
                                      OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                                 AND mld_melding_status <> 2
                                 AND ins_deel_key = p_deel_key
                        GROUP BY ins_deel_key, ernst, intensiteit
                          HAVING COUNT (*) = lnrgebreken;
                    ELSE
                          -- hier nog eens naar optimalisatie kijken: een gebrek heeft voor alle
                          -- betrokken objecten dezelfde eigenschappen dus score, dus kan ik
                          -- met 1 berekening volstaan; weet niet of dat boeit.
                          SELECT cnd.nen2767_meth12_cond_score (ernst,
                                                                intensiteit,
                                                                LEAST (100, SUM (omvang)))
                            INTO lcondscore
                            FROM cnd_v_nen2767_per_srtgebrek
                           WHERE     (   gcndusagemodel = 1
                                      OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                                 AND mld_melding_status <> 2
                                 AND mld_melding_key = p_mld_key
                        GROUP BY ins_deel_key, ernst, intensiteit
                          HAVING COUNT (*) = lnrgebreken;
                    END IF;
                EXCEPTION
                    WHEN NO_DATA_FOUND
                    THEN
                        -- Ze hebben niet dezelfde ernst en intensiteit
                        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Methode 1-2 levert niks op');
                        NULL;
                END;
                IF lcondscore IS NULL AND p_mld_key IS NULL
                -- bedoeling: methode 1,2 leverde niks op; is dat daarvoor de juiste conditie?
                -- Dit kan niet voorkomen als p_melding_key gegeven is, dan is er altijd maar 1 (nl. dat) gebrek
                THEN
                    DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'We gaan methode 3 dus toepassen');
                    -- Berekenmethode3: de gebreken op betreffende object hebben niet allemaal dezelfde ernst en intensiteit;
                    -- Let op: deze methodiek écht pas activeren wanneer aan deze voorwaarden voldaan wordt (2 of meer gebreken en/of niet dezelfde ernst/intensiteit)
                    -- want deze methodiek loslaten op 1 gebrek geeft niet altijd de goede uitkomst.
                    DECLARE
                        l_cond_score_corr       NUMBER (10, 2);
                        l_som_omvang            NUMBER (10);
                        l_cond_score_corr_str   VARCHAR2 (255);
                        l_cond_omvang_str       VARCHAR2 (255);
                        l_prio_score            NUMBER (10);
                        CURSOR c_gebreken_delta_ernst_intens
                        IS
                              SELECT ernst, intensiteit, LEAST (100, SUM (omvang)) AS omvang
                                FROM cnd_v_nen2767_per_srtgebrek
                               WHERE     (   gcndusagemodel = 1
                                          OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                                     AND mld_melding_status <> 2          -- nieuw telt nog niet mee
                                     AND ins_deel_key = p_deel_key
                            GROUP BY ins_deel_key, ernst, intensiteit
                              HAVING COUNT (*) <> lnrgebreken;
                    BEGIN
                        l_som_omvang := 0;
                        l_cond_score_corr_str := '';
                        l_cond_omvang_str := '';
                        -- Het object heeft gebreken met verschillende (delta) ernst_intens, in de 1e lus hierboven is die niet langsgekomen.
                        FOR rec_delta IN c_gebreken_delta_ernst_intens
                        LOOP
                            -- Deze loop wordt minimaal 2 keer doorlopen...
                            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Ernst: '||rec_delta.ernst||' en Intensiteit: '||rec_delta.intensiteit);
                            lcondscore :=
                                cnd.nen2767_meth12_cond_score (rec_delta.ernst,
                                                               rec_delta.intensiteit,
                                                               100); -- Doorrekenen op 100%, zie par 4.3, pagina 12 van document 'Conditiemeting 1.0'
                            l_cond_score_corr := cnd.nen2767_corr_cond_score (lcondscore); -- Uitrekenen van daarvan de gecorrigeerde score is...
                            l_cond_score_corr_str :=
                                l_cond_score_corr_str || ';' || l_cond_score_corr; -- Een array voor de gecorrigeerde score
                            l_cond_omvang_str := l_cond_omvang_str || ';' || rec_delta.omvang; -- En eveneens een 'array' voor de echte omvang ipv 100 van hierboven, die hebben we straks weer nodig
                            l_som_omvang := l_som_omvang + rec_delta.omvang; -- En we gaan de omvang van alle gebreken bij elkaar optellen, om te kijken of de som < 100 is, want dan is er ook een gedeelte (100 - som) die geen gebreken heeft, dat doet namelijk ook mee in de berekening...
                        END LOOP;
                        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Totale omvang: '||l_som_omvang);
                        IF l_som_omvang < 100
                        THEN
                            -- Er is nog een rest-gedeelte (omvang) die geen gebreken heeft, die doet met score 1 mee in de berekening.
                            l_cond_score_corr_str := l_cond_score_corr_str || ';' || '1';
                            l_cond_omvang_str := l_cond_omvang_str || ';' || (100 - l_som_omvang);
                        END IF;
                        l_cond_score_corr_str := SUBSTR (l_cond_score_corr_str, 2); -- eerste ; eraf strippen
                        l_cond_omvang_str := SUBSTR (l_cond_omvang_str, 2); -- eerste ; eraf strippen
                        lcondscore :=
                            cnd.nen2767_meth3_cond_score (l_cond_score_corr_str, l_cond_omvang_str);
                    END;
                END IF;
            END IF;
        ELSIF gcndscoremethod = 2
        THEN
            -- lcndscoreregime 2/else
            -- Conditiebepaling op basis van de slechtste conditie.
            -- Dit is een versimpelde methode, pakt gewoon de max van de methode 1,2 scores
            -- De geldigheid van deze berekening is dubieus eigenlijk, en iig niet cf NEN. Waarom zouden we dit ondersteunen?
            BEGIN
                IF p_mld_key IS NULL
                THEN
                      SELECT MAX (cnd.nen2767_meth12_cond_score (ernst, intensiteit, omvang))
                        INTO lcondscore
                        FROM cnd_v_nen2767_per_srtgebrek
                       WHERE     (   gcndusagemodel = 1
                                  OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                             AND mld_melding_status <> 2                  -- nieuw telt nog niet mee
                             AND ins_deel_key = p_deel_key
                    GROUP BY ins_deel_key;
                ELSE
                      SELECT MAX (cnd.nen2767_meth12_cond_score (ernst, intensiteit, omvang))
                        INTO lcondscore
                        FROM cnd_v_nen2767_per_srtgebrek
                       WHERE     (   gcndusagemodel = 1
                                  OR (gcndusagemodel = 2 AND mld_melding_status <> 5))
                             AND mld_melding_status <> 2                  -- nieuw telt nog niet mee
                             AND mld_melding_key = p_mld_key
                    GROUP BY ins_deel_key;
                END IF;
            EXCEPTION
                WHEN NO_DATA_FOUND
                THEN
                    lcondscore := 1;
            END;
        ELSE
            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'UNSUPPORTED VALUE FOR cnd_scoremethod');
            lcondscore := NULL;
        END IF;
        RETURN lcondscore;
    END;
    -- Bepaal de prioriteit van een gebrek/de gebrekenm aan een object aan de hand van de aspecten
    -- volgens de prioriteitenmatrix van het bijbehorende srtgebouw.
    -- Als je een deel_key meegeeft is het de max-prioriteit van alle bijbehorende gebreken
    -- Als je (ook) een melding_key meegeeft is het de specifieke prioriteit van dat gebrek
    -- Let op: een melding kan iha meerdere objecten gekoppeld hebben
    -- Op dit moment wordt de plaats van de melding (niet van het objecten/de objecten) gebruikt om de aspectenmatrix te vinden
    -- sld je een melding_key meegeeft.
    -- Aanroep zonder melding_key bepaalt de MAX van alle meldingen bij een deel, die met melding_key de "MAX" van alleen die melding
    FUNCTION calculate_prio_score (p_deel_key IN NUMBER, p_mld_key IN NUMBER DEFAULT NULL)
        RETURN NUMBER
    AS
        v_result              NUMBER;
        v_srtgebouw_key       NUMBER;
        v_a1                  NUMBER;
        v_a2                  NUMBER;
        v_a3                  NUMBER;
        v_a4                  NUMBER;
        v_a5                  NUMBER;
        v_a6                  NUMBER;
        v_a7                  NUMBER;
        v_a1_max              NUMBER;
        v_a2_max              NUMBER;
        v_a3_max              NUMBER;
        v_a4_max              NUMBER;
        v_a5_max              NUMBER;
        v_a6_max              NUMBER;
        v_a7_max              NUMBER;
        v_gering_aspect_key   NUMBER (10) := get_usrdata_key ('USR_ASPECTENMATRIX', 'Gering');
        v_matig_aspect_key    NUMBER (10) := get_usrdata_key ('USR_ASPECTENMATRIX', 'Matig');
        v_sterk_aspect_key    NUMBER (10) := get_usrdata_key ('USR_ASPECTENMATRIX', 'Sterk');
        FUNCTION getmaxprio (p_max IN NUMBER, p_usrdata_key IN NUMBER, p_cur_prio IN NUMBER)
            RETURN NUMBER
        AS
            v_prio_result   NUMBER;
        BEGIN
            CASE p_usrdata_key
                WHEN v_gering_aspect_key
                THEN
                    v_prio_result := p_max + 2;
                WHEN v_matig_aspect_key
                THEN
                    v_prio_result := p_max + 1;
                WHEN v_sterk_aspect_key
                THEN
                    v_prio_result := p_max;
                ELSE
                    v_prio_result := 10;
            END CASE;
            IF v_prio_result < p_cur_prio
            THEN
                RETURN v_prio_result;
            ELSE
                RETURN p_cur_prio;
            END IF;
        END;
    BEGIN
        -- De aspectenmatrix vindt je bij het gebouwsoort
        IF p_mld_key IS NOT NULL
        THEN
            SELECT alg_srtgebouw_key
              INTO v_srtgebouw_key
              FROM mld_melding m, alg_v_allonroerendgoed aog, alg_gebouw g
             WHERE     aog.alg_gebouw_key = g.alg_gebouw_key
                   AND m.mld_alg_onroerendgoed_keys = aog.alg_onroerendgoed_keys
                   AND m.mld_melding_key = p_mld_key;
        ELSE
            SELECT alg_srtgebouw_key
              INTO v_srtgebouw_key
              FROM ins_v_deel_gegevens_keys dg, alg_gebouw g
             WHERE dg.alg_gebouw_key = g.alg_gebouw_key AND dg.ins_deel_key = p_deel_key;
        END IF;
        SELECT alg_srtgebouw_aspect_max_vg,
               alg_srtgebouw_aspect_max_ch,
               alg_srtgebouw_aspect_max_gb,
               alg_srtgebouw_aspect_max_tv,
               alg_srtgebouw_aspect_max_tk,
               alg_srtgebouw_aspect_max_be,
               alg_srtgebouw_aspect_max_en
          INTO v_a1_max,
               v_a2_max,
               v_a3_max,
               v_a4_max,
               v_a5_max,
               v_a6_max,
               v_a7_max
          FROM alg_srtgebouw
         WHERE alg_srtgebouw_key = v_srtgebouw_key;
        SELECT MAX(a1),
               MAX(a2),
               MAX(a3),
               MAX(a4),
               MAX(a5),
               MAX(a6),
               MAX(a7)
          INTO v_a1,
               v_a2,
               v_a3,
               v_a4,
               v_a5,
               v_a6,
               v_a7
          FROM (  SELECT MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT1'))
                             a1,
                         MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT2'))
                             a2,
                         MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT3'))
                             a3,
                         MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT4'))
                             a4,
                         MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT5'))
                             a5,
                         MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT6'))
                             a6,
                         MAX (
                             (SELECT km.mld_kenmerkmelding_waarde
                                FROM mld_kenmerkmelding km, mld_kenmerk k, mld_srtkenmerk sk
                               WHERE     km.mld_melding_key = g.mld_melding_key
                                     AND k.mld_kenmerk_key = km.mld_kenmerk_key
                                     AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                                     AND sk.mld_srtkenmerk_code = 'ASPECT7'))
                             a7
                    FROM cnd_v_nen2767_srtgebrek g
                   WHERE (gcndusagemodel= 1 OR (gcndusagemodel= 2 AND mld_melding_status <> 5))
                         AND mld_melding_status <> 2
                         AND (p_deel_key IS NULL OR g.ins_deel_key = p_deel_key)
                         AND (p_mld_key IS NULL OR mld_melding_key = p_mld_key)
                GROUP BY g.ins_deel_key);
        v_result := getmaxprio (v_a1_max, v_a1, 10);
        v_result := getmaxprio (v_a2_max, v_a2, v_result);
        v_result := getmaxprio (v_a3_max, v_a3, v_result);
        v_result := getmaxprio (v_a4_max, v_a4, v_result);
        v_result := getmaxprio (v_a5_max, v_a5, v_result);
        v_result := getmaxprio (v_a6_max, v_a6, v_result);
        v_result := getmaxprio (v_a7_max, v_a7, v_result);
        IF v_result = 10
        THEN
            RETURN NULL;  -- geen gebreken = geen prio
        ELSE
            RETURN v_result;
        END IF;
    EXCEPTION
        WHEN NO_DATA_FOUND
        THEN
            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Geen gebreken = geen prio');
            RETURN NULL;
    END;
    PROCEDURE update_mjb_scores (p_deel_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL)
    AS
    BEGIN
        DECLARE
            lnewscore1         NUMBER := 1;                                              -- Conditie
            lnewscore2         NUMBER;                                                       -- Prio
            loldscore1         NUMBER;
            loldscore2         NUMBER;
        BEGIN
            -- Hier worden de ins_deel_mjb_score1/2 bijgewerkt.
            -- Dat wordt doorgaans getriggerd door een event waardoor deze score gewijzigd kan zijn
            -- Maar om deze score te bepalen heb je wel de eventuele andere lopende meldingen
            -- nodig en kun je je dus niet alleen baseren op dat waardoor je getriggerd werd
            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'updating MJB-object: ' || p_deel_key);
            SELECT ins_deel_mjb_score1, ins_deel_mjb_score2
              INTO loldscore1, loldscore2
              FROM ins_deel
             WHERE ins_deel_key = p_deel_key;
            lnewscore1 := calculate_cond_score (p_deel_key);
            lnewscore2 := calculate_prio_score (p_deel_key);
            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'newcondscore: ' || lnewscore1);
            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'newprioscore: ' || lnewscore2);
            UPDATE ins_deel
               SET ins_deel_mjb_score1 = lnewscore1, ins_deel_mjb_score2 = lnewscore2
             WHERE ins_deel_key = p_deel_key;
            -- we only track real changes, one should trust that we are accurate
            IF (loldscore1 IS NULL and lnewscore1 IS NOT NULL) OR (lnewscore1 <> loldscore1)
            THEN
                fac.trackaction ('#INSCN1',
                                 p_deel_key,
                                 p_user_key,
                                 NULL,
                                 lcl.l('lcl_ins_deel_mjb_score1')||': ' || TO_CHAR(loldscore1) ||lcl.l('lcl_trackto') || TO_CHAR(lnewscore1));
            ELSE
                DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Conditiescore ongewijzigd');
            END IF;
            IF (loldscore2 IS NULL and lnewscore2 IS NOT NULL) OR (loldscore2 IS NOT NULL and lnewscore2 IS NULL) OR (lnewscore2 <> loldscore2)
            THEN
                IF lnewscore2 IS NULL
                THEN
                    fac.trackaction ('#INSUPD',
                                     p_deel_key,
                                     p_user_key,
                                     NULL,
                                     lcl.l('cnd_prioriteitscore_gewist'));  -- geen score = ongedefinieerde (geen) prio
                ELSE
                    fac.trackaction ('#INSUPD',
                                     p_deel_key,
                                     p_user_key,
                                     NULL,
                                     lcl.l('lcl_ins_deel_mjb_score2')||': '||TO_CHAR(loldscore2) ||lcl.l('lcl_trackto')|| TO_CHAR(lnewscore2));
                END IF;
            ELSE
                DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Prioriteitscore ongewijzigd');
            END IF;
        END;
    END;
    -- Update de scores for (all) the object(s) that are related to this gebrek
    -- It is essentially a way to define the set of objects that are affected by this call
    -- to limit the calculations
    PROCEDURE process_mjb_score_effects (p_melding_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL)
    AS
    BEGIN
        DECLARE
            lsrtdisckey          ins_tab_discipline.ins_srtdiscipline_key%TYPE;
            lstdmeldingcode      mld_stdmelding.mld_stdmelding_code%TYPE;
            l_kenmerk_key_cond   mld_kenmerk.mld_kenmerk_key%TYPE;
            l_kenmerk_key_prio   mld_kenmerk.mld_kenmerk_key%TYPE;
            lthisscore           NUMBER;
        BEGIN
            BEGIN
                -- is het een gebrekmelding?
                SELECT id.ins_srtdiscipline_key, stdm.mld_stdmelding_code
                  INTO lsrtdisckey, lstdmeldingcode
                  FROM mld_stdmelding stdm, ins_tab_discipline id, mld_melding m
                 WHERE     stdm.mld_ins_discipline_key = id.ins_discipline_key
                       AND stdm.mld_stdmelding_key = m.mld_stdmelding_key
                       AND mld_melding_key = p_melding_key;
            EXCEPTION
                WHEN NO_DATA_FOUND
                THEN
                    DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Ongeldige aanroep voor melding ' || p_melding_key);
                    RETURN;
            END;
            IF lsrtdisckey = gsrtdisckey
            THEN
                DECLARE
                    ldeelcnt   NUMBER := 0;
                    CURSOR c_objecten
                    IS
                        SELECT ins_deel_key
                          FROM mld_melding_object
                         WHERE     mld_melding_object_verwijder IS NULL
                               AND mld_melding_key = p_melding_key;
                BEGIN
                    -- UPDATE de scores van alle betrokken objecten conform model en regels
                    -- Besef: gebruikelijk is dat er maar 1 object aan een gebrek is gekoppeld
                    -- dus deze loop doorloop je doorgaans maar 1 keer
                    FOR c_o IN c_objecten
                    LOOP
                        DBMS_OUTPUT.put_line (
                            to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||
                            'About to update scores of object #'|| ldeelcnt ||': ' || c_o.ins_deel_key);
                        IF lstdmeldingcode = 'GEEN'
                        THEN
                            -- Dit is een 'Geen Gebrek'-melding
                            -- Dat betekent dat we alle eventuele voorgaande actieve gebreken Verwerken
                            -- En pas daarna gaan berekenen. Die berekening zal dan 1 opleveren.
                            -- Deze Geen Gebrek melding wordt zelf ook direct verwerkt, lijkt me prima eigenlijk.
                            DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Dit is een Geen Gebrek-gebrek -> reset alle gebreken');
                            resetgebreken (c_o.ins_deel_key, p_user_key);
                            -- dat was al inclusief de herberekening
                        ELSE
                            update_mjb_scores (c_o.ins_deel_key, p_user_key);
                        END IF;
                        ldeelcnt := ldeelcnt + 1;
                    END LOOP;
                    -- Bij het gebrek registreren we welke specifieke ongewogen impact dit gebrek op
                    -- de score van de bijbehorende objecten heeft,
                    -- zodat je de ergste gebreken kunt kiezen om eerst te herstellen.
                    SELECT MAX (k.mld_kenmerk_key)
                      INTO l_kenmerk_key_cond
                      FROM mld_kenmerk k, mld_srtkenmerk sk
                     WHERE     k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                           AND sk.mld_srtkenmerk_verwijder IS NULL
                           AND k.mld_kenmerk_verwijder IS NULL
                           AND UPPER (sk.mld_srtkenmerk_code) = 'CONDITIESCORE';
                    IF l_kenmerk_key_cond IS NOT NULL
                    THEN
                        lthisscore := calculate_cond_score (NULL, p_melding_key);
                        DBMS_OUTPUT.put_line (
                             to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||
                            'Conditiescore door dit gebrek ' || p_melding_key||': '||lthisscore);
                        mld.upsertmeldingkenmerk (l_kenmerk_key_cond,
                                                  p_melding_key,
                                                  lthisscore);
                    ELSE
                        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Geen meldingflexkenmerksoort CONDITIESCORE');
                    END IF;
                    SELECT MAX (k.mld_kenmerk_key)
                      INTO l_kenmerk_key_prio
                      FROM mld_kenmerk k, mld_srtkenmerk sk
                     WHERE     k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                           AND sk.mld_srtkenmerk_verwijder IS NULL
                           AND k.mld_kenmerk_verwijder IS NULL
                           AND UPPER (sk.mld_srtkenmerk_code) = 'PRIORITEITSCORE';
                    IF l_kenmerk_key_prio IS NOT NULL
                    THEN
                        lthisscore := calculate_prio_score (NULL, p_melding_key);
                        DBMS_OUTPUT.put_line (
                             to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||
                            'Prioscore door dit gebrek ' || p_melding_key||': '||lthisscore);
                        mld.upsertmeldingkenmerk (l_kenmerk_key_prio,
                                                  p_melding_key,
                                                  lthisscore);
                    ELSE
                        DBMS_OUTPUT.put_line (to_char(systimestamp, 'hh24:mi:ss.ff3')||' - '||'Geen meldingflexkenmerksoort PRIORITEITSCORE');
                    END IF;
                    -- Verbeterpuntje: dit alleen indien daadwerkelijk gewijzigd doen?
                    IF ldeelcnt > 0
                    THEN
                        IF ldeelcnt = 1
                        THEN
                            fac.trackaction (
                                '#MLDUPD',
                                p_melding_key,
                                p_user_key,
                                NULL,
                                lcl.l('cnd_conditiescore_verwerkt'));
                        ELSE
                            fac.trackaction (
                                '#MLDUPD',
                                p_melding_key,
                                p_user_key,
                                NULL,
                                lcl.l('cnd_conditiescore_verwerkt_m'));
                        END IF;
                    END IF;
                END;
            END IF;
        END;
    END;
    -- Zet eventuele open gebrekenmelding op Verwerkt, waardoor deze niet meer in de conditiescores zullen meedoen
    -- Veronderstelt dat deze gebreken over precies 1 object gaan, namelijk deze. Als dat niet zo zou zijn,
    -- dan worden deze gebreken verwerkt zonder dat de score van die andere objecten herberekend zouden worden.
    -- Binnen CND is het echter niet mogelijk/ongeldig om meer objecten aan zo'n melding te hangen.
    PROCEDURE resetgebreken (p_deel_key IN NUMBER, p_user_key IN NUMBER DEFAULT NULL)
    AS
        CURSOR c_opengebreken
        IS
            SELECT mld_melding_key
              FROM cnd_v_nen2767_gebrek
             WHERE ins_deel_key = p_deel_key;
    BEGIN
        FOR gebrek IN c_opengebreken
        LOOP
            DBMS_OUTPUT.put_line ('Verwerk melding ' || gebrek.mld_melding_key);
            fac.trackaction ('#MLDUPD', gebrek.mld_melding_key, p_user_key, NULL, lcl.l('cnd_mjbtaak_verwerkt'));
            -- een melding kan niet zomaar naar 6, 5 komt eerst, doet niks als het al 5 was (todo?)
            mld.setmeldingstatus (gebrek.mld_melding_key, 5, p_user_key, 1);  --notificeer eventueel
            mld.setmeldingstatus (gebrek.mld_melding_key, 6, p_user_key, 0);
        END LOOP;
        update_mjb_scores (p_deel_key);
    END;
    -- Gegeven een taak, die gaat over (een) object(en). Als het een MJB-taak of een vervanging is
    -- en er andere geen lopende taken (meer) op dat object zijn:
    -- Zet dan alle gebreken (melding van CND) op status Verwerkt zodat die gebreken niet meer meedoen
    -- Ze worden opgelost verondersteld na het uitvoeren van de laatste MJB/vervangings-taak.
    -- De nieuw te berekenen score zal dan 1 moeten worden.
    -- Als er nog taken resteren, dan gebeurt er niets met de gebreken.
    PROCEDURE process_mjb_gebreken (p_deelsrtcontrole_key   IN NUMBER,
                                    p_user_key              IN NUMBER DEFAULT NULL)
    AS
        CURSOR c_betrokkendelen
        IS
            SELECT ins_deel_key
              FROM ins_deelsrtcontrole
             WHERE ins_deelsrtcontrole_key = p_deelsrtcontrole_key;
        l_controletype      ctr_disc_params.ctr_disc_params_controle_type%TYPE;
        l_actievemjbtaken   NUMBER;
    BEGIN
        -- Gegeven is een taak; is dit een succesvol uitgevoerde vervangingstaak?
        BEGIN
            SELECT ctr_disc_params_controle_type
              INTO l_controletype
              FROM ins_deelsrtcontrole  dsc,
                   ins_srtcontrole      sc,
                   ctr_disc_params      cd,
                   ins_controlemode     im
             WHERE     dsc.ins_srtcontrole_key = sc.ins_srtcontrole_key
                   AND sc.ctr_discipline_key = cd.ctr_ins_discipline_key
                   AND dsc.ins_controlemode_key = im.ins_controlemode_key
                   AND im.ins_controlemode_success = 1
                   AND dsc.ins_deelsrtcontrole_key = p_deelsrtcontrole_key;
        EXCEPTION
            WHEN NO_DATA_FOUND
            THEN
                DBMS_OUTPUT.put_line (
                    TO_CHAR (SYSTIMESTAMP, 'hh24:mi:ss.ff3') || ' - ' || 'Deze taak is niet succesvol');
                RETURN;
        END;

        -- Zo nee, dan hoeven we hier niks
        IF l_controletype <> 2
        THEN
            DBMS_OUTPUT.put_line (
                   TO_CHAR (SYSTIMESTAMP, 'hh24:mi:ss.ff3')
                || ' - '
                || 'Deze taak is geen vervanging '
                || p_deelsrtcontrole_key);
            RETURN;
        END IF;

        DBMS_OUTPUT.put_line ('Deze taak is een succesvol afgemelde vervanging');

        -- ik denk dat dit altijd maar 1 record is, maar wellicht wordt dat ooit anders
        FOR deel IN c_betrokkendelen
        LOOP
            -- Tel hoeveel actieve vervangings-taken er voor dit object actief zijn
            SELECT COUNT (*)
              INTO l_actievemjbtaken
              FROM ins_deelsrtcontrole dsc, ins_srtcontrole sc, ctr_disc_params cd
             WHERE     dsc.ins_srtcontrole_key = sc.ins_srtcontrole_key
                   AND sc.ctr_discipline_key = cd.ctr_ins_discipline_key
                   AND ins_deelsrtcontrole_status <> 6
                   AND dsc.ins_scenario_key = 1
                   AND (cd.ctr_disc_params_ismjob = 1
                       OR cd.ctr_disc_params_controle_type = 2)
                   AND dsc.ins_deel_key = deel.ins_deel_key;
            DBMS_OUTPUT.put_line ('Aantal actieve Vervangingstaken: ' || l_actievemjbtaken);
            IF l_actievemjbtaken = 0
            THEN
                -- geen lopende vervangings-taken (meer): alle eventuele gebreken sluiten
                DBMS_OUTPUT.put_line ('Reset meldingen van object ' || deel.ins_deel_key);
                resetgebreken (deel.ins_deel_key, p_user_key);
            END IF;
        END LOOP;
    END;
    -- Aggregatiefunctie om de totaalscore per locatie en/of gebouw (of alles) te herberekenen
    -- parameters zijn optioneel om het domein te beperken
    PROCEDURE update_aggr_scores (p_locatie_key   IN NUMBER DEFAULT NULL,
                                  p_gebouw_key    IN NUMBER DEFAULT NULL)
    AS
        -- Gebruik hiervoor als basis: zie pagina 14 uit Word document....
        CURSOR c_locatie
        IS
              SELECT alg_locatie_key,
                     SUM (totale_vervangingswaarde)
                         totale_vervangingswaarde,
                     SUM (correctie_vervangingswaarde)
                         correctie_vervangingswaarde,
                     ROUND (
                           SUM (correctie_vervangingswaarde)
                         / SUM (COALESCE (totale_vervangingswaarde, 1)),
                         4)
                         factor
                FROM cnd_v_aggr_cond_score
               WHERE     totale_vervangingswaarde <> 0
                     AND ((p_locatie_key IS NOT NULL AND alg_locatie_key = p_locatie_key)
                     OR (p_locatie_key IS NULL AND p_gebouw_key IS NULL))
            GROUP BY alg_locatie_key;
        CURSOR c_gebouw
        IS
              SELECT alg_gebouw_key,
                     SUM (totale_vervangingswaarde)
                         totale_vervangingswaarde,
                     SUM (correctie_vervangingswaarde)
                         correctie_vervangingswaarde,
                     ROUND (
                           SUM (correctie_vervangingswaarde)
                         / SUM (COALESCE (totale_vervangingswaarde, 1)),
                         4)
                         factor
                FROM cnd_v_aggr_cond_score
               WHERE     totale_vervangingswaarde <> 0
                     AND (p_locatie_key IS NULL OR alg_locatie_key = p_locatie_key)
                     AND (p_gebouw_key IS NULL OR alg_gebouw_key = p_gebouw_key)
            GROUP BY alg_gebouw_key;
        l_cond_score_old   NUMBER (4,1);
        l_cond_score_new   NUMBER (4,1);
    BEGIN
        FOR locatie IN c_locatie
        LOOP
            SELECT alg_locatie_mjb_score1
              INTO l_cond_score_old
              FROM alg_locatie
             WHERE alg_locatie_key = locatie.alg_locatie_key;
            l_cond_score_new := cnd.nen2767_cond_herleiding (locatie.factor);
            DBMS_OUTPUT.put_line (
                   'Score voor locatie '
                || locatie.alg_locatie_key
                || ' was '
                || l_cond_score_old
                || ' en is '
                || l_cond_score_new);
            IF l_cond_score_old IS NULL OR l_cond_score_old <> l_cond_score_new
            THEN
                UPDATE alg_locatie
                   SET alg_locatie_mjb_score1 = l_cond_score_new
                 WHERE alg_locatie_key = locatie.alg_locatie_key;
                DBMS_OUTPUT.put_line ('-updated');
                fac.trackaction (
                    '#ALGLUP',
                    locatie.alg_locatie_key,
                    NULL,
                    NULL,
                       lcl.l ('lcl_ins_deel_mjb_score1')
                    || ': '
                    || TO_CHAR (l_cond_score_old)
                    || lcl.l ('lcl_trackto')
                    || TO_CHAR (l_cond_score_new));
            END IF;
        END LOOP;
        FOR gebouw IN c_gebouw
        LOOP
            SELECT alg_gebouw_mjb_score1
              INTO l_cond_score_old
              FROM alg_gebouw
             WHERE alg_gebouw_key = gebouw.alg_gebouw_key;
            l_cond_score_new := cnd.nen2767_cond_herleiding (gebouw.factor);
            DBMS_OUTPUT.put_line (
                   'Score voor gebouw '
                || gebouw.alg_gebouw_key
                || ' was '
                || l_cond_score_old
                || ' en is '
                || l_cond_score_new);
            IF l_cond_score_old IS NULL OR l_cond_score_old <> l_cond_score_new
            THEN
                UPDATE alg_gebouw
                   SET alg_gebouw_mjb_score1 = l_cond_score_new
                 WHERE alg_gebouw_key = gebouw.alg_gebouw_key;
                DBMS_OUTPUT.put_line ('-updated');
                fac.trackaction (
                    '#ALGGUP',
                    gebouw.alg_gebouw_key,
                    NULL,
                    NULL,
                       lcl.l ('lcl_ins_deel_mjb_score1')
                    || ': '
                    || TO_CHAR (l_cond_score_old)
                    || lcl.l ('lcl_trackto')
                    || TO_CHAR (l_cond_score_new));
            END IF;
        END LOOP;
    END;
END;
/


-----------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
-- IMPORTFUNCTIONS
-----------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
-- PLAT#53170: Koppelen van soort gebrek (mld_stdmelding) aan elementen obv importsheet: IMPORTFUNCTIE srtdeel_mlddisc
-- om het aantal combinaties te beperken tot alleen relevante combi's van gebrek en objectsoort, groep of discipline
-----------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE cnd_import_srtdeel_mlddisc (
    p_import_key   IN NUMBER)
AS
    c_fielddelimitor                VARCHAR2 (2) := fac.import_delimiter(p_import_key);
    v_newline                       VARCHAR2 (1000);             -- Input line
    v_aanduiding                    VARCHAR2 (200);
    v_errorhint                     VARCHAR2 (1000);
    v_errormsg                      VARCHAR2 (1000);
    oracle_err_num                  NUMBER;
    oracle_err_mes                  VARCHAR2 (200);
    header_is_valid                 NUMBER := 0;
    v_ongeldig                      NUMBER (1);
    v_count_tot                     NUMBER (10);
    v_count_import                  NUMBER (10);
    v_count                         NUMBER;

    -- De importvelden:
    v_ins_srtdeel_code              VARCHAR2 (1000);
    v_ins_srtgroep_omschrijving     VARCHAR2 (1000);
    v_ins_discipline_omschrijving   VARCHAR2 (1000);
    v_mld_discipline_omschrijving   VARCHAR2 (1000);

    v_lcl_ins_srtdeel_code          VARCHAR2 (100);
    v_lcl_ins_discipline_omschr     VARCHAR2 (100);
    v_lcl_ins_srtgroep_omschr       VARCHAR2 (100);
    v_lcl_mld_discipline_omschr     VARCHAR2 (100);

    CURSOR c1
    IS
          SELECT *
            FROM fac_imp_file
           WHERE fac_import_key = p_import_key
        ORDER BY fac_imp_file_index;
BEGIN
    v_errorhint := 'cnd_import_srtdeel_mlddisc';

    v_count_tot := 0;
    v_count_import := 0;

    FOR rec1 IN c1
    LOOP
        BEGIN
            v_newline := rec1.fac_imp_file_line;
            v_aanduiding := '';
            v_errorhint := 'Fout bij opvragen te importeren rij';
            v_ongeldig := 0;
            -- Lees alle veldwaarden

            -- 01 - v_ins_srtdeel_code
            v_aanduiding := 'Probleem bij v_ins_srtdeel_code: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 1,
                                 v_ins_srtdeel_code);
            v_ins_srtdeel_code := TRIM (v_ins_srtdeel_code);

            -- 03 - v_ins_discipline_omschrijving
            v_aanduiding := 'Probleem bij v_ins_discipline_omschrijving: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 3,
                                 v_ins_discipline_omschrijving);
            v_ins_discipline_omschrijving :=
                TRIM (v_ins_discipline_omschrijving);

            -- 04 - v_ins_srtgroep_omschrijving
            v_aanduiding := 'Probleem bij v_ins_srtgroep_omschrijving: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 4,
                                 v_ins_srtgroep_omschrijving);
            v_ins_srtgroep_omschrijving := TRIM (v_ins_srtgroep_omschrijving);

            -- 07 - v_mld_discipline_omschrijving
            v_aanduiding := 'Probleem bij v_mld_discipline_omschrijving: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 7,
                                 v_mld_discipline_omschrijving);
            v_mld_discipline_omschrijving :=
                TRIM (v_mld_discipline_omschrijving);

            --
            v_aanduiding :=
                   '['
                || rec1.fac_imp_file_index
                || ':'
                || v_ins_srtdeel_code
                || '-'
                || v_ins_discipline_omschrijving
                || '-'
                || v_ins_srtgroep_omschrijving
                || '-'
                || v_mld_discipline_omschrijving
                || '] ';

            -- Ik controleer of ik een geldige header heb, dat is: in de juiste kolommen
            -- de juiste kolomkop. Ik controleer daarbij de volgende kolommen:
            -- 1. Subrecept nummer
            -- 3. Hoofdrecept
            -- 4. Groep
            -- 7. Vakgroep
            -- Ik negeer alles totdat ik een geldige header ben gepasseerd.
            IF (header_is_valid = 0)
            THEN
                IF UPPER (v_ins_srtdeel_code) = 'SUBRECEPT NUMMER'
                THEN
                   v_lcl_ins_srtdeel_code          := 'SUBRECEPT NUMMER';
                   v_lcl_ins_discipline_omschr     := 'HOOFDRECEPT';
                   v_lcl_ins_srtgroep_omschr       := 'GROEP';
                   v_lcl_mld_discipline_omschr     := 'VAKGROEP';
                ELSE
                   v_lcl_ins_srtdeel_code          := 'OBJECTSOORTCODE';
                   v_lcl_ins_discipline_omschr     := 'DISCIPLINEOMSCHRIJVING';
                   v_lcl_ins_srtgroep_omschr       := 'GROEPSOORTOMSCHRIJVING';
                   v_lcl_mld_discipline_omschr     := 'VAKGROEP';
                END IF;

                IF     UPPER (v_ins_srtdeel_code) = v_lcl_ins_srtdeel_code
                   AND UPPER (v_ins_discipline_omschrijving) = v_lcl_ins_discipline_omschr
                   AND UPPER (v_ins_srtgroep_omschrijving) = v_lcl_ins_srtgroep_omschr
                   AND UPPER (v_mld_discipline_omschrijving) = v_lcl_mld_discipline_omschr
                THEN
                    header_is_valid := 1;
                END IF;
            ELSE
                v_count_tot := v_count_tot + 1;

                v_errorhint := 'Ongeldig ' || v_lcl_ins_srtdeel_code;

                IF (v_ins_srtdeel_code IS NOT NULL)
                THEN
                    IF LENGTH (v_ins_srtdeel_code) > 10
                    THEN
                        v_ins_srtdeel_code :=
                            SUBSTR (v_ins_srtdeel_code, 1, 10);
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding || v_lcl_ins_srtdeel_code || ' te lang',
                            'Afgebroken tot [' || v_ins_srtdeel_code || ']');
                    END IF;
                END IF;

                --
                v_errorhint := 'Ongeldig ' || v_lcl_ins_discipline_omschr;

                IF (v_ins_discipline_omschrijving IS NOT NULL)
                THEN
                    IF LENGTH (v_ins_discipline_omschrijving) > 60
                    THEN
                        v_ins_discipline_omschrijving :=
                            SUBSTR (v_ins_discipline_omschrijving, 1, 60);
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding || v_lcl_ins_discipline_omschr || ' te lang',
                               'Afgebroken tot ['
                            || v_ins_discipline_omschrijving
                            || ']');
                    END IF;
                END IF;

                --
                v_errorhint := 'Ongeldige ' || v_lcl_ins_srtgroep_omschr;

                IF (v_ins_srtgroep_omschrijving IS NOT NULL)
                THEN
                    IF LENGTH (v_ins_srtgroep_omschrijving) > 60
                    THEN
                        v_ins_srtgroep_omschrijving :=
                            SUBSTR (v_ins_srtgroep_omschrijving, 1, 60);
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding || v_lcl_ins_srtgroep_omschr || ' te lang',
                               'Afgebroken tot ['
                            || v_ins_srtgroep_omschrijving
                            || ']');
                    END IF;
                END IF;

                --
                v_errorhint := 'Ongeldige ' || v_lcl_mld_discipline_omschr;

                IF (v_mld_discipline_omschrijving IS NOT NULL)
                THEN
                    IF LENGTH (v_mld_discipline_omschrijving) > 60
                    THEN
                        v_mld_discipline_omschrijving :=
                            SUBSTR (v_mld_discipline_omschrijving, 1, 60);
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding || v_lcl_mld_discipline_omschr || ' te lang',
                               'Afgebroken tot ['
                            || v_mld_discipline_omschrijving
                            || ']');
                    END IF;
                ELSE
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                IF (v_ongeldig = 0)
                THEN
                    BEGIN
                        v_errorhint :=
                            'Fout bij toevoegen regel aan importtabel cnd_imp_srtdeel_mlddiscipline';

                        INSERT INTO cnd_imp_srtdeel_mlddiscipline (
                                        fac_import_key,
                                        ins_srtdeel_code,
                                        ins_discipline_omschrijving,
                                        ins_srtgroep_omschrijving,
                                        mld_discipline_omschrijving)
                             VALUES (p_import_key,
                                     v_ins_srtdeel_code,
                                     v_ins_discipline_omschrijving,
                                     v_ins_srtgroep_omschrijving,
                                     v_mld_discipline_omschrijving);

                        v_count_import := v_count_import + 1;
                        COMMIT;
                    EXCEPTION
                        WHEN OTHERS
                        THEN
                            oracle_err_num := SQLCODE;
                            oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
                            v_errormsg :=
                                   v_errorhint
                                || ' ORACLE (error '
                                || oracle_err_num
                                || '/'
                                || oracle_err_mes
                                || ')';
                            fac.imp_writelog (
                                p_import_key,
                                'E',
                                v_aanduiding || v_errormsg,
                                'Ingelezen regel kan niet worden weggeschreven!');
                            COMMIT;
                    END;
                END IF;
            END IF;
        END;
    END LOOP;

    IF (header_is_valid = 0)
    THEN
        fac.imp_writelog (
            p_import_key,
            'E',
            'Ongeldig importbestand',
            'Geen header of header niet volgens specificatie! Header kolommen: 1. Subrecept nummer, 3. Hoofdrecept, 4. Groep en 7. Vakgroep');
    ELSE
        fac.imp_writelog (
            p_import_key,
            'S',
               'IMPORT SRTDEEL_MLDDISC: aantal ingelezen regels: '
            || TO_CHAR (v_count_tot)
            || ' / aantal geldige regels: '
            || TO_CHAR (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_errormsg,
                          v_errorhint);
END cnd_import_srtdeel_mlddisc;
/

CREATE OR REPLACE PROCEDURE cnd_update_srtdeel_mlddisc (
    p_import_key   IN NUMBER)
IS
    -- Alle ingelezen records
    CURSOR c1
    IS
        SELECT *
          FROM cnd_imp_srtdeel_mlddiscipline
         WHERE fac_import_key = p_import_key;

    v_aanduiding           VARCHAR2 (200);
    v_errorhint            VARCHAR2 (1000);
    v_errormsg             VARCHAR2 (1000);
    oracle_err_num         NUMBER;
    oracle_err_mes         VARCHAR2 (200);
    v_count_tot            NUMBER (10);
    v_count_import         NUMBER (10);
    v_niveau               VARCHAR2 (1);

    v_ins_srtinstallatie_key NUMBER (10);
    v_mld_discipline_key   NUMBER (10);
BEGIN
    v_count_tot := 0;
    v_count_import := 0;

    FOR rec IN c1
    LOOP
        BEGIN
            v_ins_srtinstallatie_key := NULL;

            v_aanduiding :=
                   '['
                || rec.ins_srtdeel_code
                || '-'
                || rec.ins_srtgroep_omschrijving
                || '-'
                || rec.ins_srtgroep_omschrijving
                || '-'
                || rec.ins_srtgroep_omschrijving
                || '] ';

            IF rec.ins_srtdeel_code IS NOT NULL
            THEN
               v_errorhint := 'MAX(sd.ins_srtdeel_key) levert NULL op';
               v_niveau := 'S';
               SELECT MAX (sd.ins_srtdeel_key)
                 INTO v_ins_srtinstallatie_key
                 FROM ins_srtdeel sd, ins_srtgroep g, ins_discipline d
                WHERE     sd.ins_srtgroep_key = g.ins_srtgroep_key
                      AND g.ins_discipline_key = d.ins_discipline_key
                      AND sd.ins_srtdeel_code_upper =
                          UPPER (rec.ins_srtdeel_code)
                      AND g.ins_srtgroep_upper =
                          UPPER (rec.ins_srtgroep_omschrijving)
                      AND UPPER(d.ins_discipline_omschrijving) =
                          UPPER(rec.ins_discipline_omschrijving)
                      AND d.ins_discipline_verwijder IS NULL
                      AND g.ins_srtgroep_verwijder IS NULL
                      AND sd.ins_srtdeel_verwijder IS NULL;

            ELSIF rec.ins_srtgroep_omschrijving IS NOT NULL
            THEN
               v_niveau := 'G';
               v_errorhint := 'MAX(g.ins_srtgroep_key) levert NULL op';
               SELECT MAX (g.ins_srtgroep_key)
                 INTO v_ins_srtinstallatie_key
                 FROM ins_srtgroep g, ins_discipline d
                WHERE     g.ins_discipline_key = d.ins_discipline_key
                      AND g.ins_srtgroep_upper =
                          UPPER (rec.ins_srtgroep_omschrijving)
                      AND UPPER (d.ins_discipline_omschrijving) =
                          UPPER (rec.ins_discipline_omschrijving)
                      AND d.ins_discipline_verwijder IS NULL
                      AND g.ins_srtgroep_verwijder IS NULL;
            ELSE
               v_niveau := 'D';
               v_errorhint := 'MAX(d.ins_discipline_key) levert NULL op';
               SELECT MAX (d.ins_discipline_key)
                 INTO v_ins_srtinstallatie_key
                 FROM ins_discipline d
                WHERE     UPPER (d.ins_discipline_omschrijving) =
                          UPPER (rec.ins_discipline_omschrijving)
                      AND d.ins_discipline_verwijder IS NULL;
            END IF;

            v_errorhint := 'MAX(d.ins_discipline_key) levert NULL op';

            SELECT MAX (d.ins_discipline_key)
              INTO v_mld_discipline_key
              FROM mld_discipline d
             WHERE     d.ins_discipline_omschrijving =
                       rec.mld_discipline_omschrijving
                   AND d.ins_discipline_verwijder IS NULL;

            IF v_ins_srtinstallatie_key IS NULL
            THEN
                fac.imp_writelog (
                    p_import_key,
                    'E',
                    v_aanduiding || ' - Identificatie niet gevonden',
                    v_errorhint);
            END IF;

            IF v_mld_discipline_key IS NULL
            THEN
                fac.imp_writelog (
                    p_import_key,
                    'E',
                    v_aanduiding || ' - Vakgroep niet gevonden',
                    v_errorhint);
            END IF;

            IF     v_ins_srtinstallatie_key IS NOT NULL
               AND v_mld_discipline_key IS NOT NULL
            THEN
                v_errorhint := 'INSERT INTO mld_stdmelding_srtinst faalt...';

                INSERT INTO mld_stdmelding_srtinst (
                                mld_stdmelding_key,
                                ins_srtinstallatie_key,
                                ins_srtinstallatie_niveau)
                    SELECT sm.mld_stdmelding_key, v_ins_srtinstallatie_key, v_niveau
                      FROM mld_stdmelding sm
                     WHERE     sm.mld_ins_discipline_key =
                               v_mld_discipline_key
                           AND sm.mld_stdmelding_verwijder IS NULL
                           AND NOT EXISTS
                                   (SELECT 'x'
                                      FROM mld_stdmelding_srtinst smsi
                                     WHERE     smsi.mld_stdmelding_key =
                                               sm.mld_stdmelding_key
                                           AND smsi.ins_srtinstallatie_key =
                                               v_ins_srtinstallatie_key
                                           AND smsi.ins_srtinstallatie_niveau =
                                               v_niveau);
            END IF;
        EXCEPTION
            WHEN OTHERS
            THEN
                oracle_err_num := SQLCODE;
                oracle_err_mes := SUBSTR (SQLERRM, 1, 200);
                v_errormsg :=
                       'OTHERS (error '
                    || oracle_err_num
                    || '/'
                    || oracle_err_mes
                    || ')';
                fac.imp_writelog (p_import_key,
                                  'E',
                                  v_aanduiding || v_errormsg,
                                  v_errorhint);
                COMMIT;
        END;
    END LOOP;
EXCEPTION
    WHEN OTHERS
    THEN
        oracle_err_num := SQLCODE;
        oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
        v_errormsg :=
               'OTHERS (error '
            || oracle_err_num
            || '/'
            || oracle_err_mes
            || ')';
        fac.imp_writelog (p_import_key,
                          'E',
                          v_aanduiding || v_errormsg,
                          v_errorhint);
        COMMIT;
END cnd_update_srtdeel_mlddisc;
/

-----------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
--PLAT#53608: NEN2767 inspectie/gebreken importfunctie nen2767_results
-----------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE cnd_import_nen2767_results (
    p_import_key   IN NUMBER)
AS
    c_fielddelimitor             VARCHAR2 (2) := fac.import_delimiter(p_import_key);
    v_newline                    VARCHAR2 (1000);                -- Input line
    v_aanduiding                 VARCHAR2 (200);
    v_errorhint                  VARCHAR2 (1000);
    v_errormsg                   VARCHAR2 (1000);
    oracle_err_num               NUMBER;
    oracle_err_mes               VARCHAR2 (200);
    header_is_valid              NUMBER := 0;
    v_ongeldig                   NUMBER (1);
    v_count_tot                  NUMBER (10);
    v_count_import               NUMBER (10);
    v_count                      NUMBER;
    v_mld_stdmelding_key         NUMBER (10);
    v_regel                      NUMBER;
    v_mld_srtkenmerk_key1           VARCHAR2 (255);
    v_mld_srtkenmerk_key2           VARCHAR2 (255);
    v_mld_srtkenmerk_key3           VARCHAR2 (255);
    v_mld_srtkenmerk_key4           VARCHAR2 (255);
    v_mld_srtkenmerk_key5           VARCHAR2 (255);
    v_mld_srtkenmerk_key6           VARCHAR2 (255);
    v_mld_srtkenmerk_key7           VARCHAR2 (255);
    v_mld_srtkenmerk_key8           VARCHAR2 (255);
    v_mld_srtkenmerk_key9           VARCHAR2 (255);
    v_mld_srtkenmerk_key10          VARCHAR2 (255);

    v_alg_gebouw_code            VARCHAR2 (1000);
    v_ins_deel_omschrijving      VARCHAR2 (1000);
    v_mld_melding_datum          VARCHAR2 (1000);
    v_mld_melding_omschrijving   VARCHAR2 (1000);
    v_prs_perslid_email          VARCHAR2 (1000);
    v_gebrekcode                 VARCHAR2 (1000);
    v_ernst                      VARCHAR2 (1000);
    v_omvang                     VARCHAR2 (1000);
    v_intensiteit                VARCHAR2 (1000);
    v_aspect1                    VARCHAR2 (1000);
    v_aspect2                    VARCHAR2 (1000);
    v_aspect3                    VARCHAR2 (1000);
    v_aspect4                    VARCHAR2 (1000);
    v_aspect5                    VARCHAR2 (1000);
    v_aspect6                    VARCHAR2 (1000);
    v_aspect7                    VARCHAR2 (1000);
    v_foto                       VARCHAR2 (1000);
    v_kosten                     VARCHAR2 (1000);
    v_plandatum                  VARCHAR2 (1000);
    v_condscore                  VARCHAR2 (1000);
    v_prioscore                  VARCHAR2 (1000);
    v_gebouwcode                 NUMBER(1) := 0;
    v_plato                      NUMBER;
    v_mld_kenmerkwaarde1            VARCHAR2 (4000);
    v_mld_kenmerkwaarde2            VARCHAR2 (4000);
    v_mld_kenmerkwaarde3            VARCHAR2 (4000);
    v_mld_kenmerkwaarde4            VARCHAR2 (4000);
    v_mld_kenmerkwaarde5            VARCHAR2 (4000);
    v_mld_kenmerkwaarde6            VARCHAR2 (4000);
    v_mld_kenmerkwaarde7            VARCHAR2 (4000);
    v_mld_kenmerkwaarde8            VARCHAR2 (4000);
    v_mld_kenmerkwaarde9            VARCHAR2 (4000);
    v_mld_kenmerkwaarde10           VARCHAR2 (4000);

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


   -- Controleer tijdens import-fase alleen op bestaan van kenmerksoort (of
   -- deze - via een kenmerk - wel is gedefinieerd voor de betreffende melding -
   -- discipline/vakgroep/st-melding, volgt pas tijdens de update-fase)!
   --
   -- kw is bijvoorbeeld 'Parkeercode' of 'Parkeercode|3' waarbij de laatste in groep 3 zit
   -- het resultaat is NULL (als niet gevonden) of 234|3 voor strkenmer_key 234 in groep 3
   -- Als geen groep is meegegeven wordt 234|0 opgeleverd (de default groep)
   FUNCTION bepaal_srtkenmerk_key (p_kw IN VARCHAR)
      RETURN VARCHAR
   IS
      v_srtkenmerk_key   NUMBER;
      v_kenmerk_groep    NUMBER;
      v_kw               VARCHAR(250);
   BEGIN
      v_kenmerk_groep := 0;
      v_kw := p_kw;
      IF INSTR (v_kw, '|') > 1
      THEN
        v_kenmerk_groep := SUBSTR (v_kw, INSTR (v_kw, '|') + 1);
        v_kw := SUBSTR (v_kw, 1, INSTR (v_kw, '|') - 1);
      END IF;

      IF fac.safe_to_number (v_kw) IS NULL
      THEN                -- kenmerkwaarde is alfanumeriek (dus omschrijving)!
         SELECT   mld_srtkenmerk_key
           INTO   v_srtkenmerk_key
           FROM   mld_srtkenmerk     -- ins_v_aanwezigsrtkenmerk
          WHERE   mld_srtkenmerk_upper = UPPER (v_kw)
                  AND mld_srtkenmerk_kenmerktype IN ('C', 'D', 'N', 'R', 'S', 'X', 'B', 'V');
      ELSE                             -- kenmerkwaarde is numeriek (dus key)!
         SELECT   mld_srtkenmerk_key
           INTO   v_srtkenmerk_key
           FROM   mld_srtkenmerk    -- ins_v_aanwezigsrtkenmerk
          WHERE   mld_srtkenmerk_key = fac.safe_to_number (v_kw)
                  AND mld_srtkenmerk_kenmerktype IN ('C', 'D', 'N', 'R', 'S', 'X', 'B', 'V');
      END IF;

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

    FUNCTION get_aspect_value (p_aspect IN VARCHAR2)
        RETURN VARCHAR2
    IS
        v_result   VARCHAR2 (100);
    BEGIN
        v_result := p_aspect;

        IF p_aspect IS NULL OR p_aspect = 0
        THEN
            v_result := 'NVT';
        END IF;

        IF p_aspect = '1'
        THEN
            v_result := 'Gering';
        END IF;

        IF p_aspect = '2'
        THEN
            v_result := 'Matig';
        END IF;

        IF p_aspect = '3'
        THEN
            v_result := 'Sterk';
        END IF;

        RETURN v_result;
    END;
BEGIN
    v_errorhint := 'cnd_import_nen2767_results';

    v_count_tot := 0;
    v_count_import := 0;
    v_plato := 0;


    FOR rec1 IN c1
    LOOP
        BEGIN
            v_newline := rec1.fac_imp_file_line;
            v_regel := rec1.fac_imp_file_index;
            v_aanduiding := '';
            v_errorhint := 'Fout bij opvragen te importeren rij';
            v_ongeldig := 0;
            -- Lees alle veldwaarden

            -- check of het een plato import is
            IF UPPER(v_newline) LIKE '%CLUSTER PLATO%' AND header_is_valid = 0
            THEN
               v_plato := 1;
            END IF;

            -- Voor niet alle klanten is de gebouwcode relevant. Daarom is deze optioneel.
            IF ((UPPER(v_newline) LIKE '%GEBOUWCODE%' OR UPPER(v_newline) LIKE '%CLUSTER PLATO%') AND header_is_valid = 0) OR v_gebouwcode = 1
            THEN
               -- 01
               v_aanduiding := 'Probleem bij v_alg_gebouw_code: ';
               fac.imp_getfield_nr (v_newline,
                                    c_fielddelimitor,
                                    1,
                                    v_alg_gebouw_code);
               v_alg_gebouw_code := TRIM (v_alg_gebouw_code);
               v_gebouwcode := 1;
            ELSE
               -- Als we geen gebouwcode gebruiken dan plakken we er een lege entry voor.
               v_newline := c_fielddelimitor || v_newline;
               IF header_is_valid = 1
               THEN
                  v_alg_gebouw_code := NULL;
               ELSE
                  v_alg_gebouw_code := 'GEBOUWCODE';
               END IF;
            END IF;

            -- 02
            v_aanduiding := 'Probleem bij v_ins_deel_omschrijving: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 2,
                                 v_ins_deel_omschrijving);
            v_ins_deel_omschrijving := TRIM (v_ins_deel_omschrijving);

            -- 04
            v_aanduiding := 'Probleem bij v_mld_melding_datum: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 4,
                                 v_mld_melding_datum);
            v_mld_melding_datum := TRIM (v_mld_melding_datum);


            -- 06
            v_aanduiding := 'Probleem bij v_gebrekcode: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 6,
                                 v_gebrekcode);
            v_gebrekcode := TRIM (v_gebrekcode);

            -- 08
            v_aanduiding := 'Probleem bij v_ernst: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 8,
                                 v_ernst);
            v_ernst := TRIM (v_ernst);

            -- 09
            v_aanduiding := 'Probleem bij v_omvang: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 9,
                                 v_omvang);
            v_omvang := TRIM (v_omvang);

            -- 10
            v_aanduiding := 'Probleem bij v_intensiteit: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 10,
                                 v_intensiteit);
            v_intensiteit := TRIM (v_intensiteit);

            -- 11
            v_aanduiding := 'Probleem bij v_aspect1: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 11,
                                 v_aspect1);
            v_aspect1 := TRIM (v_aspect1);

            -- 12
            v_aanduiding := 'Probleem bij v_aspect2: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 12,
                                 v_aspect2);
            v_aspect2 := TRIM (v_aspect2);

            -- 13
            v_aanduiding := 'Probleem bij v_aspect3: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 13,
                                 v_aspect3);
            v_aspect3 := TRIM (v_aspect3);

            -- 14
            v_aanduiding := 'Probleem bij v_aspect4: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 14,
                                 v_aspect4);
            v_aspect4 := TRIM (v_aspect4);

            -- 15
            v_aanduiding := 'Probleem bij v_aspect5: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 15,
                                 v_aspect5);
            v_aspect5 := TRIM (v_aspect5);

            -- 16
            v_aanduiding := 'Probleem bij v_aspect6: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 16,
                                 v_aspect6);
            v_aspect6 := TRIM (v_aspect6);

            -- Kenmerk bestaat alleen bij niet plato klanten
            IF v_plato = 0
            THEN
               -- 17
               v_aanduiding := 'Probleem bij v_aspect7: ';
               fac.imp_getfield_nr (v_newline,
                                    c_fielddelimitor,
                                    17,
                                    v_aspect7);
               v_aspect7 := TRIM (v_aspect7);
            ELSE
               v_aspect7 := NULL;
            END IF;

            -- 18
            v_aanduiding := 'Probleem bij v_mld_melding_omschrijving: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 18 - v_plato,
                                 v_mld_melding_omschrijving);
            v_mld_melding_omschrijving := TRIM (v_mld_melding_omschrijving);

            -- 19
            v_aanduiding := 'Probleem bij v_condscore: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 19 - v_plato,
                                 v_condscore);
            v_condscore := TRIM (v_condscore);

            -- 20
            v_aanduiding := 'Probleem bij v_prioscore: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 20 - v_plato,
                                 v_prioscore);
            v_prioscore := TRIM (v_prioscore);

            -- 21
            v_aanduiding := 'Probleem bij v_prs_perslid_email: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 21 - v_plato,
                                 v_prs_perslid_email);
            v_prs_perslid_email := TRIM (v_prs_perslid_email);

            -- 22
            v_aanduiding := 'Probleem bij v_foto: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 22 - v_plato,
                                 v_foto);
            v_foto := TRIM (v_foto);

            -- 23
            v_aanduiding := 'Probleem bij v_kosten: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 23 - v_plato,
                                 v_kosten);
            v_kosten := TRIM (v_kosten);

            -- 25
            v_aanduiding := 'Probleem bij v_plandatum: ';
            fac.imp_getfield_nr (v_newline,
                                 c_fielddelimitor,
                                 25 - v_plato,
                                 v_plandatum);
            v_plandatum := TRIM (v_plandatum);

            -- 26 t/m 35
            v_aanduiding := 'Probleem bij vullen v_mld_kenmerkwaarde 1 t/m 10: ';
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,26 - v_plato, v_mld_kenmerkwaarde1);
            v_mld_kenmerkwaarde1 := TRIM (v_mld_kenmerkwaarde1);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,27 - v_plato, v_mld_kenmerkwaarde2);
            v_mld_kenmerkwaarde2 := TRIM (v_mld_kenmerkwaarde2);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,28 - v_plato, v_mld_kenmerkwaarde3);
            v_mld_kenmerkwaarde3 := TRIM (v_mld_kenmerkwaarde3);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,29 - v_plato, v_mld_kenmerkwaarde4);
            v_mld_kenmerkwaarde4 := TRIM (v_mld_kenmerkwaarde4);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,30 - v_plato, v_mld_kenmerkwaarde5);
            v_mld_kenmerkwaarde5 := TRIM (v_mld_kenmerkwaarde5);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,31 - v_plato, v_mld_kenmerkwaarde6);
            v_mld_kenmerkwaarde6 := TRIM (v_mld_kenmerkwaarde6);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,32 - v_plato, v_mld_kenmerkwaarde7);
            v_mld_kenmerkwaarde7 := TRIM (v_mld_kenmerkwaarde7);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,33 - v_plato, v_mld_kenmerkwaarde8);
            v_mld_kenmerkwaarde8 := TRIM (v_mld_kenmerkwaarde8);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,34 - v_plato, v_mld_kenmerkwaarde9);
            v_mld_kenmerkwaarde9 := TRIM (v_mld_kenmerkwaarde9);
            fac.imp_getfield_nr (v_newline,c_fielddelimitor,35 - v_plato, v_mld_kenmerkwaarde10);
            v_mld_kenmerkwaarde10 := TRIM (v_mld_kenmerkwaarde10);

            v_aanduiding :=
                   '['
                || v_alg_gebouw_code
                || '-'
                || v_ins_deel_omschrijving
                || '-'
                || v_gebrekcode
                || '] ';

            -- Ik controleer of ik een geldige header heb, dat is: in de juiste kolommen
            -- de juiste kolomkop. Ik controleer daarbij de volgende kolommen:

            -- 1. Gebouwcode
            -- 2. Objectcode
            -- 4. Datum
            -- 6. Gebrekcode
            -- 8. Ernst
            -- 9. Omvang
            -- 10. Intensiteit
            -- 11. Aspectwaarde1
            -- 12. Aspectwaarde2
            -- 13. Aspectwaarde3
            -- 14. Aspectwaarde4
            -- 15. Aspectwaarde5
            -- 16. Aspectwaarde6
            -- 17. Aspectwaarde7
            -- 18. Opmerking
            -- 19. Conditiescore
            -- 20. Prio
            -- 21. Inspecteur
            -- 22. Foto
            -- 23. Kosten
            -- 24. Vervaldatum
            -- 25. Datum gepland

            -- Ik negeer alles totdat ik een geldige header ben gepasseerd.
            -- De tweede waarde is de waarde uit de plato import. Als er geen tweede waarde is dan zijn ze gelijk.
            IF (header_is_valid = 0)
            THEN
                IF     (UPPER (v_alg_gebouw_code) = 'GEBOUWCODE' OR UPPER (v_alg_gebouw_code) = 'CLUSTER PLATO')
                   AND (UPPER (v_ins_deel_omschrijving) = 'OBJECTOMSCHRIJVING' OR UPPER (v_ins_deel_omschrijving) = 'ELEMENTCODE')
                   AND (UPPER (v_gebrekcode) = 'STDMELDING' OR UPPER (v_gebrekcode) = 'GEBREKCODE')
                   AND UPPER (v_ernst) = 'ERNST'
                   AND UPPER (v_omvang) = 'OMVANG'
                   AND UPPER (v_intensiteit) = 'INTENSITEIT'
                   AND UPPER (v_mld_melding_omschrijving) = 'OPMERKING'
                   AND UPPER (v_prs_perslid_email) = 'INSPECTEUR'
                   AND (UPPER (v_foto) = 'FOTO' OR UPPER (v_foto) = 'FOTO?')
                THEN
                    v_mld_srtkenmerk_key1 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde1);
                    v_mld_srtkenmerk_key2 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde2);
                    v_mld_srtkenmerk_key3 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde3);
                    v_mld_srtkenmerk_key4 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde4);
                    v_mld_srtkenmerk_key5 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde5);
                    v_mld_srtkenmerk_key6 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde6);
                    v_mld_srtkenmerk_key7 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde7);
                    v_mld_srtkenmerk_key8 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde8);
                    v_mld_srtkenmerk_key9 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde9);
                    v_mld_srtkenmerk_key10 := bepaal_srtkenmerk_key (v_mld_kenmerkwaarde10);

                    header_is_valid := 1;
                ELSE
                    IF rec1.fac_imp_file_index = 1
                    THEN
                        fac.imp_writelog (
                            p_import_key,
                            'I',
                               'Header: '
                            || UPPER (v_alg_gebouw_code)
                            || '-'
                            || UPPER (v_ins_deel_omschrijving)
                            || '-'
                            || UPPER (v_gebrekcode)
                            || '-'
                            || UPPER (v_ernst)
                            || '-'
                            || UPPER (v_omvang)
                            || '-'
                            || UPPER (v_intensiteit)
                            || '-'
                            || UPPER (v_mld_melding_omschrijving)
                            || '-'
                            || UPPER (v_prs_perslid_email)
                            || '-'
                            || UPPER (v_foto),
                            '');
                    END IF;
                END IF;
            ELSE
                v_count_tot := v_count_tot + 1;

                v_errorhint :=
                    'Ongeldig kolom GEBOUWCODE (mag maximaal 12 tekens zijn)';

                IF    (v_alg_gebouw_code IS NOT NULL)
                   AND (LENGTH (v_alg_gebouw_code) > 12)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldige kolom OBJECTOMSCHRIJVING (moet gevuld en maximaal 60 tekens zijn) [' || v_ins_deel_omschrijving || ']';

                IF    (v_ins_deel_omschrijving IS NULL)
                   OR (LENGTH (v_ins_deel_omschrijving) > 60)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldige kolom DATUM (moet leeg of geldige datum in formaat dd-mm-jjjj zijn) [' || v_mld_melding_datum || ']';

                IF     (v_mld_melding_datum IS NOT NULL)
                   AND (fac.safe_to_date (v_mld_melding_datum, 'dd-mm-yyyy')
                            IS NULL)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom STDMELDING (moet gevuld en maximaal 20 tekens zijn) [' || v_gebrekcode || ']';

                IF (v_gebrekcode IS NULL) OR (LENGTH (v_gebrekcode) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                -- Bepaal of gebrek uberhaupt wel in gebrekenlijst voorkomt
                v_errorhint :=
                   'Gebrek (melding) niet gevonden (bestaat niet), regel wordt overgeslagen';

                SELECT max(sm.mld_stdmelding_key)
                  INTO v_mld_stdmelding_key
                FROM mld_stdmelding sm
                WHERE UPPER(mld_stdmelding_code) = UPPER (v_gebrekcode);

                IF v_mld_stdmelding_key IS NULL
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                 END IF;

                IF UPPER(v_gebrekcode) = 'GEEN GEBREK' OR v_ongeldig = 1
                THEN
                   v_omvang := NULL;
                   v_intensiteit := NULL;
                   v_ernst := NULL;
                   v_gebrekcode := 'GEEN';
                ELSE
                    --
                    v_errorhint :=
                        'Ongeldig kolom ERNST (moet gevuld en maximaal 50 tekens zijn) [' || v_ernst || ']';

                    -- Als de codering ingevuld wordt gaan we zelf op zoek naar de omschrijving.
                    IF FAC.safe_to_number(v_ernst) IN (1, 2, 3)
                    THEN
                        CASE v_ernst
                            WHEN 1
                            THEN
                                v_ernst := 'G - Gering gebrek';
                            WHEN 2
                            THEN
                                v_ernst := 'S - Serieus gebrek';
                            WHEN 3
                            THEN
                                v_ernst := 'E - Ernstig gebrek';
                        END CASE;
                    END IF;

                    -- Bepalen of de ingelezen ernst wel overeenkomt met de ernst die bij het gebrek hoort.
                    SELECT COUNT (*)
                      INTO v_count
                      FROM mld_srtkenmerk  sk,
                           mld_kenmerk     k,
                           mld_stdmelding  std,
                           fac_usrdata     ud
                     WHERE     sk.mld_srtkenmerk_key = k.mld_srtkenmerk_key
                           AND k.mld_kenmerk_niveau = 'S'
                           AND k.mld_stdmelding_key = std.mld_stdmelding_key
                           AND sk.mld_srtkenmerk_code = 'ERNST'
                           AND mld_stdmelding_code = v_gebrekcode
                           AND fac_usrdata_omschr = v_ernst
                           AND k.mld_kenmerk_default LIKE '%' || ud.fac_usrdata_key || '%';

                    IF v_count <> 1
                    THEN
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding,
                            'Ernst komt niet overeen met default bij gebrekcode.');
                    END IF;

                    IF (v_ernst IS NULL) OR (LENGTH (v_ernst) > 50)
                    THEN
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding,
                            v_errorhint || ' - Regel wordt overgeslagen');
                        v_ongeldig := 1;
                    END IF;

                    --
                    v_errorhint :=
                        'Ongeldig kolom OMVANG (moet 1,2,3,4 of 5 zijn) [' || v_omvang || ']';

                    -- Als de codering ingevuld wordt gaan we zelf op zoek naar de omschrijving.
                    IF fac.safe_to_number(v_omvang) IN (1,
                                    2,
                                    3,
                                    4,
                                    5)
                    THEN
                        CASE v_omvang
                            WHEN 1
                            THEN
                                v_omvang := '< 2% Incidenteel';
                            WHEN 2
                            THEN
                                v_omvang := '2% tot 10% Plaatselijk';
                            WHEN 3
                            THEN
                                v_omvang := '10% tot 30% Regelmatig';
                            WHEN 4
                            THEN
                                v_omvang := '30% tot 70% Aanzienlijk';
                            WHEN 5
                            THEN
                                v_omvang := '> 70% Algemeen';
                        END CASE;
                    END IF;

                    IF (v_omvang IS NULL) OR (LENGTH (v_omvang) > 50)
                    THEN
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding,
                            v_errorhint || ' - Regel wordt overgeslagen');
                        v_ongeldig := 1;
                    END IF;

                    --
                    v_errorhint :=
                           'Ongeldig kolom INTENSITEIT (moet 1,2 of 3 zijn):  [' || v_intensiteit || ']'
                        || v_intensiteit;

                    -- Als de codering ingevuld wordt gaan we zelf op zoek naar de omschrijving.
                    IF fac.safe_to_number(v_intensiteit) IN (1, 2, 3)
                    THEN
                        CASE v_intensiteit
                            WHEN 1
                            THEN
                                v_intensiteit := '1 - Beginstadium';
                            WHEN 2
                            THEN
                                v_intensiteit := '2 - Gevorderd stadium';
                            WHEN 3
                            THEN
                                v_intensiteit := '3 - Eindstadium';
                        END CASE;
                    END IF;

                    IF (v_intensiteit IS NULL) OR (LENGTH (v_intensiteit) > 50)
                    THEN
                        fac.imp_writelog (
                            p_import_key,
                            'W',
                            v_aanduiding,
                            v_errorhint || ' - Regel wordt overgeslagen');
                        v_ongeldig := 1;
                    END IF;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT1 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect1 := get_aspect_value (v_aspect1);

                IF (v_aspect1 IS NULL) OR (LENGTH (v_aspect1) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT2 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect2 := get_aspect_value (v_aspect2);

                IF (v_aspect2 IS NULL) OR (LENGTH (v_aspect2) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT3 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect3 := get_aspect_value (v_aspect3);

                IF (v_aspect3 IS NULL) OR (LENGTH (v_aspect3) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT4 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect4 := get_aspect_value (v_aspect4);

                IF (v_aspect4 IS NULL) OR (LENGTH (v_aspect4) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT5 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect5 := get_aspect_value (v_aspect5);

                IF (v_aspect5 IS NULL) OR (LENGTH (v_aspect5) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT6 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect6 := get_aspect_value (v_aspect6);

                IF (v_aspect6 IS NULL) OR (LENGTH (v_aspect6) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom ASPECT7 (moet gevuld en maximaal 20 tekens zijn)';
                v_aspect7 := get_aspect_value (v_aspect7);

                IF (v_aspect7 IS NULL) OR (LENGTH (v_aspect7) > 20)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom OPMERKING (mag maximaal 2000 tekens zijn)';

                IF (LENGTH (v_mld_melding_omschrijving) > 2000)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                           v_errorhint
                        || ' - Opmerking wordt afgekapt op 2000 tekens');
                    v_mld_melding_omschrijving :=
                        SUBSTR (v_mld_melding_omschrijving, 1, 2000);
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom INSPECTEUR (moet ingevuld en mag maximaal 200 tekens zijn) [' || v_prs_perslid_email || ']';

                IF    (v_prs_perslid_email IS NULL)
                   OR (LENGTH (v_prs_perslid_email) > 200)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom FOTO (mag maximaal 50 tekens zijn) [' || v_foto || ']';

                IF (LENGTH (v_foto) > 50)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Foto wordt overgeslagen');
                    v_foto := NULL;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom CONDITIESCORE (indien gevuld dan een cijfer van 1 t/m 6)';

                IF     (v_condscore IS NOT NULL)
                   AND (   (fac.safe_to_number (v_condscore) < 0)
                        OR (fac.safe_to_number (v_condscore) > 6))
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                --
                v_errorhint :=
                    'Ongeldig kolom PRIORITEITSSCORE (indien gevuld dan een cijfer van 1 t/m 9)';

                IF     (v_prioscore IS NOT NULL)
                   AND (   (fac.safe_to_number (v_prioscore) < 0)
                        OR (fac.safe_to_number (v_prioscore) > 9))
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                v_kosten := REPLACE (v_kosten, ',', '.');
                v_errorhint :=
                    'Ongeldig kolom KOSTEN (indien gevuld dan een cijfer met max 2 decimalen)';

                IF     (v_kosten IS NOT NULL)
                   AND (fac.safe_to_number (v_kosten) IS NULL)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                v_errorhint := 'Ongeldig kolom DATUM GEPLAND (Geldige datum)';

                IF     (v_plandatum IS NOT NULL)
                   AND (fac.safe_to_date (v_plandatum, 'dd-mm-yyyy') IS NULL)
                THEN
                    fac.imp_writelog (
                        p_import_key,
                        'W',
                        v_aanduiding,
                        v_errorhint || ' - Regel wordt overgeslagen');
                    v_ongeldig := 1;
                END IF;

                IF (v_ongeldig = 0)
                THEN
                    BEGIN
                        v_errorhint :=
                            'Fout bij toevoegen regel aan importtabel cnd_imp_nen2767_results';

                        INSERT INTO cnd_imp_nen2767_results (
                                        fac_import_key,
                                        alg_gebouw_code,
                                        ins_deel_omschrijving,
                                        mld_melding_datum,
                                        mld_melding_omschrijving,
                                        prs_perslid_email,
                                        gebrekcode,
                                        ernst,
                                        omvang,
                                        intensiteit,
                                        aspect1,
                                        aspect2,
                                        aspect3,
                                        aspect4,
                                        aspect5,
                                        aspect6,
                                        aspect7,
                                        kosten,
                                        plandatum,
                                        foto,
                                        condscore,
                                        prioscore,
                                        flex1,
                                        flex2,
                                        flex3,
                                        flex4,
                                        flex5,
                                        flex6,
                                        flex7,
                                        flex8,
                                        flex9,
                                        flex10)
                             VALUES (p_import_key,
                                     v_alg_gebouw_code,
                                     v_ins_deel_omschrijving,
                                     v_mld_melding_datum,
                                     v_mld_melding_omschrijving,
                                     v_prs_perslid_email,
                                     v_gebrekcode,
                                     v_ernst,
                                     v_omvang,
                                     v_intensiteit,
                                     v_aspect1,
                                     v_aspect2,
                                     v_aspect3,
                                     v_aspect4,
                                     v_aspect5,
                                     v_aspect6,
                                     v_aspect7,
                                     v_kosten,
                                     fac.safe_to_date (v_plandatum, 'dd-mm-yyyy'),
                                     v_foto,
                                     v_condscore,
                                     v_prioscore,
                                     DECODE (v_mld_srtkenmerk_key1,
                                        NULL, v_mld_kenmerkwaarde1,
                                        TO_CHAR (v_mld_srtkenmerk_key1)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde1, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key2,
                                        NULL, v_mld_kenmerkwaarde2,
                                        TO_CHAR (v_mld_srtkenmerk_key2)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde2, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key3,
                                        NULL, v_mld_kenmerkwaarde3,
                                        TO_CHAR (v_mld_srtkenmerk_key3)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde3, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key4,
                                        NULL, v_mld_kenmerkwaarde4,
                                        TO_CHAR (v_mld_srtkenmerk_key4)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde4, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key5,
                                        NULL, v_mld_kenmerkwaarde5,
                                        TO_CHAR (v_mld_srtkenmerk_key5)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde5, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key6,
                                        NULL, v_mld_kenmerkwaarde6,
                                        TO_CHAR (v_mld_srtkenmerk_key6)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde6, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key7,
                                        NULL, v_mld_kenmerkwaarde7,
                                        TO_CHAR (v_mld_srtkenmerk_key7)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde7, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key8,
                                        NULL, v_mld_kenmerkwaarde8,
                                        TO_CHAR (v_mld_srtkenmerk_key8)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde8, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key9,
                                        NULL, v_mld_kenmerkwaarde9,
                                        TO_CHAR (v_mld_srtkenmerk_key9)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde9, 1, 3900)
                                     ),
                                     DECODE (v_mld_srtkenmerk_key10,
                                        NULL, v_mld_kenmerkwaarde10,
                                        TO_CHAR (v_mld_srtkenmerk_key10)
                                        || '='
                                        || SUBSTR (v_mld_kenmerkwaarde10, 1, 3900)
                                     )
                                     );

                        v_count_import := v_count_import + 1;
                        COMMIT;
                    EXCEPTION
                        WHEN OTHERS
                        THEN
                            oracle_err_num := SQLCODE;
                            oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
                            v_errormsg :=
                                   v_errorhint
                                || ' ORACLE (error '
                                || oracle_err_num
                                || '/'
                                || oracle_err_mes
                                || ')';
                            fac.imp_writelog (
                                p_import_key,
                                'E',
                                v_aanduiding || v_errormsg,
                                'Ingelezen regel kan niet worden weggeschreven!');
                            COMMIT;
                    END;
                END IF;
            END IF;
        END;
    END LOOP;

    IF (header_is_valid = 0)
    THEN
        fac.imp_writelog (
            p_import_key,
            'E',
            'Ongeldig importbestand',
            'Geen header of header niet volgens specificatie: A. GEBOUWCODE, B. OBJECTOMSCHRIJVING, F. STDMELDING, H.ERNST, I. OMVANG, J. INTENSITEIT, R. OPMERKING, U. INSPECTEUR, V. FOTO');
    ELSE
        fac.imp_writelog (
            p_import_key,
            'S',
               'IMPORT NEN2767 RESULTS: aantal ingelezen regels: '
            || TO_CHAR (v_count_tot)
            || ' / aantal geldige regels: '
            || TO_CHAR (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_errormsg,
                          v_errorhint || ' regel[' || v_regel || ']');
END cnd_import_nen2767_results;
/

CREATE OR REPLACE PROCEDURE cnd_update_nen2767_results (
    p_import_key   IN NUMBER)
IS
    CURSOR c1
    IS
        SELECT *
          FROM cnd_imp_nen2767_results
         WHERE fac_import_key = p_import_key;



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

    v_mld_melding_key              NUMBER (10);

    v_alg_gebouw_key               NUMBER (10);
    v_ins_deel_key                 NUMBER (10);
    v_alg_ruimte_key               NUMBER (10);
    v_prs_perslid_key              NUMBER (10);
    v_mld_stdmelding_key           NUMBER (10);

    v_ernst_kenmerk_key            NUMBER (10);
    v_ernst_key                    NUMBER (10);
    v_omvang_kenmerk_key           NUMBER (10);
    v_omvang_key                   NUMBER (10);
    v_intensiteit_kenmerk_key      NUMBER (10);
    v_intensiteit_key              NUMBER (10);

    v_foto_kenmerk_key             NUMBER (10);
    v_kosten_kenmerk_key           NUMBER (10) := NULL;
    v_kosten_srtkenmerk_key        NUMBER (10);

    v_ernst_srtkenmerk_key         NUMBER (10);
    v_omvang_srtkenmerk_key        NUMBER (10);
    v_intensiteit_srtkenmerk_key   NUMBER (10);


    PROCEDURE set_aspect (p_aspect            IN VARCHAR2,
                          p_aspect_waarde     IN VARCHAR2,
                          p_mld_melding_key   IN NUMBER)
    IS
        v_key              NUMBER (10);
        v_kenmerk_key      NUMBER (10);
        v_srtkenmerk_key   NUMBER (10);
    BEGIN
        SELECT MAX (mld_srtkenmerk_key)
          INTO v_srtkenmerk_key
          FROM mld_srtkenmerk
         WHERE mld_srtkenmerk_code = p_aspect;

        IF v_srtkenmerk_key IS NOT NULL
        THEN
            v_errorhint :=
                   p_aspect
                || ' (eigen tabel) niet gevonden (bestaat niet), regel wordt overgeslagen';

            SELECT ud.fac_usrdata_key, k.mld_kenmerk_key
              INTO v_key, v_kenmerk_key
              FROM mld_srtkenmerk     sk,
                   fac_kenmerkdomein  kd,
                   fac_usrtab         ut,
                   fac_usrdata        ud,
                   mld_kenmerk        k
             WHERE     sk.mld_srtkenmerk_key = v_srtkenmerk_key
                   AND kd.fac_kenmerkdomein_key = sk.fac_kenmerkdomein_key
                   AND ut.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrdata_upper = UPPER (p_aspect_waarde)
                   AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key;

            mld.upsertmeldingkenmerk (v_kenmerk_key,
                                      p_mld_melding_key,
                                      v_key);
        END IF;
    END;

    -- SUBPROC
    -- Voor vullen van de optionele kenmerkvelden 1 t/m 10
    -- p_srtkenmerkgroepwaarde = '234|1=37-ZB-DR'. Ofwel: srtkenmerk_key|groep=waarde
    PROCEDURE insert_mldkenmerk (p_mld_melding_key       IN NUMBER,
                                 p_srtkenmerkgroepwaarde IN VARCHAR2)
    AS
        v_kenmerk_key       NUMBER;
        v_srtkenmerk_key    NUMBER;
        v_groep             NUMBER;
        v_waarde            VARCHAR(4000);
        v_srtkenmerk_type   VARCHAR2 (1);
        ccount              NUMBER;
        v_objectnaam        fac_kenmerkdomein.fac_kenmerkdomein_objectnaam%TYPE;
        v_kolomnaam         fac_kenmerkdomein.fac_kenmerkdomein_kolomnaam%TYPE;
        v_kolomtxt          fac_kenmerkdomein.fac_kenmerkdomein_kolomtxt%TYPE;
        sql_stmt            VARCHAR2 (1000);
        v_kenmerkdeel_key   NUMBER;
        l_cursor_1          INTEGER;
        l_rowsprocessed     NUMBER DEFAULT 0;
    BEGIN
        IF p_srtkenmerkgroepwaarde IS NOT NULL
        THEN
            v_errormsg := 'Fout bij bepalen kenmerk van soort [' || p_srtkenmerkgroepwaarde || ']';

            v_srtkenmerk_key := fac.safe_to_number (
                       SUBSTR (p_srtkenmerkgroepwaarde, 1, INSTR (p_srtkenmerkgroepwaarde, '|') - 1));
            v_groep := fac.safe_to_number (
                       SUBSTR (p_srtkenmerkgroepwaarde,
                                INSTR (p_srtkenmerkgroepwaarde, '|') + 1,
                                INSTR (p_srtkenmerkgroepwaarde, '=') - 1 - INSTR (p_srtkenmerkgroepwaarde, '|')));
            v_waarde := SUBSTR (p_srtkenmerkgroepwaarde, INSTR (p_srtkenmerkgroepwaarde, '=') + 1);


        -- Niveau en mld_kenmerk_key bepalen vanuit de ingelezen gebreksmelding
             SELECT mk.mld_kenmerk_key, msk.mld_srtkenmerk_kenmerktype
                INTO v_kenmerk_key, v_srtkenmerk_type
                FROM mld_kenmerk mk, mld_srtkenmerk msk, mld_melding m, mld_stdmelding sm, mld_discipline d, ins_srtdiscipline t
                WHERE  mk.mld_srtkenmerk_key = v_srtkenmerk_key
                       AND mk.mld_kenmerk_groep = v_groep
                       AND mk.mld_srtkenmerk_key = msk.mld_srtkenmerk_key
                       AND m.mld_melding_key = p_mld_melding_key
                       AND m.mld_stdmelding_key = sm.mld_stdmelding_key
                       AND sm.mld_ins_discipline_key = d.ins_discipline_key
                       AND d.ins_srtdiscipline_key = t.ins_srtdiscipline_key AND t.ins_srtdiscipline_module = 'MLD'
                       AND (
                            (mk.mld_stdmelding_key = sm.mld_stdmelding_key and mk.mld_kenmerk_niveau = 'S')
                            OR
                            (mk.mld_stdmelding_key = d.ins_discipline_key and mk.mld_kenmerk_niveau = 'D')
                            OR
                            (mk.mld_stdmelding_key = t.ins_srtdiscipline_key and mk.mld_kenmerk_niveau = 'T')
                           ) ;

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

                    SELECT COUNT ( * )
                      INTO ccount
                      FROM mld_srtkenmerk sk, fac_kenmerkdomein d
                     WHERE     sk.mld_srtkenmerk_key = v_srtkenmerk_key
                           AND sk.fac_kenmerkdomein_key = d.fac_kenmerkdomein_key
                           AND d.fac_usrtab_key IS NOT NULL;

                    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 mld_srtkenmerk sk, fac_kenmerkdomein d, fac_v_aanwezigusrdata ud
                         WHERE     sk.mld_srtkenmerk_key = v_srtkenmerk_key
                               AND sk.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 mld_srtkenmerk sk, fac_kenmerkdomein d
                         WHERE     sk.mld_srtkenmerk_key = v_srtkenmerk_key
                               AND sk.fac_kenmerkdomein_key = d.fac_kenmerkdomein_key
                               AND d.fac_usrtab_key IS NULL;

                        sql_stmt :=
                               'SELECT MAX ('
                            || v_kolomnaam
                            || ') FROM '
                            || v_objectnaam
                            || ' WHERE UPPER (TRIM ('
                            || v_kolomtxt
                            || ')) = UPPER (:pwaarde)';
                       l_cursor_1 := DBMS_SQL.open_cursor;
                       DBMS_SQL.parse (l_cursor_1, sql_stmt, DBMS_SQL.native);
                       DBMS_SQL.BIND_VARIABLE(l_cursor_1,':pwaarde', v_waarde);
                       DBMS_SQL.define_column(l_cursor_1, 1, v_waarde, 255);
                       l_rowsprocessed := DBMS_SQL.execute_and_fetch (l_cursor_1);
                       DBMS_SQL.column_value (l_cursor_1, 1, v_waarde);
                       DBMS_SQL.close_cursor(l_cursor_1);
                    END IF;
                ELSE                                 -- C(Karakter)/D(Datum)/N(Numeriek)/X(Bestandsnaam)
                    NULL; -- v_waarde := p_waarde;
                END IF;

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

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

                    INSERT INTO mld_kenmerkmelding (mld_melding_key, mld_kenmerk_key, mld_kenmerkmelding_waarde)
                        VALUES (p_mld_melding_key, v_kenmerk_key, v_waarde);
            ELSE
                NULL;

            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,
                              'insert_mldkenmerk');
    END;


BEGIN
    v_count_tot := 0;
    v_count_import := 0;

    v_errorhint :=
        'Ernst kenmerk bij gebreken niet gevonden (bestaat niet), import wordt niet uitgevoerd';

    SELECT mld_srtkenmerk_key
      INTO v_ernst_srtkenmerk_key
      FROM mld_srtkenmerk
     WHERE mld_srtkenmerk_code = 'ERNST';

    v_errorhint :=
        'Omvang kenmerk bij gebreken niet gevonden (bestaat niet), import wordt niet uitgevoerd';

    SELECT mld_srtkenmerk_key
      INTO v_omvang_srtkenmerk_key
      FROM mld_srtkenmerk
     WHERE mld_srtkenmerk_code = 'OMVANG';

    v_errorhint :=
        'Intensiteit kenmerk bij gebreken niet gevonden (bestaat niet), import wordt niet uitgevoerd';

    SELECT mld_srtkenmerk_key
      INTO v_intensiteit_srtkenmerk_key
      FROM mld_srtkenmerk
     WHERE mld_srtkenmerk_code = 'INTENSITEIT';

    v_errorhint :=
        'Fout bij bepalen kenmerk foto-bestand';

    SELECT max(k.mld_kenmerk_key)
      INTO v_foto_kenmerk_key
      FROM mld_kenmerk k, mld_srtkenmerk sk
     WHERE     k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
          AND k.mld_kenmerk_niveau = 'T'
          AND k.mld_stdmelding_key = fac.getsetting ('cnd_gebreken_srtdisc_key')
          AND sk.mld_srtkenmerk_upper = 'FOTONAAM' ;

    v_errorhint :=
        'Kosten kenmerk bij gebreken niet gevonden (bestaat niet), import wordt niet uitgevoerd';

    SELECT MAX (mld_srtkenmerk_key)
      INTO v_kosten_srtkenmerk_key
      FROM mld_srtkenmerk
     WHERE mld_srtkenmerk_code = 'KOSTEN';

    IF v_kosten_srtkenmerk_key IS NOT NULL
    THEN
        SELECT mld_kenmerk_key
          INTO v_kosten_kenmerk_key
          FROM mld_kenmerk
         WHERE     mld_srtkenmerk_key = v_kosten_srtkenmerk_key;
    END IF;

    FOR rec IN c1
    LOOP
        BEGIN
            v_count_tot := v_count_tot + 1;
            v_aanduiding :=
                   '['
                || rec.alg_gebouw_code
                || '-'
                || rec.ins_deel_omschrijving
                || '-'
                || rec.gebrekcode
                || '] ';

            v_errorhint :=
                'Gebouwcode niet gevonden (bestaat niet), regel wordt overgeslagen';

            v_alg_gebouw_key := -1;

            IF rec.alg_gebouw_code IS NOT NULL
            THEN
                SELECT alg_gebouw_key
                  INTO v_alg_gebouw_key
                  FROM alg_v_aanweziggebouw
                 WHERE alg_gebouw_upper = UPPER (rec.alg_gebouw_code);
            END IF;

            v_errorhint :=
                'Element (object) niet gevonden (bestaat niet), regel wordt overgeslagen';

            -- Uitgangspunt hierbij is dat objectnaam uniek is per gebouw, op zich mag in Facilitor de objectnaam per objectsoort per locatie uniek zijn.
            SELECT ins_deel_key, r.alg_ruimte_key
              INTO v_ins_deel_key, v_alg_ruimte_key
              FROM ins_v_aanwezigdeel, alg_ruimte r, alg_verdieping v
             WHERE     ins_deel_upper = UPPER (rec.ins_deel_omschrijving)
                   AND ins_alg_ruimte_key = r.alg_ruimte_key
                   AND r.alg_verdieping_key = v.alg_verdieping_key
                   AND (   v_alg_gebouw_key = -1
                        OR v.alg_gebouw_key = v_alg_gebouw_key)
                   AND ins_alg_ruimte_type = 'R';

            v_errorhint :=
                'Mailadres van inspecteur (persoon) niet gevonden (bestaat niet), regel wordt overgeslagen';

            SELECT prs_perslid_key
              INTO v_prs_perslid_key
              FROM prs_v_aanwezigperslid
             WHERE UPPER (prs_perslid_email) = UPPER (rec.prs_perslid_email);


            v_errorhint :=
                'Gebrek (melding) niet gevonden (bestaat niet), regel wordt overgeslagen';

            SELECT sm.mld_stdmelding_key
              INTO v_mld_stdmelding_key
              FROM mld_stdmelding sm
             WHERE UPPER(mld_stdmelding_code) = UPPER (rec.gebrekcode);

            IF UPPER(rec.gebrekcode) = 'GEEN'
                THEN
                   v_errorhint :=
                'Geen Gebrek melding. Ernst, Omvang en Intensiteit worden overgeslagen';
                ELSE

            v_errorhint :=
                'Ernst (eigen tabel) niet gevonden (bestaat niet), regel wordt overgeslagen';

            SELECT ud.fac_usrdata_key, k.mld_kenmerk_key
              INTO v_ernst_key, v_ernst_kenmerk_key
              FROM mld_srtkenmerk     sk,
                   fac_kenmerkdomein  kd,
                   fac_usrtab         ut,
                   fac_usrdata        ud,
                   mld_kenmerk        k
             WHERE     sk.mld_srtkenmerk_key = v_ernst_srtkenmerk_key
                   AND kd.fac_kenmerkdomein_key = sk.fac_kenmerkdomein_key
                   AND ut.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrdata_upper = UPPER (rec.ernst)
                   AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                   AND k.mld_stdmelding_key = v_mld_stdmelding_key
                   AND k.mld_kenmerk_niveau = 'S';

            v_errorhint :=
                'Omvang (eigen tabel) niet gevonden (bestaat niet), regel wordt overgeslagen';

            SELECT ud.fac_usrdata_key, k.mld_kenmerk_key
              INTO v_omvang_key, v_omvang_kenmerk_key
              FROM mld_srtkenmerk     sk,
                   fac_kenmerkdomein  kd,
                   fac_usrtab         ut,
                   fac_usrdata        ud,
                   mld_kenmerk        k
             WHERE     sk.mld_srtkenmerk_key = v_omvang_srtkenmerk_key
                   AND kd.fac_kenmerkdomein_key = sk.fac_kenmerkdomein_key
                   AND ut.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrdata_upper = UPPER (rec.omvang)
                   AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                   AND k.mld_stdmelding_key = v_mld_stdmelding_key
                   AND k.mld_kenmerk_niveau = 'S';

            v_errorhint :=
                'Intensiteit (eigen tabel) niet gevonden (bestaat niet), regel wordt overgeslagen';

            SELECT ud.fac_usrdata_key, k.mld_kenmerk_key
              INTO v_intensiteit_key, v_intensiteit_kenmerk_key
              FROM mld_srtkenmerk     sk,
                   fac_kenmerkdomein  kd,
                   fac_usrtab         ut,
                   fac_usrdata        ud,
                   mld_kenmerk        k
             WHERE     sk.mld_srtkenmerk_key = v_intensiteit_srtkenmerk_key
                   AND kd.fac_kenmerkdomein_key = sk.fac_kenmerkdomein_key
                   AND ut.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrtab_key = kd.fac_usrtab_key
                   AND ud.fac_usrdata_upper = UPPER (rec.intensiteit)
                   AND k.mld_srtkenmerk_key = sk.mld_srtkenmerk_key
                   AND k.mld_stdmelding_key = v_mld_stdmelding_key
                   AND k.mld_kenmerk_niveau = 'S';
             END IF;

            v_errorhint :=
                'Toevoegen melding';
            INSERT INTO mld_melding (mld_melding_module,
                                     mld_meldbron_key,
                                     mld_melding_datum,
                                     mld_melding_omschrijving,
                                     mld_stdmelding_key,
                                     mld_alg_onroerendgoed_keys,
                                     mld_melding_einddatum,
                                     prs_perslid_key,
                                     prs_perslid_key_voor,
                                     mld_melding_status,
                                     mld_melding_spoed)
                 VALUES (
                            'MLD',
                            6,
                            fac.safe_to_date (rec.mld_melding_datum,
                                              'dd-mm-yyyy'),
                            rec.mld_melding_omschrijving,
                            v_mld_stdmelding_key,
                            v_alg_ruimte_key,
                            rec.plandatum,
                            v_prs_perslid_key,
                            v_prs_perslid_key,
                            NULL,
                            3)
              RETURNING mld_melding_key
                   INTO v_mld_melding_key;

            mld.setmeldingstatus(v_mld_melding_key, 2, v_prs_perslid_key, 0);

            v_errorhint := 'Koppelen object';
            INSERT INTO mld_melding_object (mld_melding_key, ins_deel_key)
                 VALUES (v_mld_melding_key, v_ins_deel_key);

            v_errorhint := 'Toevoegen Ernst kenmerk';
            mld.upsertmeldingkenmerk (v_ernst_kenmerk_key,
                                      v_mld_melding_key,
                                      v_ernst_key);
            v_errorhint := 'Toevoegen Omvang kenmerk';
            mld.upsertmeldingkenmerk (v_omvang_kenmerk_key,
                                      v_mld_melding_key,
                                      v_omvang_key);
            v_errorhint := 'Toevoegen Intensiteit kenmerk';
            mld.upsertmeldingkenmerk (v_intensiteit_kenmerk_key,
                                      v_mld_melding_key,
                                      v_intensiteit_key);
            set_aspect ('ASPECT1', rec.aspect1, v_mld_melding_key);
            set_aspect ('ASPECT2', rec.aspect2, v_mld_melding_key);
            set_aspect ('ASPECT3', rec.aspect3, v_mld_melding_key);
            set_aspect ('ASPECT4', rec.aspect4, v_mld_melding_key);
            set_aspect ('ASPECT5', rec.aspect5, v_mld_melding_key);
            set_aspect ('ASPECT6', rec.aspect6, v_mld_melding_key);
            set_aspect ('ASPECT7', rec.aspect7, v_mld_melding_key);

            v_errorhint := 'Toevoegen Foto kenmerk';
            IF rec.foto IS NOT NULL
            THEN
                mld.upsertmeldingkenmerk (v_foto_kenmerk_key,
                                          v_mld_melding_key,
                                          rec.foto);
            END IF;

            v_errorhint := 'Toevoegen Kosten kenmerk';
            IF rec.kosten IS NOT NULL AND v_kosten_kenmerk_key IS NOT NULL
            THEN
                mld.upsertmeldingkenmerk (v_kosten_kenmerk_key,
                                          v_mld_melding_key,
                                          TO_CHAR(rec.kosten));
            END IF;

            -- Hier toevoegen insert_meldingskenmerken 1 t/m 10..
            v_errorhint := 'Toevoegen kenmerk-velden ';
            insert_mldkenmerk (v_mld_melding_key, rec.flex1);
            insert_mldkenmerk (v_mld_melding_key, rec.flex2);
            insert_mldkenmerk (v_mld_melding_key, rec.flex3);
            insert_mldkenmerk (v_mld_melding_key, rec.flex4);
            insert_mldkenmerk (v_mld_melding_key, rec.flex5);
            insert_mldkenmerk (v_mld_melding_key, rec.flex6);
            insert_mldkenmerk (v_mld_melding_key, rec.flex7);
            insert_mldkenmerk (v_mld_melding_key, rec.flex8);
            insert_mldkenmerk (v_mld_melding_key, rec.flex9);
            insert_mldkenmerk (v_mld_melding_key, rec.flex10);

            v_errorhint := 'Meldingen direct accepteren ';
            IF fac.getsetting('cnd_autoaccept') = 1
            THEN
                mld.setmeldingstatus(v_mld_melding_key, 4, v_prs_perslid_key, 0);
            END IF;

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

    fac.imp_writelog (
        p_import_key,
        'S',
           'UPDATE NEN2767_RESULTS: aantal ingelezen regels: '
        || TO_CHAR (v_count_tot)
        || ' / aantal geldige regels: '
        || TO_CHAR (v_count_import),
        '');
EXCEPTION
    WHEN OTHERS
    THEN
        oracle_err_num := SQLCODE;
        oracle_err_mes := SUBSTR (SQLERRM, 1, 100);
        v_errormsg :=
               'OTHERS (error '
            || oracle_err_num
            || '/'
            || oracle_err_mes
            || ')';
        fac.imp_writelog (p_import_key,
                          'E',
                          v_aanduiding || v_errormsg,
                          v_errorhint);
        COMMIT;
END cnd_update_nen2767_results;
/


REGISTERRUN('$Id$')

#endif // CND
