Subversion Repositories Sigmater

Rev

Blame | Last modification | View Log | Download | RSS feed

<?php

// ************************************************
// INCLUDE CLASSE ZIP
// ************************************************
require_once(APP_PATH.'include/LSTU_pclzip.lib.php');

// ************************************************
// INCLUDE CLASSE PEAR Mail/mimeDecode.php
// ************************************************
require_once('Mail/mimeDecode.php');

// *******************************************************
// Classi per il parsing xml
// *******************************************************
require_once(APP_PATH.'include/LSTM_Incrementale_Fab.class.php');
require_once(APP_PATH.'include/LSTM_Incrementale_Ter.class.php');
require_once(APP_PATH.'include/LSTM_Incrementale_Sog.class.php');
require_once(APP_PATH.'include/LSTM_Incrementale_ICI.class.php');
require_once(APP_PATH.'include/LSTM_Incrementale_TARSU.class.php');
require_once(APP_PATH.'include/LSTM_Incrementale_TARES.class.php');
require_once(APP_PATH.'impiantodb/include/LSTM_staging_catasto.inc');
require_once(APP_PATH.'impiantodb/LSTM_operazioni_db.php');

function gestione_errore($err, $msg, $associata = false) {
        
        global $conn, $flag_ass;
        
        out('ERRORE = '.$err);
        
        @OCIRollback($conn);
        
        if ($associata)
                $flag_ass = 1;
                
        wlog($err, 1, $msg);
        
        if (!update_codstato(11))
                wlog(30014, 1);
                
        $flag_ass = 0;
        
}

function gestione_update_stato($associata) {
        
        global $flag_ass;
        
        if ($associata) {

                $flag_ass = 1;
                $autocommit = 0;
        }
        else {

                $autocommit = 1;
        }       
        
        $ret = update_codstato(12, $autocommit);
        
        $flag_ass = 0;
        
        if (!$ret) {
                
                gestione_errore(30009, '', $associata);
                return false;
        }       
                
        return true;
}       

function parse_xml(&$xml, $keyservizio) {
        
        //////////////////////////////////////////////////////////
        // opzioni per il costruttore della classe XML_Unserializer
        //////////////////////////////////////////////////////////
        $attribs_name = 'attribs';
        $options = array(
                         'complexType' => 'array',
                         'parseAttributes'   => true,
                         'attributesArray'   => $attribs_name
                        );
        
        switch ($keyservizio) {
 
               case 5:
                        //////////////////////////////////////////////////////////
                        // istanza della classe Incrementale_TARSU
                        //////////////////////////////////////////////////////////
                        $Parser = &new Incrementale_TARSU($options, 'http://www.agenziaterritorio.it/TARSU.xsd');     
                break;
                   case 3:
                        //////////////////////////////////////////////////////////
                        // istanza della classe Incrementale_TARES
                        //////////////////////////////////////////////////////////
                        $Parser = &new Incrementale_TARES($options, 'http://www.agenziaentrate.it/TARES');     
                break;
               case 6:
                        
                        //////////////////////////////////////////////////////////
                        // istanza della classe Incrementale_ICI
                        //////////////////////////////////////////////////////////
                        $Parser = &new Incrementale_ICI($options, 'http://www.agenziaterritorio.it/ICI.xsd');
                break;

        
                case 7:
                        
                        //////////////////////////////////////////////////////////
                        // istanza della classe Incrementale_Fab
                        //////////////////////////////////////////////////////////
                        $Parser = &new Incrementale_Fab($options, 'http://www.agenziaterritorio.it/IncrementaleOggettiFabbricati.xsd');
                                
                break;

                case 8:
                case 27:
                        
                        //////////////////////////////////////////////////////////
                        // istanza della classe Incrementale_Ter
                        //////////////////////////////////////////////////////////
                        $Parser = &new Incrementale_Ter($options, 'http://www.agenziaterritorio.it/IncrementaleOggettiTerreni.xsd');
                                
                break;          
                
                case 9:
                case 10:
                        
                        //////////////////////////////////////////////////////////
                        // istanza della classe Incrementale_Sog
                        //////////////////////////////////////////////////////////
                        $Parser = &new Incrementale_Sog($options, 'http://www.agenziaterritorio.it/IncrementaleSoggetti.xsd');
                                
                break;                          
        }
        
        //////////////////////////////////////////////////////////
        // deserializzazione dell'xml
        //////////////////////////////////////////////////////////
        $status = $Parser->P_Unserialize($xml, false);    
        if (!$status) {
                
                return array(false, 30008, $Parser->P_error);
        }
        
        //////////////////////////////////////////////////////////
        // composizione array dati per staging
        //////////////////////////////////////////////////////////    
        $Parser->compose_staging();

        $arr_staging = $Parser->get_staging();

        if (empty($arr_staging))
                return array(false, 30023, 'Risultato parsing nullo');
        return array(true, $arr_staging, '');
}

function load_staging_tables(&$arr_staging, $protocollo_staging, &$extra) {

        global $conn, $staging_catasto, $GL_OCI_LOB;

        foreach ($arr_staging as $_prodotto=>$arr_tabella) {
                $ret_w = true;  
                foreach ($arr_tabella as $nr=>$arr_riga) {      
                        
                        // per i riferimenti planimetrici viene effettuata una insert per ogni pagina
                        // della planimetria. Il record differisce solo per il numero pagina.
                        //echo "Il valore della fornitura vale".$_prodotto."\n";        
                        if ($_prodotto == 'plan') {
                                // in $arr_riga[8] c'� il totale delle pagine della planimetria
                                $tot_pag = $arr_riga[8];
                                
                                // ciclo per sostituire il totale delle pagine con il numero pagina
                                for ($npag = 1; $npag <= $tot_pag; $npag++) {

                                        $arr_riga[8] = $npag;
                                        $filename_plan = APP_PATH.'tmp/'.$arr_riga[7].'.'.str_pad($npag, 3, '0', STR_PAD_LEFT);
                                        if(file_exists($filename_plan)) {  
                                                list($ret_w, $err, $msg)=insert_blob_plan($filename_plan,$arr_riga,$protocollo_staging);
                                                if (!$ret_w) {
                                                        return array(false, 30022, '');
                                                } 
                                        }       
                                }
                        
                        }
                        else {
                                
                                 // controllo sul flag classamento MM 
                                 if($_prodotto == 'uiu'){
                                        if(!is_numeric($arr_riga[43])){
                                                $arr_riga[43]=-1;
                                        }
                                 }
                                // chiamata alla funzione di scrittura sulle tabelle di staging
                                $ret_w = write_impianto_db($conn, $_prodotto, null, $arr_riga, $staging_catasto, '', $protocollo_staging, 0);
                        }
                        
                        if (!$ret_w) {
                                
                                return array(false, 30022, '');
                        }
                        /*
                        elseif ($_prodotto == 'plan') {
                                
                                // se si tratta di planimetrie bisogna riempire anche il campo blob
                                // (precedentemente inserito come EMPTY_BLOB()) usando la risorsa
                                // globale $GL_OCI_LOB settata nelle funzioni oci_db;                           
                                
                                global $GL_OCI_LOB;
                                
                                // chiamata alla funzione che prepara le planimetrie in un file zip;
                                // parametri in input: nome planimetria, numero fogli;
                                list($ret, $filename) = get_planimetrie_zipped($arr_riga[7], $arr_riga[8]);
                                
                                if (!$ret)
                                        return array(false, 30025, 'Creazione file zip planimetrie staging');
                                
                            if (!$GL_OCI_LOB->savefile($filename)) {
                                
                                unlink($filename);
                                return array(false, 30024, '');
                            }
                            
                            unlink($filename);
                        }
                        */
                        elseif ($_prodotto == 'uiu' || $_prodotto == 'particelle' || $_prodotto == 'titolarita') {
                                
                                // INSERT NELLA TABELLA TCW20_CARICAMENTO
                                
                                if ($_prodotto == 'uiu') {
                                        
                                        $arr_caricamento[0] = array(1, $arr_riga[22], 'F', $arr_riga[1], $arr_riga[2], $arr_riga[35], $arr_riga[4], 0, '', '', '', '', '', '', '', '', '', '', $extra[$nr][1], $extra[$nr][2], $extra[$nr][3], $extra[$nr][4], $extra[$nr][5]);
                                        
                                        if ($arr_riga[36] != '')
                                                $arr_caricamento[1] = array(1, $arr_riga[28], 'F', $arr_riga[1], $arr_riga[2], $arr_riga[36], $arr_riga[4], 1, '', '', '', '', '', '', '', '', '', '', $extra[$nr][1], $extra[$nr][2], $extra[$nr][3], $extra[$nr][4], $extra[$nr][5]);
                                                
                                }
                                elseif ($_prodotto == 'particelle') {
                                        
                                        $arr_caricamento[0] = array(5, $arr_riga[23], 'T', $arr_riga[1], $arr_riga[2], $arr_riga[36], $arr_riga[4], 0, '', '', '', '', '', '', '', '', '', '', '', '', '', '', '');
                                        
                                        if ($arr_riga[37] != '')
                                                $arr_caricamento[1] = array(5, $arr_riga[29], 'T', $arr_riga[1], $arr_riga[2], $arr_riga[37], $arr_riga[4], 1, '', '', '', '', '', '', '', '', '', '', '', '', '', '', '');
                                                
                                }
                                elseif ($_prodotto == 'titolarita') {
                                        
                                        // controllo tipo catasto per settare tipo operazione
                                        $tipo_operazione = ($arr_riga[6] == 'F') ? 9 : 12;
                                        
                                        $arr_caricamento[0] = array($tipo_operazione, $arr_riga[18], $arr_riga[6], $arr_riga[1], $arr_riga[2], $arr_riga[26], '', 0, '', '', '', '', '', '', '', '', '', '', '', '', '', '', '');
                                        
                                        if ($arr_riga[27] != '')
                                                $arr_caricamento[1] = array($tipo_operazione, $arr_riga[25], $arr_riga[6], $arr_riga[1], $arr_riga[2], $arr_riga[27], '', 1, '', '', '', '', '', '', '', '', '', '', '', '', '', '', '');
                                                
                                }
                                                                                                        
                                foreach ($arr_caricamento as $arr_carica_riga) {
                                                
                                        // chiamata alla funzione di scrittura sulle tabelle di staging
                                        $ret_w = write_impianto_db($conn, 'caricamento', null, $arr_carica_riga, $staging_catasto, '', $protocollo_staging, 0);
                                        if (!$ret_w)
                                                return array(false, 30022, '');
                                }
                                
                                unset($arr_caricamento);
                        }                       
                }
        }
        
        return array(true, '', '');
}       


function get_xml(&$blob_zipped) {

    list($ret, $data_fname, $msg) = get_by_extension($blob_zipped, 'smime');
    
    if (!$ret)
        return array(false, $data_fname, $msg);
    
    $smime = implode('', file($data_fname));
    
    unlink($data_fname);
        
        ///////////////////////////////////////////////////////////////////
    // DECODIFICA DEL PKCS7 E RECUPERO DEL CORPO (BODY) DEL MESSAGGIO
    ///////////////////////////////////////////////////////////////////    
    $struct_pkcs7 = decode_pkcs7($smime);
    
        if (!isset($struct_pkcs7->parts[0]->body))
                return array(false, 30007, 'Decodifica PKCS7 fallita');
                    
    $xml = $struct_pkcs7->parts[0]->body;       
        
        return array(true, $xml, '');
}

function gestione_fornitura_associata() {
        
        global $keyservizio, $keycom, $keysez, $progiscrizione, $periodo_da, $periodo_a, $keydett, $protocollo_ass;

        ///////////////////////////////////////////////////////
        // CONTROLLO PRESENZA FORNITURA ASSOCIATA ED EVENTUALE
        // RECUPERO DI TOTALE_FILE E PROTOCOLLO
        ///////////////////////////////////////////////////////         
        list($ret, $n_file_tot_ass, $protocollo_ass,$keydett_ass) = check_fornitura($progiscrizione, $periodo_da, $periodo_a, 1, $keydett, 4);
        
        if (!$ret)
                return array(false, 30013, '');
        elseif ($ret === 'NODATA')
                return array('NODATA', '', '');

        list($ret, $data_prot) = insert_protocollo_staging($keyservizio, $keycom, $keysez, $periodo_da, $periodo_a, $protocollo_ass, 0);
        
        if (!$ret)
                return array(false, $data_prot, '');
        
        $protocollo_staging = $data_prot;
        
        $arr_hash = array();
         
        /////////////////////////////////////////////////
        // CICLO SU OGNI FILE DELLA FORNITURA ASSOCIATA
        /////////////////////////////////////////////////               
        for ($idfile = 1; $idfile <= $n_file_tot_ass; $idfile++) {

                /////////////////////////////////////////////////
                // RECUPERO DEL FILE DELLA FORNITURA
                /////////////////////////////////////////////////       
                list($ret, $data, $msg) = extract_blob($progiscrizione, $periodo_da, $periodo_a, 1, $keydett_ass, $idfile);
                
                if (!$ret)                      
                        return array(false, $data, $msg);
                
                if ($keyservizio == 7) {
                
                        ///////////////////////////////////////////////////////
                        // CALCOLO E MEMORIZZAZIONE DELL'HASH DELLE PLANIMETRIE
                        // ($arr_hash passato per riferimento)
                        ///////////////////////////////////////////////////////
                        list($ret, $err, $msg) = get_hash($data, $arr_hash);
                }
                elseif ($keyservizio == 27) {
                        
                        /////////////////////////////////////////////////
                        // GESTIONE DELLE FORNITURE XML
                        /////////////////////////////////////////////////
                        list($ret, $err, $msg) = gestione_dati_xml($data, '', $protocollo_staging);
                }
                
                if (!$ret)
                        return array(false, $err, $msg);                        
        }       

        if(!update_codstato_ass(12,0,$keydett_ass))
                 return array(false,30009, 'Errore aggiornamento dello stato');   

        return array(true, $arr_hash, '');
}

function get_hash(&$blob_zipped, &$arr_hash) {
        
    list($ret, $data_fname, $msg) = get_by_extension($blob_zipped, 'zip');
   
    if (!$ret)
        return array(false, $data_fname, $msg);
    
        $zip = new PclZip($data_fname);
        
        $arr_list = $zip->listContent();                
        
        if (!$arr_list)
                return array(false, 30021, 'Fallita lista del contenuto del file zip:'.$zip->errorInfo());

        foreach ($arr_list as $v) {
                
                if (!$zip->extractByIndex($v['index'], APP_PATH.'tmp'))
                        return array(false, 30017, 'Fallita estrazione file da zip');
                                
                $filename = basename($v['filename']);
                                
                $arr_hash[$filename] = md5_file(APP_PATH.'tmp/'.$filename);
                
                //unlink(APP_PATH.'tmp/'.$filename);
        }
        
        unlink($data_fname);
        
        return array(true, '', '');
}

function check_hash($arr_hash, $arr_check) {
        
        foreach ($arr_check as $v) {
                
                $chiave = $v[1].'.'.str_pad($v[2], 3, '0', STR_PAD_LEFT);
                
                if (isset($arr_hash[$chiave])) {
                        
                        if ($arr_hash[$chiave] != $v[3])
                                return array(false, 30019, 'Nome file: '.$chiave);
                        
                }
                else {
                        
                        out('Nome file: '.$chiave.' non trovato');
                        //return array(false, 30018, 'Nome file: '.$chiave);
                }       
        }
        
        return array(true, '', '');
}

function get_by_extension(&$blob_zipped, $ext) {

        $fname_blob = tempnam(APP_PATH.'tmp', 'BLOB_');
        
        if (!wfile($fname_blob, $blob_zipped))
                return array(false, 30005, 'Errore scrittura file: '.$fname_blob);

        $zip = new PclZip($fname_blob);
        
        $arr_list = $zip->listContent();

        if (!$arr_list)
                return array(false, 30020, 'Fallita lista del contenuto del file zip:'.$zip->errorInfo());
                        
        foreach ($arr_list as $v) {
                
                $arr_name = explode('.', basename($v['filename']));
                $ext_file = end($arr_name);
                
                if ($ext_file == $ext) {
                        
                        $fname = APP_PATH.'tmp/'.basename($v['filename']);
                        $index = $v['index'];
                        break;
                }
        }
        
        if (!isset($index)) {
                
                unlink($fname_blob);
                return array(false, 30015, $ext.' non contenuto nel file zip');
        }
        
        if (!$zip->extractByIndex($index, APP_PATH.'tmp')) {
                
                unlink($fname_blob);
                return array(false, 30006, 'Fallita estrazione file: '.$fname);
        }
        
        unlink($fname_blob);
        
    return array(true, $fname, '');
}

function get_planimetrie_zipped($name, $number) {
        
        $fname_zip = tempnam(APP_PATH.'tmp', 'ZIP_');
        
        $zip = new PclZip($fname_zip);
        
        for ($i = 1; $i <= $number; $i++) {
                
                $filelist[] = APP_PATH.'tmp/'.$name.'.'.str_pad($i, 3, '0', STR_PAD_LEFT);
        }
        
        $ret = $zip->create($filelist, '', APP_PATH.'tmp');
        
        foreach ($filelist as $file) {
                
                unlink($file);
        }
                
        if (!$ret)
                return array(false, '');
                
        return array(true, $fname_zip);
}

function gestione_dati_xml(&$blob_zipped, $data_hash, $protocollo_staging) {
        
        global $keyservizio;
        
        /////////////////////////////////////////////////
        // RECUPERO DELL'XML DEL FILE DELLA FORNITURA
        /////////////////////////////////////////////////               
        list($ret, $data_xml, $msg) = get_xml($blob_zipped);
        
        if (!$ret)
                return array(false, $data_xml, $msg);
        
        ////////////////////////////////////////////////////
        // PARSIG DELL'XML E CARICAMENTO DELL'ARRAY DI DATI
        ////////////////////////////////////////////////////    
        list($ret, $data_staging, $msg) = parse_xml($data_xml, $keyservizio);
        
        if (!$ret)
                return array(false, $data_staging, $msg);
        
        if ('DATI_ASSENTI' != $data_staging) {
        
                if ($keyservizio == 7) {
                        
                        if (isset($data_staging['check'])) {    
                                ///////////////////////////////////////////////////////
                                // SE IL SERVIZIO E' INCREMENTALE FABBRICATI
                                // E DAL PARSING DELL'XML SI SONO OTTENUTI GLI HASH ->
                                // CONTROLLO HASH
                                ///////////////////////////////////////////////////////
                                list($ret, $err, $msg) = check_hash($data_hash, $data_staging['check']);
                                
                                // $data_staging['check'] viene eliminato perch� non deve essere passato
                                // alla funzione load_staging_tables()
                                unset($data_staging['check']);
                                                                
                                if (!$ret)
                                        return array(false, $err, $msg);
                                
                                out('OK HASH');
                        }
        
                        ///////////////////////////////////////////////////////
                        // SE IL SERVIZIO E' INCREMENTALE FABBRICATI
                        // IMPOSTO $caricamento_extra PER I FLAGS
                        // E POI RIPULISCO L'ARRAY DI STAGING
                        ///////////////////////////////////////////////////////
                        $caricamento_extra = $data_staging['flags_fabbricati'];
                        unset($data_staging['flags_fabbricati']);
                        //print_r($data_staging); 
                }
                else {
                        
                        $caricamento_extra = '';
                }       
                
                out('CARICAMENTO TABELLE DI STAGING');
                
                ////////////////////////////////////////////////////
                // CARICAMENTO TABELLE DI STAGING
                ////////////////////////////////////////////////////    
                list($ret, $err, $msg) = load_staging_tables($data_staging, $protocollo_staging, $caricamento_extra);
                
                if (!$ret)
                        return array(false, $err, $msg);
        }
                
        return array(true, '', '');
}

function gestione_dati_zip(&$blob_zipped, $protocollo_fornitura, $protocollo_staging, $progressivo) {
        
        global $gl_PP_arr_xml;

        /////////////////////////////////////////////////
        // INCLUDE CLASSE PATH_PARSER
        /////////////////////////////////////////////////
        
        require_once(APP_PATH.'include/LSTM_class_path_parser.php');    
        
        /////////////////////////////////////////////////
        // RECUPERO DELL'XML DEL FILE DELLA FORNITURA
        /////////////////////////////////////////////////               
        list($ret, $data_xml, $msg) = get_xml($blob_zipped);
        
        if (!$ret)
                return array(false, $data_xml, $msg);
                
        /////////////////////////////////////////////////
    // LETTURA HASH DALL'XML
    /////////////////////////////////////////////////

        //MM Inizio Trattamento Dati Assenti
        //Cerco se i dati sono presenti
                
        $path_ass = '/DatiOut/DatiAssenti';
        //MODIFICA MM 
        if(read_xml_if_exist_single_tag($data_xml,$path_ass)){
         if(!empty($gl_PP_arr_xml)){
          if(array_key_exists($path_ass, $gl_PP_arr_xml)){
           $assenza_dati = $gl_PP_arr_xml[$path_ass];
           echo "Il valore dei Dati assenti vale ".$assenza_dati;
           if ('true' == $assenza_dati || '1' == $assenza_dati) 
            return array(true, '', '');
          }
         }
        }   
        //MM fine Trattamento Dati Assenti

        $path = '/DatiOut/DatiPresenti/ChecksumZip/Hash';
        read_xml_single_tag($data_xml, $path);
        $hash_in_xml = $gl_PP_arr_xml[$path];
        
        if (empty($hash_in_xml))
                return array(false, 30026, 'HASH DEL FILE ZIP NON PRESENTE');
                
        /////////////////////////////////////////////////
        // RECUPERO DELLO ZIP DEL FILE DELLA FORNITURA
        /////////////////////////////////////////////////                   
        list($ret, $data_fname, $msg) = get_by_extension($blob_zipped, 'zip');
    
        if (!$ret)
         return array(false, $data_fname, $msg);

                /////////////////////////////////////////////////
        // CALCOLO HASH DEL FILE
        /////////////////////////////////////////////////       
        $hash_zip = md5_file($data_fname);

        //echo "IL VALORE DEL FILE HASH VALE=|".$hash_zip."|\n";
        //echo "IL VALORE DEL HASH NEL FILE XML VALE=|".$hash_in_xml."|\n";
        //echo "IL NOME FILE=|".$data_fname."|\n";

        /////////////////////////////////////////////////
        // CONFRONTO HASH
        /////////////////////////////////////////////////    
        //if ($hash_zip != $hash_in_xml)
                //return array(false, 30027, '');
        
        ////////////////////////////////////////////////////
        // INSERIMENTO DELLO ZIP NELLA TABELLA TCW24_BLOB_CART
        ////////////////////////////////////////////////////        
        list($ret, $err, $msg) = insert_blob_cart($data_fname, $protocollo_fornitura, $protocollo_staging, $progressivo);
    
        if (!$ret)
         return array(false, $err, $msg);
        
        return array(true, '', '');
}
?>