DBProtocolPropertiesUtils.java

  1. /*
  2.  * GovWay - A customizable API Gateway
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.core.mapping;

  23. import static org.openspcoop2.core.constants.CostantiDB.CREATE;
  24. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  25. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  27. import java.sql.Connection;
  28. import java.sql.PreparedStatement;
  29. import java.sql.ResultSet;
  30. import java.sql.SQLException;
  31. import java.util.ArrayList;
  32. import java.util.List;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.core.byok.BYOKWrappedValue;
  36. import org.openspcoop2.core.byok.IDriverBYOK;
  37. import org.openspcoop2.core.commons.CoreException;
  38. import org.openspcoop2.core.commons.DBUtils;
  39. import org.openspcoop2.core.constants.CostantiDB;
  40. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  41. import org.openspcoop2.generic_project.exception.NotFoundException;
  42. import org.openspcoop2.utils.TipiDatabase;
  43. import org.openspcoop2.utils.UtilsException;
  44. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  45. import org.openspcoop2.utils.jdbc.JDBCAdapterException;
  46. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  47. import org.openspcoop2.utils.jdbc.JDBCParameterUtilities;
  48. import org.openspcoop2.utils.sql.ISQLQueryObject;
  49. import org.openspcoop2.utils.sql.SQLObjectFactory;
  50. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  51. import org.slf4j.Logger;

  53. /**
  54.  * Funzioni di utilita utilizzate dai driver
  55.  *
  56.  * @author Andrea Poli (apoli@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  */
  60. public class DBProtocolPropertiesUtils {
  61.     
  62.     private DBProtocolPropertiesUtils() {}

  64.     private static void logDebug(Logger log, String msg) {
  65.         if(log!=null) {
  66.             log.debug(msg);
  67.         }
  68.     }
  69.     
  70.     private static List<String> protocolPropertiesConfidentials = new ArrayList<>();
  71.     public static List<String> getProtocolPropertiesConfidentials() {
  72.         return protocolPropertiesConfidentials;
  73.     }
  74.     public static void addConfidentialProtocolProperty(String nome){
  75.         if(!protocolPropertiesConfidentials.contains(nome)) {
  76.             protocolPropertiesConfidentials.add(nome);
  77.         }
  78.     }
  79.     public static boolean isConfidentialProtocolProperty(String nome) {
  80.         return protocolPropertiesConfidentials.contains(nome);
  81.     }
  82.     
  83.     public static void crudRegistryProtocolProperty(Logger log, int type, List<org.openspcoop2.core.registry.ProtocolProperty> listPP, long idProprietario,
  84.             ProprietariProtocolProperty tipologiaProprietarioProtocolProperty, Connection connection,
  85.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException {
  86.         List<ProtocolProperty> list = null;
  87.         if(listPP!=null) {
  88.             list = new ArrayList<>();
  89.             if(!listPP.isEmpty()) {
  90.                 for (org.openspcoop2.core.registry.ProtocolProperty pp : listPP) {
  91.                     list.add(new ProtocolProperty(pp));
  92.                 }
  93.             }
  94.         }
  95.         crudProtocolProperty(log, type, list, idProprietario, tipologiaProprietarioProtocolProperty, connection, tipoDatabase, driverBYOK);
  96.     }
  97.     public static void crudConfigProtocolProperty(Logger log, int type, List<org.openspcoop2.core.config.ProtocolProperty> listPP, long idProprietario,
  98.             ProprietariProtocolProperty tipologiaProprietarioProtocolProperty, Connection connection,
  99.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException {
  100.         List<ProtocolProperty> list = null;
  101.         if(listPP!=null) {
  102.             list = new ArrayList<>();
  103.             if(!listPP.isEmpty()) {
  104.                 for (org.openspcoop2.core.config.ProtocolProperty pp : listPP) {
  105.                     list.add(new ProtocolProperty(pp));
  106.                 }
  107.             }
  108.         }
  109.         crudProtocolProperty(log, type, list, idProprietario, tipologiaProprietarioProtocolProperty, connection, tipoDatabase, driverBYOK);
  110.     }

  112.     private static void crudProtocolProperty(Logger log, int type, List<ProtocolProperty> listPP, long idProprietario,
  113.             ProprietariProtocolProperty tipologiaProprietarioProtocolProperty, Connection connection,
  114.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException {
  115.         
  116.         // NOTA: l'update dei documenti, essendo mega di documenti non puo' essere implementata come delete + create
  117.         
  118.         PreparedStatement stm = null;
  119.         ResultSet rs=null;
  120.         String sqlQuery;

  122.         if((listPP == null) && (type!= CostantiDB.DELETE)) 
  123.             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] L'oggetto listPP non puo essere null");
  124.         if(idProprietario <= 0 ) 
  125.             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] id proprietario non definito");
  126.         
  127.         IJDBCAdapter jdbcAdapter = null;
  128.         
  129.         try {

  131.             jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(tipoDatabase);
  132.             
  133.             switch (type) {
  134.             case CREATE:

  136.                 if(listPP!=null) {
  137.                     for(int i=0; i<listPP.size(); i++){
  138.                     
  139.                         ProtocolProperty protocolProperty = listPP.get(i);
  140.                         if(protocolProperty.getName()==null || "".equals(protocolProperty.getName()))
  141.                             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] Nome non definito per protocolProperty ["+i+"]");
  142.                         
  143.                         // Aggiorno proprietari
  144.                         protocolProperty.setIdProprietario(idProprietario);
  145.                         protocolProperty.setTipoProprietario(tipologiaProprietarioProtocolProperty.name());
  146.                         
  147.                         int contenutiDefiniti = 0;
  148.                         
  149.                         boolean stringValue = protocolProperty.getValue()!=null && !"".equals(protocolProperty.getValue());
  150.                         String plainContenutoString = null;
  151.                         String encContenutoString = null;
  152.                         if(stringValue){ 
  153.                             contenutiDefiniti++;
  154.                             plainContenutoString = protocolProperty.getValue();
  155.                             if(driverBYOK!=null && isConfidentialProtocolProperty(protocolProperty.getName())) {
  156.                                 BYOKWrappedValue byokValue = driverBYOK.wrap(protocolProperty.getValue());
  157.                                 if(byokValue!=null) {
  158.                                     encContenutoString = byokValue.getWrappedValue();
  159.                                     plainContenutoString = byokValue.getWrappedPlainValue();
  160.                                 }
  161.                             }
  162.                         }
  163.                         
  164.                         boolean numberValue = protocolProperty.getNumberValue()!=null;
  165.                         Long contenutoNumber = null;
  166.                         if(numberValue){
  167.                             contenutiDefiniti++;
  168.                             contenutoNumber = protocolProperty.getNumberValue();
  169.                         }
  170.                         
  171.                         boolean booleanValue = protocolProperty.getBooleanValue()!=null;
  172.                         Boolean contenutoBoolean = null;
  173.                         if(booleanValue){
  174.                             contenutiDefiniti++;
  175.                             contenutoBoolean = protocolProperty.getBooleanValue();
  176.                         }
  177.                         
  178.                         boolean binaryValue = protocolProperty.getByteFile()!=null && protocolProperty.getByteFile().length>0;
  179.                         byte[] contenutoBinario = null; 
  180.                         String contenutoBinarioFileName = null;
  181.                         if(binaryValue){
  182.                             contenutiDefiniti++;
  183.                             contenutoBinario = protocolProperty.getByteFile();
  184.                             if(contenutoBinario.length<3){
  185.                                 String test = new String(contenutoBinario);
  186.                                 if("".equals(test.trim().replace("\n", ""))){
  187.                                     // eliminare \n\n
  188.                                     contenutoBinario = null;    
  189.                                     binaryValue = false;
  190.                                     contenutiDefiniti--;
  191.                                 }
  192.                             }
  193.                             if(binaryValue){
  194.                                 contenutoBinarioFileName = protocolProperty.getFile();
  195.                             
  196.                                 if(driverBYOK!=null && isConfidentialProtocolProperty(protocolProperty.getName())) {
  197.                                     BYOKWrappedValue byokValue = driverBYOK.wrap(contenutoBinario);
  198.                                     if(byokValue!=null) {
  199.                                         contenutoBinario = byokValue.getWrappedValue().getBytes();
  200.                                     }
  201.                                 }
  202.                             }
  203.                         }
  204.                         
  205.                         /**if(!stringValue && !numberValue && !binaryValue && !booleanValue){
  206.                             throw new DriverRegistroServiziException("[DBProtocolProperties::CRUDProtocolProperty] Contenuto non definito per protocolProperty ["+protocolProperty.getName()+"]");
  207.                         }*/
  208.                         // Per fare i filtri con is null e' necessario registrarlo!
  209.                         if(contenutiDefiniti>1){
  210.                             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] Contenuto definito con più tipologie per protocolProperty ["+protocolProperty.getName()+
  211.                                     "] (string:"+stringValue+" number:"+numberValue+" binary:"+binaryValue+")");
  212.                         }
  213.                         
  214.                         
  215.                         // create
  216.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  217.                         sqlQueryObject.addInsertTable(CostantiDB.PROTOCOL_PROPERTIES);
  218.                         sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO, "?");
  219.                         sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO, "?");
  220.                         sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME, "?");
  221.                         if(stringValue){
  222.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING, "?");
  223.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING, "?");
  224.                         }
  225.                         if(numberValue){
  226.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER, "?");
  227.                         }
  228.                         if(booleanValue){
  229.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN, "?");
  230.                         }
  231.                         if(binaryValue){
  232.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY, "?");
  233.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_FILENAME, "?");
  234.                         }
  235.                         sqlQuery = sqlQueryObject.createSQLInsert();
  236.                         stm = connection.prepareStatement(sqlQuery);
  237.                         int index = 1;
  238.                         stm.setString(index++, tipologiaProprietarioProtocolProperty.name());
  239.                         stm.setLong(index++, idProprietario);
  240.                         stm.setString(index++, protocolProperty.getName());
  241.                         String debug = null;
  242.                         if(stringValue){
  243.                             stm.setString(index++, plainContenutoString);
  244.                             debug = plainContenutoString;
  245.                             stm.setString(index++, encContenutoString);
  246.                         }
  247.                         if(numberValue){
  248.                             stm.setLong(index++, contenutoNumber);
  249.                             debug = contenutoNumber+"";
  250.                         }
  251.                         if(booleanValue){
  252.                             if(contenutoBoolean!=null && contenutoBoolean.booleanValue()){
  253.                                 stm.setInt(index++,CostantiDB.TRUE);
  254.                                 debug = CostantiDB.TRUE+"";
  255.                             }
  256.                             else{
  257.                                 stm.setInt(index++,CostantiDB.FALSE);
  258.                                 debug = CostantiDB.FALSE+"";
  259.                             }
  260.                         }
  261.                         if(binaryValue){
  262.                             jdbcAdapter.setBinaryData(stm,index++,contenutoBinario);
  263.                             debug = "BinaryData";
  264.                             stm.setString(index++, contenutoBinarioFileName);
  265.                             debug = debug + "," + contenutoBinarioFileName;
  266.                         }
  267.                         
  268.                         logDebug(log,"CRUDProtocolProperty CREATE : \n" + DBUtils.
  269.                                 formatSQLString(sqlQuery, tipologiaProprietarioProtocolProperty.name(), idProprietario, protocolProperty.getName(), debug));
  270.         
  271.                         int n = stm.executeUpdate();
  272.                         stm.close();
  273.                         logDebug(log,"Inserted " + n + " row(s)");
  274.             
  275.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  276.                         sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  277.                         sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  278.                         sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+" = ?");
  279.                         sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+" = ?");
  280.                         sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME+" = ?");
  281.                         sqlQueryObject.setANDLogicOperator(true);
  282.                         sqlQuery = sqlQueryObject.createSQLQuery();
  283.                         stm = connection.prepareStatement(sqlQuery);
  284.                         index = 1;
  285.                         stm.setString(index++, tipologiaProprietarioProtocolProperty.name());
  286.                         stm.setLong(index++, idProprietario);
  287.                         stm.setString(index++, protocolProperty.getName());
  288.         
  289.                         logDebug(log,"Recupero id inserito : \n" + DBUtils.
  290.                                 formatSQLString(sqlQuery, tipologiaProprietarioProtocolProperty.name(), idProprietario, protocolProperty.getName()));
  291.         
  292.                         rs = stm.executeQuery();
  293.         
  294.                         if (rs.next()) {
  295.                             listPP.get(i).setId(rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID));
  296.                         } else {
  297.                             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] Errore avvenuto durante il recupero dell'id dopo una create");
  298.                         }
  299.         
  300.                         rs.close();
  301.                         stm.close();
  302.                         
  303.                     }
  304.                 }
  305.                 break;

  307.             case UPDATE:
  308.                 
  309.                 // Prelevo vecchia lista
  310.                 List<ProtocolProperty> oldLista = getListaProtocolPropertySafe(idProprietario,tipologiaProprietarioProtocolProperty, connection, tipoDatabase, 
  311.                         null); //driverBYOK);  // serve solo a verificare se devo aggiornare o meno. Non serve quindi decodificare
  312.                 
  313.                 // Gestico la nuova immagine
  314.                 if(listPP!=null) {
  315.                     for(int i=0; i<listPP.size(); i++){
  316.                         
  317.                         ProtocolProperty protocolProperty = listPP.get(i);
  318.                         if(protocolProperty.getName()==null || "".equals(protocolProperty.getName()))
  319.                             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] Nome non definito per protocolProperty ["+i+"]");
  320.                         
  321.                         // Aggiorno proprietari
  322.                         protocolProperty.setIdProprietario(idProprietario);
  323.                         protocolProperty.setTipoProprietario(tipologiaProprietarioProtocolProperty.name());
  324.                         
  325.                         int contenutiDefiniti = 0;
  326.                         
  327.                         boolean stringValue = protocolProperty.getValue()!=null && !"".equals(protocolProperty.getValue());
  328.                         String plainContenutoString = null;
  329.                         String encContenutoString = null;
  330.                         if(stringValue){ 
  331.                             contenutiDefiniti++;
  332.                             plainContenutoString = protocolProperty.getValue();
  333.                             if(driverBYOK!=null && isConfidentialProtocolProperty(protocolProperty.getName())) {
  334.                                 BYOKWrappedValue byokValue = driverBYOK.wrap(protocolProperty.getValue());
  335.                                 if(byokValue!=null) {
  336.                                     encContenutoString = byokValue.getWrappedValue();
  337.                                     plainContenutoString = byokValue.getWrappedPlainValue();
  338.                                 }
  339.                             }
  340.                         }
  341.                         
  342.                         boolean numberValue = protocolProperty.getNumberValue()!=null;
  343.                         Long contenutoNumber = null;
  344.                         if(numberValue){
  345.                             contenutiDefiniti++;
  346.                             contenutoNumber = protocolProperty.getNumberValue();
  347.                         }
  348.                         
  349.                         boolean booleanValue = protocolProperty.getBooleanValue()!=null;
  350.                         Boolean contenutoBoolean = null;
  351.                         if(booleanValue){
  352.                             contenutiDefiniti++;
  353.                             contenutoBoolean = protocolProperty.getBooleanValue();
  354.                         }
  355.                         
  356.                         boolean binaryValue = protocolProperty.getByteFile()!=null && protocolProperty.getByteFile().length>0;
  357.                         byte[] contenutoBinario = null; 
  358.                         String contenutoBinarioFileName = null;
  359.                         if(binaryValue){
  360.                             contenutiDefiniti++;
  361.                             contenutoBinario = protocolProperty.getByteFile();
  362.                             if(contenutoBinario.length<3){
  363.                                 String test = new String(contenutoBinario);
  364.                                 if("".equals(test.trim().replace("\n", ""))){
  365.                                     // eliminare \n\n
  366.                                     contenutoBinario = null;    
  367.                                     binaryValue = false;
  368.                                     contenutiDefiniti--;
  369.                                 }
  370.                             }
  371.                             if(binaryValue){
  372.                                 contenutoBinarioFileName = protocolProperty.getFile();
  373.                             
  374.                                 if(driverBYOK!=null && isConfidentialProtocolProperty(protocolProperty.getName())) {
  375.                                     BYOKWrappedValue byokValue = driverBYOK.wrap(contenutoBinario);
  376.                                     if(byokValue!=null) {
  377.                                         contenutoBinario = byokValue.getWrappedValue().getBytes();
  378.                                     }
  379.                                 }
  380.                             }
  381.                         }
  382.                         
  383.                         /**if(!stringValue && !numberValue && !binaryValue && !booleanValue){
  384.                             throw new DriverRegistroServiziException("[DBProtocolProperties::CRUDProtocolProperty] Contenuto non definito per protocolProperty ["+protocolProperty.getName()+"]");
  385.                         }*/
  386.                         // Per fare i filtri con is null e' necessario registrarlo!
  387.                         if(contenutiDefiniti>1){
  388.                             throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] Contenuto definito con più tipologie per protocolProperty ["+protocolProperty.getName()+
  389.                                     "] (string:"+stringValue+" number:"+numberValue+" binary:"+binaryValue+")");
  390.                         }
  391.                         
  392.                                         
  393.                         /**if(doc.getId()<=0){*/
  394.                         // Rileggo sempre id, puo' essere diverso (es. importato tramite sincronizzazioni)
  395.                         protocolProperty.setId(DBUtils.getIdProtocolProperty(protocolProperty.getTipoProprietario(), idProprietario,protocolProperty.getName(), 
  396.                                 connection, 
  397.                                 tipoDatabase));
  398.                                             
  399.                         boolean ppGiaPresente = false;
  400.                         boolean ppDaAggiornare = false;
  401.                         if(protocolProperty.getId()>0){
  402.                             for(int j=0; j<oldLista.size(); j++){
  403.                                 ProtocolProperty old = oldLista.get(j);
  404.             
  405.                                 /**System.out.println("OLD["+old.getId().longValue()+"]==ATTUALE["+doc.getId().longValue()+"] ("+((doc.getId().longValue() == old.getId().longValue()))+")");*/
  406.                                 if(protocolProperty.getId().longValue() == old.getId().longValue()){        
  407.                                     ppGiaPresente = true; // non devo fare una insert, ma una update...
  408.                                             
  409.                                     // rimuovo la vecchia immagine del documento dalla lista dei doc vecchi
  410.                                     oldLista.remove(j);
  411.                                         
  412.                                     ppDaAggiornare = true;
  413.                                     break;
  414.                                 }
  415.                             }
  416.                         }
  417.     
  418.                         if(ppGiaPresente){
  419.                             if(ppDaAggiornare){
  420.                                 // update
  421.                                 long idPP = protocolProperty.getId();
  422.                                 if(idPP<=0){
  423.                                     throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] ID non definito per documento da aggiorare ["+protocolProperty.getName()+"]");
  424.                                 }
  425.                                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  426.                                 sqlQueryObject.addUpdateTable(CostantiDB.PROTOCOL_PROPERTIES);
  427.                                 sqlQueryObject.addUpdateField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING, "?");
  428.                                 sqlQueryObject.addUpdateField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING, "?");
  429.                                 sqlQueryObject.addUpdateField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER, "?");
  430.                                 sqlQueryObject.addUpdateField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN, "?");
  431.                                 sqlQueryObject.addUpdateField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY, "?");
  432.                                 sqlQueryObject.addUpdateField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_FILENAME, "?");
  433.                                 sqlQueryObject.addWhereCondition("id=?");
  434.                                 sqlQuery = sqlQueryObject.createSQLUpdate();
  435.                                 stm = connection.prepareStatement(sqlQuery);
  436.                                 int index = 1;
  437.                                 
  438.                                 stm.setString(index++, plainContenutoString);
  439.                                 stm.setString(index++, encContenutoString);
  440.                                 
  441.                                 if(numberValue){
  442.                                     stm.setLong(index++, contenutoNumber);
  443.                                 }
  444.                                 else{
  445.                                     stm.setNull(index++, java.sql.Types.BIGINT);
  446.                                 }
  447.                                 
  448.                                 if(booleanValue){
  449.                                     if(contenutoBoolean!=null && contenutoBoolean.booleanValue()){
  450.                                         stm.setInt(index++,CostantiDB.TRUE);
  451.                                     }
  452.                                     else{
  453.                                         stm.setInt(index++,CostantiDB.FALSE);
  454.                                     }
  455.                                 }
  456.                                 else{
  457.                                     stm.setNull(index++, java.sql.Types.INTEGER);
  458.                                 }
  459.                                 
  460.                                 jdbcAdapter.setBinaryData(stm,index++,contenutoBinario);
  461.                                 stm.setString(index++, contenutoBinarioFileName);
  462.                                 
  463.                                 stm.setLong(index++, idPP);
  464.                                 stm.executeUpdate();
  465.                                 stm.close();
  466.                             }
  467.                         }else{
  468.                             // create
  469.                             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  470.                             sqlQueryObject.addInsertTable(CostantiDB.PROTOCOL_PROPERTIES);
  471.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO, "?");
  472.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO, "?");
  473.                             sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME, "?");
  474.                             if(stringValue){
  475.                                 sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING, "?");
  476.                                 sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING, "?");
  477.                             }
  478.                             if(numberValue){
  479.                                 sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER, "?");
  480.                             }
  481.                             if(booleanValue){
  482.                                 sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN, "?");
  483.                             }
  484.                             if(binaryValue){
  485.                                 sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY, "?");
  486.                                 sqlQueryObject.addInsertField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_FILENAME, "?");
  487.                             }
  488.                             sqlQuery = sqlQueryObject.createSQLInsert();
  489.                             stm = connection.prepareStatement(sqlQuery);
  490.                             int index = 1;
  491.                             stm.setString(index++, tipologiaProprietarioProtocolProperty.name());
  492.                             stm.setLong(index++, idProprietario);
  493.                             stm.setString(index++, protocolProperty.getName());
  494.                             String debug = null;
  495.                             if(stringValue){
  496.                                 stm.setString(index++, plainContenutoString);
  497.                                 debug = plainContenutoString;
  498.                                 stm.setString(index++, encContenutoString);
  499.                             }
  500.                             if(numberValue){
  501.                                 stm.setLong(index++, contenutoNumber);
  502.                                 debug = contenutoNumber+"";
  503.                             }
  504.                             if(booleanValue){
  505.                                 if(contenutoBoolean!=null && contenutoBoolean.booleanValue()){
  506.                                     stm.setInt(index++,CostantiDB.TRUE);
  507.                                     debug = CostantiDB.TRUE+"";
  508.                                 }
  509.                                 else{
  510.                                     stm.setInt(index++,CostantiDB.FALSE);
  511.                                     debug = CostantiDB.FALSE+"";
  512.                                 }
  513.                             }
  514.                             if(binaryValue){
  515.                                 jdbcAdapter.setBinaryData(stm,index++,contenutoBinario);
  516.                                 debug = "BinaryData";
  517.                                 stm.setString(index++, contenutoBinarioFileName);
  518.                                 debug = debug + "," + contenutoBinarioFileName;
  519.                             }
  520.                             
  521.                             logDebug(log,"CRUDProtocolProperty CREATE : \n" + DBUtils.
  522.                                     formatSQLString(sqlQuery, tipologiaProprietarioProtocolProperty.name(), idProprietario, protocolProperty.getName(), debug));
  523.             
  524.                             int n = stm.executeUpdate();
  525.                             stm.close();
  526.                             logDebug(log,"Inserted " + n + " row(s)");
  527.                 
  528.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  529.                             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  530.                             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  531.                             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+" = ?");
  532.                             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+" = ?");
  533.                             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME+" = ?");
  534.                             sqlQueryObject.setANDLogicOperator(true);
  535.                             sqlQuery = sqlQueryObject.createSQLQuery();
  536.                             stm = connection.prepareStatement(sqlQuery);
  537.                             index = 1;
  538.                             stm.setString(index++, tipologiaProprietarioProtocolProperty.name());
  539.                             stm.setLong(index++, idProprietario);
  540.                             stm.setString(index++, protocolProperty.getName());
  541.             
  542.                             logDebug(log,"Recupero id inserito : \n" + DBUtils.
  543.                                     formatSQLString(sqlQuery, tipologiaProprietarioProtocolProperty.name(), idProprietario, protocolProperty.getName()));
  544.             
  545.                             rs = stm.executeQuery();
  546.             
  547.                             if (rs.next()) {
  548.                                 listPP.get(i).setId(rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID));
  549.                             } else {
  550.                                 throw new CoreException("[DBProtocolProperties::CRUDProtocolProperty] Errore avvenuto durante il recupero dell'id dopo una create");
  551.                             }
  552.             
  553.                             rs.close();
  554.                             stm.close();
  555.                             
  556.                         }
  557.                         
  558.                     }
  559.                 }
  560.                 
  561.                 if(!oldLista.isEmpty()){
  562.                     // Qualche documento e' stato cancellato.
  563.                     // Non e' piu' presente.
  564.                     for(int j=0; j<oldLista.size(); j++){
  565.                         ProtocolProperty old = oldLista.get(j);
  566.                         
  567.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  568.                         sqlQueryObject.addDeleteTable(CostantiDB.PROTOCOL_PROPERTIES);
  569.                         sqlQueryObject.addWhereCondition("id=?");
  570.                         sqlQuery = sqlQueryObject.createSQLDelete();
  571.                         stm = connection.prepareStatement(sqlQuery);
  572.                         stm.setLong(1, old.getId());
  573.                         stm.executeUpdate();
  574.                         stm.close();
  575.                     }
  576.                 }
  577.                 
  578.                 break;

  580.             case DELETE:
  581.                 // delete
  582.                 
  583.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  584.                 sqlQueryObject.addDeleteTable(CostantiDB.PROTOCOL_PROPERTIES);
  585.                 sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+" = ?");
  586.                 sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+"=?");
  587.                 sqlQueryObject.setANDLogicOperator(true);
  588.                 sqlQuery = sqlQueryObject.createSQLDelete();
  589.                 stm = connection.prepareStatement(sqlQuery);
  590.                 stm.setString(1, tipologiaProprietarioProtocolProperty.name());
  591.                 stm.setLong(2, idProprietario);
  592.                 stm.executeUpdate();
  593.                 stm.close();

  595.                 logDebug(log,"CRUDDocumento DELETE : \n" + DBUtils.formatSQLString(sqlQuery, tipologiaProprietarioProtocolProperty.name(), idProprietario));

  597.                 break;
  598.                 
  599.             default:
  600.                 // nop
  601.             }

  603.         } catch (SQLException se) {
  604.             throw new CoreException("[DBProtocolProperties::CRUDDocumento] SQLException : " + se.getMessage(),se);
  605.         }catch (Exception se) {
  606.             throw new CoreException("[DBProtocolProperties::CRUDDocumento] Exception : " + se.getMessage(),se);
  607.         } finally {
  608.             try {
  609.                 if(rs!=null) 
  610.                     rs.close();
  611.             } catch (Exception e) {
  612.                 // ignore
  613.             }
  614.             try {
  615.                 if(stm!=null) 
  616.                     stm.close();
  617.             } catch (Exception e) {
  618.                 // ignore
  619.             }
  620.         }
  621.     }
  622.     
  623.     public static List<org.openspcoop2.core.registry.ProtocolProperty> getListaProtocolPropertyRegistry(long idProprietario, ProprietariProtocolProperty tipologiaProprietario, 
  624.             Connection connection,
  625.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException,NotFoundException {
  626.         List<ProtocolProperty> l = getListaProtocolProperty(idProprietario, tipologiaProprietario, connection, tipoDatabase, driverBYOK);
  627.         List<org.openspcoop2.core.registry.ProtocolProperty> lPP = null;
  628.         if(l==null) {
  629.             return lPP;
  630.         }
  631.         lPP = new ArrayList<>();
  632.         if(!l.isEmpty()) {
  633.             for (ProtocolProperty protocolProperty : l) {
  634.                 lPP.add(protocolProperty.toRegistry());
  635.             }
  636.         }
  637.         return lPP;
  638.     }
  639.     public static List<org.openspcoop2.core.config.ProtocolProperty> getListaProtocolPropertyConfig(long idProprietario, ProprietariProtocolProperty tipologiaProprietario, 
  640.             Connection connection,
  641.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException,NotFoundException {
  642.         List<ProtocolProperty> l = getListaProtocolProperty(idProprietario, tipologiaProprietario, connection, tipoDatabase, driverBYOK);
  643.         List<org.openspcoop2.core.config.ProtocolProperty> lPP = null;
  644.         if(l==null) {
  645.             return lPP;
  646.         }
  647.         lPP = new ArrayList<>();
  648.         if(!l.isEmpty()) {
  649.             for (ProtocolProperty protocolProperty : l) {
  650.                 lPP.add(protocolProperty.toConfig());
  651.             }
  652.         }
  653.         return lPP;
  654.     }
  655.     
  656.     public static List<ProtocolProperty> getListaProtocolPropertySafe(long idProprietario, ProprietariProtocolProperty tipologiaProprietario, 
  657.             Connection connection,
  658.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException  {
  659.         List<ProtocolProperty> l = null;
  660.         try{
  661.             l = getListaProtocolProperty(idProprietario,tipologiaProprietario, connection, tipoDatabase, driverBYOK);
  662.         }catch(NotFoundException dNotFound){
  663.             l = new ArrayList<>();
  664.         }
  665.         return l;
  666.     }
  667.     public static List<ProtocolProperty> getListaProtocolProperty(long idProprietario, ProprietariProtocolProperty tipologiaProprietario, 
  668.             Connection connection,
  669.             String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException,NotFoundException {
  670.         
  671.         PreparedStatement stm = null;
  672.         ResultSet rs=null;
  673.         String sqlQuery;

  675.         if(idProprietario <= 0 ) 
  676.             throw new CoreException("[DBProtocolProperties::getListaProtocolProperty] id proprietario non definito");
  677.         
  678.         try {
  679.         
  680.             List<ProtocolProperty> listPP = new ArrayList<>();
  681.             
  682.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  683.             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  684.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  685.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+" = ?");
  686.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+" = ?");
  687.             sqlQueryObject.setANDLogicOperator(true);
  688.             sqlQuery = sqlQueryObject.createSQLQuery();
  689.             stm = connection.prepareStatement(sqlQuery);
  690.             stm.setString(1, tipologiaProprietario.name());
  691.             stm.setLong(2, idProprietario);
  692.             rs = stm.executeQuery();
  693.             
  694.             while(rs.next()){
  695.                 ProtocolProperty pp = getProtocolProperty(rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID), connection,tipoDatabase, driverBYOK); 
  696.                 listPP.add(pp);
  697.             }
  698.             
  699.             if(listPP.isEmpty())
  700.                 throw new NotFoundException("ProtocolProperty con tipologiaProprietario["+tipologiaProprietario.name()+
  701.                         "] e idProprietario["+idProprietario+"] non trovati");
  702.             
  703.             return listPP;

  705.         } catch (SQLException se) {
  706.             throw new CoreException("[DBProtocolProperties::getListaProtocolProperty] SQLException : " + se.getMessage(),se);
  707.         }catch (NotFoundException dnf) {
  708.             throw dnf;
  709.         }catch (Exception se) {
  710.             throw new CoreException("[DBProtocolProperties::getListaProtocolProperty] Exception : " + se.getMessage(),se);
  711.         } finally {
  712.             try {
  713.                 if(rs!=null) 
  714.                     rs.close();
  715.             } catch (Exception e) {
  716.                 // ignore
  717.             }
  718.             try {
  719.                 if(stm!=null) 
  720.                     stm.close();
  721.             } catch (Exception e) {
  722.                 // ignore
  723.             }
  724.         }
  725.     }
  726.     
  727.     public static org.openspcoop2.core.registry.ProtocolProperty getProtocolPropertyRegistry(long id, Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException,NotFoundException {
  728.         ProtocolProperty pp = getProtocolProperty(id, connection, tipoDatabase, driverBYOK);
  729.         if(pp==null) {
  730.             return null;
  731.         }
  732.         return pp.toRegistry();
  733.     }
  734.     public static org.openspcoop2.core.config.ProtocolProperty getProtocolPropertyConfig(long id, Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException,NotFoundException {
  735.         ProtocolProperty pp = getProtocolProperty(id, connection, tipoDatabase, driverBYOK);
  736.         if(pp==null) {
  737.             return null;
  738.         }
  739.         return pp.toConfig();
  740.     }
  741.     public static ProtocolProperty getProtocolProperty(long id, Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException,NotFoundException {
  742.         
  743.         PreparedStatement stm = null;
  744.         ResultSet rs=null;
  745.         String sqlQuery;

  747.         if(id <= 0 ) 
  748.             throw new CoreException("[DBProtocolProperties::getProtocolProperty] id non definito");
  749.         
  750.         try {
  751.         
  752.             IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(tipoDatabase);
  753.                 
  754.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  755.             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  756.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO);
  757.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO);
  758.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME);
  759.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING);
  760.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING);
  761.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER);
  762.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN);
  763.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY);
  764.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_FILENAME);
  765.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  766.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID+" = ?");
  767.             sqlQueryObject.setANDLogicOperator(true);
  768.             sqlQuery = sqlQueryObject.createSQLQuery();
  769.             stm = connection.prepareStatement(sqlQuery);
  770.             stm.setLong(1, id);
  771.             rs = stm.executeQuery();
  772.             
  773.             ProtocolProperty pp = null;
  774.             if(rs.next()){
  775.                 pp = new ProtocolProperty();
  776.                 pp.setTipoProprietario(rs.getString(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO));
  777.                 pp.setIdProprietario(rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO));
  778.                 
  779.                 String ppName = rs.getString(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME);
  780.                 pp.setName(ppName);
  781.                 
  782.                 String plainStringValue = rs.getString(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING);
  783.                 String encStringValue = rs.getString(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING);
  784.                 if(encStringValue!=null && StringUtils.isNotEmpty(encStringValue)) {
  785.                     if(driverBYOK!=null) {
  786.                         pp.setValue(driverBYOK.unwrapAsString(encStringValue));
  787.                     }
  788.                     else {
  789.                         pp.setValue(encStringValue);
  790.                     }
  791.                 }
  792.                 else {
  793.                     pp.setValue(plainStringValue);
  794.                 }
  795.                 
  796.                 pp.setNumberValue(rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER));
  797.                 if(rs.wasNull()){
  798.                     pp.setNumberValue(null);
  799.                 }
  800.                 int value = rs.getInt(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN);
  801.                 pp.setBooleanValue(value == CostantiDB.TRUE);
  802.                 if(rs.wasNull()){
  803.                     pp.setBooleanValue(null);
  804.                 }
  805.                 
  806.                 byte[]binaryValue = jdbcAdapter.getBinaryData(rs,CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY);
  807.                 if(binaryValue!=null && binaryValue.length>0 && driverBYOK!=null && isConfidentialProtocolProperty(ppName)) {
  808.                     binaryValue = driverBYOK.unwrap(binaryValue);
  809.                 }
  810.                 pp.setByteFile(binaryValue);
  811.                 
  812.                 pp.setFile(rs.getString(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_FILENAME));
  813.                 pp.setId(rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID));
  814.             }
  815.             
  816.             if(pp==null)
  817.                 throw new NotFoundException("ProtocolProperty con id["+id+"] non trovato");
  818.             
  819.             return pp;

  821.         } catch (SQLException se) {
  822.             throw new CoreException("[DBProtocolProperties::getProtocolProperty] SQLException : " + se.getMessage(),se);
  823.         }catch (NotFoundException dnf) {
  824.             throw dnf;
  825.         }catch (Exception se) {
  826.             throw new CoreException("[DBProtocolProperties::getProtocolProperty] Exception : " + se.getMessage(),se);
  827.         } finally {
  828.             try {
  829.                 if(rs!=null) 
  830.                     rs.close();
  831.             } catch (Exception e) {
  832.                 // ignore
  833.             }
  834.             try {
  835.                 if(stm!=null) 
  836.                     stm.close();
  837.             } catch (Exception e) {
  838.                 // ignore
  839.             }
  840.         }
  841.     }
  842.     
  843.     
  844.     
  845.     
  846.     
  847.     public static boolean existsProtocolProperty(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome,
  848.             Connection connection, String tipoDatabase) throws CoreException {

  850.         boolean exist = false;
  851.         PreparedStatement stm = null;
  852.         ResultSet rs = null;

  854.         try {
  855.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  856.             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  857.             sqlQueryObject.addSelectField(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  858.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+" = ?");
  859.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+" = ?");
  860.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME+" = ?");
  861.             sqlQueryObject.setANDLogicOperator(true);
  862.             String sqlQuery = sqlQueryObject.createSQLQuery();
  863.             stm = connection.prepareStatement(sqlQuery);
  864.             stm.setString(1, proprietarioProtocolProperty.name());
  865.             stm.setLong(2, idProprietario);
  866.             stm.setString(3, nome);
  867.             rs = stm.executeQuery();
  868.             if (rs.next())
  869.                 exist = true;
  870.             rs.close();
  871.             stm.close();
  872.         } catch (Exception e) {
  873.             exist = false;
  874.             throw new CoreException(e.getMessage(),e);
  875.         } finally {

  877.             //Chiudo statement and resultset
  878.             try {
  879.                 if(rs!=null) 
  880.                     rs.close();
  881.             } catch (Exception e) {
  882.                 // ignore
  883.             }
  884.             try {
  885.                 if(stm!=null) 
  886.                     stm.close();
  887.             } catch (Exception e) {
  888.                 // ignore
  889.             }

  891.         }

  893.         return exist;
  894.     }

  896.     public static org.openspcoop2.core.registry.ProtocolProperty getProtocolPropertyRegistry(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome,
  897.             Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException {
  898.         ProtocolProperty pp = getProtocolProperty(proprietarioProtocolProperty, idProprietario, nome, connection, tipoDatabase, driverBYOK);
  899.         if(pp==null) {
  900.             return null;
  901.         }
  902.         return pp.toRegistry();
  903.     }
  904.     public static org.openspcoop2.core.config.ProtocolProperty getProtocolPropertyConfig(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome,
  905.             Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException {
  906.         ProtocolProperty pp = getProtocolProperty(proprietarioProtocolProperty, idProprietario, nome, connection, tipoDatabase, driverBYOK);
  907.         if(pp==null) {
  908.             return null;
  909.         }
  910.         return pp.toConfig();
  911.     }
  912.     public static ProtocolProperty getProtocolProperty(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome,
  913.             Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws CoreException {
  914.         String nomeMetodo = "getProtocolProperty";
  915.         try {
  916.             long idPP = DBUtils.getIdProtocolProperty(proprietarioProtocolProperty.name(),idProprietario,nome,connection,tipoDatabase);
  917.             return getProtocolProperty(idPP, connection, tipoDatabase, driverBYOK);

  919.         } catch (Exception se) {
  920.             throw new CoreException("[DriverRegistroServiziException::" + nomeMetodo + "] Exception: " + se.getMessage());
  921.         }
  922.     }
  923.     
  924.     
  925.     private static final String AND_SEPARATOR = " AND ";
  926.     private static final String IS_NULL_CONDITION = "is null";
  927.     public static void setProtocolPropertiesForSearch(ISQLQueryObject sqlQueryObject, List<FiltroRicercaProtocolProperty> list, String tabella) throws SQLQueryObjectException{
  928.         if(list!=null && !list.isEmpty()){
  929.             String [] conditions = new String[list.size()];
  930.             for (int i = 0; i < conditions.length; i++) {
  931.                 String aliasTabella = "pp"+i+tabella;
  932.                 sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES, aliasTabella);
  933.                 sqlQueryObject.setANDLogicOperator(true);
  934.                 sqlQueryObject.addWhereCondition(aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+"=?");
  935.                 sqlQueryObject.addWhereCondition(aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+"="+tabella+".id");
  936.                 FiltroRicercaProtocolProperty f = list.get(i);
  937.                                 
  938.                 if(f.getName()!=null){
  939.                     if(conditions[i]!=null){
  940.                         conditions[i] = conditions[i] + AND_SEPARATOR;
  941.                     }
  942.                     else {
  943.                         conditions[i] = "";
  944.                     }
  945.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME+"=?";
  946.                 }
  947.                 
  948.                 if(f.getValueAsString()!=null){
  949.                     if(conditions[i]!=null){
  950.                         conditions[i] = conditions[i] + AND_SEPARATOR;
  951.                     }
  952.                     else {
  953.                         conditions[i] = "";
  954.                     }
  955.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING+"=?";
  956.                 }
  957.                 else if(f.getValueAsLong()!=null){
  958.                     if(conditions[i]!=null){
  959.                         conditions[i] = conditions[i] + AND_SEPARATOR;
  960.                     }
  961.                     else {
  962.                         conditions[i] = "";
  963.                     }
  964.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER+"=?";
  965.                 }
  966.                 else if(f.getValueAsBoolean()!=null){
  967.                     if(conditions[i]!=null){
  968.                         conditions[i] = conditions[i] + AND_SEPARATOR;
  969.                     }
  970.                     else {
  971.                         conditions[i] = "";
  972.                     }
  973.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN+"=?";
  974.                 }
  975.                 else {
  976.                     if(conditions[i]!=null){
  977.                         conditions[i] = conditions[i] + AND_SEPARATOR;
  978.                     }
  979.                     else {
  980.                         conditions[i] = "";
  981.                     }
  982.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING+" "+IS_NULL_CONDITION;
  983.                     conditions[i] = conditions[i] + AND_SEPARATOR;
  984.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_NUMBER+" "+IS_NULL_CONDITION;
  985.                     conditions[i] = conditions[i] + AND_SEPARATOR;
  986.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BOOLEAN+" "+IS_NULL_CONDITION;
  987.                 }
  988.                 
  989.                 // casoSpecialeValoreNull
  990.                 ISQLQueryObject sqlQueryObjectPropertyNotExists = null;
  991.                 // in un caso dove il valore non e' definito nel database ci possono essere due casistiche:
  992.                 // 1) Passando via govwayConsole, la proprieta' esiste con il nome ('name') ed e' valorizzata null in tutte le colonne (value_string,value_number,value_boolean)
  993.                 // 2) Passando via govwayLoader, in una configurazione xml, non si definisce la proprietà senza il valore, quindi la riga con il nome non esistera proprio nel db.
  994.                 if(f.getValueAsString()==null && f.getValueAsLong()==null && f.getValueAsBoolean()==null){
  995.                     
  996.                     ISQLQueryObject sqlQueryObjectPropertyNotExistsInternal = sqlQueryObject.newSQLQueryObject();
  997.                     String aliasTabellaNotExists =  "not_exists_"+aliasTabella;
  998.                     sqlQueryObjectPropertyNotExistsInternal.addFromTable(CostantiDB.PROTOCOL_PROPERTIES, aliasTabellaNotExists);
  999.                     sqlQueryObjectPropertyNotExistsInternal.addSelectField(aliasTabellaNotExists, CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  1000.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO+"="+aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO);
  1001.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO+"="+aliasTabella+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO);
  1002.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME+"=?");
  1003.                     sqlQueryObjectPropertyNotExistsInternal.setANDLogicOperator(true);
  1004.                     
  1005.                     sqlQueryObjectPropertyNotExists = sqlQueryObject.newSQLQueryObject();
  1006.                     sqlQueryObjectPropertyNotExists.addWhereExistsCondition(true, sqlQueryObjectPropertyNotExistsInternal);

  1008.                     conditions[i] = "( " + conditions[i] + " ) OR ( " + sqlQueryObjectPropertyNotExists.createSQLConditions() + " )";
  1009.                 }
  1010.             }
  1011.             sqlQueryObject.addWhereCondition(true, conditions);
  1012.         }
  1013.     }
  1014.     
  1015.     public static void setProtocolPropertiesForSearch(PreparedStatement stmt, int index, 
  1016.             List<FiltroRicercaProtocolProperty> list, ProprietariProtocolProperty proprietario,
  1017.             String tipoDatabase, Logger log) throws SQLQueryObjectException, SQLException, JDBCAdapterException, UtilsException{
  1018.         
  1019.         JDBCParameterUtilities jdbcParameterUtilities = new JDBCParameterUtilities(TipiDatabase.toEnumConstant(tipoDatabase));
  1020.         
  1021.         if(list!=null && !list.isEmpty()){
  1022.             for (int i = 0; i < list.size(); i++) {
  1023.                 
  1024.                 logDebug(log,"FiltroRicercaProtocolProperty size:"+list.size()+" ["+i+"] Proprietario stmt.setString("+proprietario.name()+")");
  1025.                 stmt.setString(index++, proprietario.name());
  1026.                 
  1027.             }
  1028.             for (int i = 0; i < list.size(); i++) {
  1029.                 
  1030.                 String prefix = "FiltroRicercaProtocolProperty["+i+"] ";
  1031.                 
  1032.                 FiltroRicercaProtocolProperty f = list.get(i);
  1033.                 if(f.getName()!=null){
  1034.                     logDebug(log,prefix+"Name stmt.setString("+f.getName()+")");
  1035.                     stmt.setString(index++, f.getName());
  1036.                 }
  1037.                 
  1038.                 if(f.getValueAsString()!=null){
  1039.                     logDebug(log,prefix+"ValueAsString stmt.setString("+f.getValueAsString()+")");
  1040.                     jdbcParameterUtilities.setParameter(stmt, index++, f.getValueAsString(), String.class);
  1041.                 }
  1042.                 else if(f.getValueAsLong()!=null){
  1043.                     logDebug(log,prefix+"ValueAsLong stmt.setLong("+f.getValueAsLong()+")");
  1044.                     jdbcParameterUtilities.setParameter(stmt, index++, f.getValueAsLong(), Long.class);
  1045.                 }
  1046.                 else if(f.getValueAsBoolean()!=null){
  1047.                     int value = f.getValueAsBoolean()!=null && f.getValueAsBoolean().booleanValue() ? CostantiDB.TRUE : CostantiDB.FALSE;
  1048.                     logDebug(log,prefix+"ValueAsBoolean stmt.setInt("+value+")");
  1049.                     jdbcParameterUtilities.setParameter(stmt, index++, value, Integer.class);
  1050.                 }
  1051.                 
  1052.                 // casoSpecialeValoreNull
  1053.                 // in un caso dove il valore non e' definito nel database ci possono essere due casistiche:
  1054.                 // 1) Passando via govwayConsole, la proprieta' esiste con il nome ('name') ed e' valorizzata null in tutte le colonne (value_string,value_number,value_boolean)
  1055.                 // 2) Passando via govwayLoader, in una configurazione xml, non si definisce la proprietà senza il valore, quindi la riga con il nome non esistera proprio nel db.
  1056.                 if(f.getValueAsString()==null && f.getValueAsLong()==null && f.getValueAsBoolean()==null){
  1057.                     logDebug(log,prefix+"Name stmt.setString("+f.getName()+")");
  1058.                     stmt.setString(index++, f.getName());
  1059.                 }
  1060.             }
  1061.         }
  1062.     }
  1063. }
Created with JaCoCo 0.8.8.202204050719