DriverRegistroServiziDB_LIB.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.  */



  23. package org.openspcoop2.core.registry.driver.db;

  25. import static org.openspcoop2.core.constants.CostantiDB.CREATE;
  26. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  27. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  29. import java.sql.Connection;
  30. import java.sql.PreparedStatement;
  31. import java.sql.ResultSet;
  32. import java.sql.SQLException;
  33. import java.sql.Timestamp;
  34. import java.text.MessageFormat;
  35. import java.util.List;

  37. import org.openspcoop2.core.byok.IDriverBYOK;
  38. import org.openspcoop2.core.commons.CoreException;
  39. import org.openspcoop2.core.commons.DBUtils;
  40. import org.openspcoop2.core.constants.CostantiDB;
  41. import org.openspcoop2.core.id.IDGruppo;
  42. import org.openspcoop2.core.id.IDRuolo;
  43. import org.openspcoop2.core.id.IDScope;
  44. import org.openspcoop2.core.mapping.DBProtocolPropertiesUtils;
  45. import org.openspcoop2.core.registry.Gruppo;
  46. import org.openspcoop2.core.registry.ProtocolProperty;
  47. import org.openspcoop2.core.registry.Ruolo;
  48. import org.openspcoop2.core.registry.Scope;
  49. import org.openspcoop2.core.registry.constants.BindingStyle;
  50. import org.openspcoop2.core.registry.constants.BindingUse;
  51. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  52. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  53. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  54. import org.openspcoop2.core.registry.constants.HttpMethod;
  55. import org.openspcoop2.core.registry.constants.MessageType;
  56. import org.openspcoop2.core.registry.constants.ParameterType;
  57. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  58. import org.openspcoop2.core.registry.constants.RepresentationType;
  59. import org.openspcoop2.core.registry.constants.RepresentationXmlType;
  60. import org.openspcoop2.core.registry.constants.RuoloContesto;
  61. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  62. import org.openspcoop2.core.registry.constants.ScopeContesto;
  63. import org.openspcoop2.core.registry.constants.ServiceBinding;
  64. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  65. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  66. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  67. import org.openspcoop2.generic_project.exception.NotFoundException;
  68. import org.openspcoop2.utils.LoggerWrapperFactory;
  69. import org.openspcoop2.utils.date.DateManager;
  70. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  71. import org.openspcoop2.utils.sql.ISQLQueryObject;
  72. import org.openspcoop2.utils.sql.SQLObjectFactory;
  73. import org.slf4j.Logger;

  75. /**
  76.  * Classe utilizzata per effettuare query ad un registro dei servizi openspcoop
  77.  * formato db.
  78.  * 
  79.  * 
  80.  * @author Sandra Giangrandi (sandra@link.it)
  81.  * @author Stefano Corallo (corallo@link.it)
  82.  * @author $Author$
  83.  * @version $Rev$, $Date$
  84.  */
  85. public class DriverRegistroServiziDB_LIB {

  87.     /** Logger utilizzato per debug. */
  88.     public static org.slf4j.Logger log = LoggerWrapperFactory.getLogger(CostantiRegistroServizi.REGISTRO_DRIVER_DB_LOGGER);
  89.     
  90.     static void logDebug(String msg) {
  91.         if(log!=null) {
  92.             log.debug(msg);
  93.         }
  94.     }
  95.     static void logDebug(String msg, Exception e) {
  96.         if(log!=null) {
  97.             log.debug(msg,e);
  98.         }
  99.     }
  100.     
  101.     static void logError(String msg) {
  102.         if(log!=null) {
  103.             log.error(msg);
  104.         }
  105.     }
  106.     static void logError(String msg, Exception e) {
  107.         if(log!=null) {
  108.             log.error(msg,e);
  109.         }
  110.     }

  112.     // Tipo database ereditato da DriverRegistroServiziDB
  113.     static String tipoDB = null;

  115.     /** Log ereditato da DriverRegistroServiziDB
  116.      */
  117.     private static boolean initialize = false;
  118.     public static void initStaticLogger(Logger aLog){
  119.         if(!DriverRegistroServiziDB_LIB.initialize){
  120.             if(aLog!=null){
  121.                 DriverRegistroServiziDB_LIB.log = aLog;
  122.             }
  123.             DriverRegistroServiziDB_LIB.initialize = true;
  124.         }
  125.     }
  126.     public static boolean isStaticLoggerInitialized(){
  127.         return DriverRegistroServiziDB_LIB.initialize;
  128.     }

  130.     // Setto il tipoDB
  131.     public static void setTipoDB(String tipoDatabase) {
  132.         DriverRegistroServiziDB_LIB.tipoDB = tipoDatabase;
  133.     }
  134.     
  135.     public static String getValue(StatoFunzionalita funzionalita){
  136.         if(funzionalita==null){
  137.             return null;
  138.         }
  139.         else{
  140.             return funzionalita.getValue();
  141.         }
  142.     }
  143.     public static String getValue(ProfiloCollaborazione profilo){
  144.         if(profilo==null){
  145.             return null;
  146.         }
  147.         else{
  148.             return profilo.getValue();
  149.         }
  150.     }
  151.     public static String getValue(BindingStyle style){
  152.         if(style==null){
  153.             return null;
  154.         }
  155.         else{
  156.             return style.getValue();
  157.         }
  158.     }
  159.     public static String getValue(BindingUse use){
  160.         if(use==null){
  161.             return null;
  162.         }
  163.         else{
  164.             return use.getValue();
  165.         }
  166.     }
  167.     public static String getValue(CredenzialeTipo tipo){
  168.         if(tipo==null){
  169.             return null;
  170.         }
  171.         else{
  172.             return tipo.getValue();
  173.         }
  174.     }
  175.     public static String getValue(ServiceBinding tipo){
  176.         if(tipo==null){
  177.             return null;
  178.         }
  179.         else{
  180.             return tipo.getValue();
  181.         }
  182.     }
  183.     public static String getValue(MessageType tipo){
  184.         if(tipo==null){
  185.             return null;
  186.         }
  187.         else{
  188.             return tipo.getValue();
  189.         }
  190.     }
  191.     public static String getValue(HttpMethod tipo){
  192.         if(tipo==null){
  193.             return CostantiDB.API_RESOURCE_HTTP_METHOD_ALL_VALUE;
  194.         }
  195.         else{
  196.             return tipo.getValue();
  197.         }
  198.     }
  199.     public static String getValue(FormatoSpecifica tipo){
  200.         if(tipo==null){
  201.             return null;
  202.         }
  203.         else{
  204.             return tipo.getValue();
  205.         }
  206.     }
  207.     public static String getValue(RepresentationType tipo){
  208.         if(tipo==null){
  209.             return null;
  210.         }
  211.         else{
  212.             return tipo.getValue();
  213.         }
  214.     }
  215.     public static String getValue(RepresentationXmlType tipo){
  216.         if(tipo==null){
  217.             return null;
  218.         }
  219.         else{
  220.             return tipo.getValue();
  221.         }
  222.     }
  223.     public static String getValue(ParameterType tipo){
  224.         if(tipo==null){
  225.             return null;
  226.         }
  227.         else{
  228.             return tipo.getValue();
  229.         }
  230.     }
  231.     
  232.     public static StatoFunzionalita getEnumStatoFunzionalita(String value){
  233.         if(value==null){
  234.             return null;
  235.         }
  236.         else{
  237.             return StatoFunzionalita.toEnumConstant(value);
  238.         }
  239.     }
  240.     public static ProfiloCollaborazione getEnumProfiloCollaborazione(String value){
  241.         if(value==null){
  242.             return null;
  243.         }
  244.         else{
  245.             return ProfiloCollaborazione.toEnumConstant(value);
  246.         }
  247.     }
  248.     public static BindingStyle getEnumBindingStyle(String value){
  249.         if(value==null){
  250.             return null;
  251.         }
  252.         else{
  253.             return BindingStyle.toEnumConstant(value);
  254.         }
  255.     }
  256.     public static BindingUse getEnumBindingUse(String value){
  257.         if(value==null){
  258.             return null;
  259.         }
  260.         else{
  261.             return BindingUse.toEnumConstant(value);
  262.         }
  263.     }
  264.     public static CredenzialeTipo getEnumCredenzialeTipo(String value){
  265.         if(value==null){
  266.             return null;
  267.         }
  268.         else{
  269.             return CredenzialeTipo.toEnumConstant(value);
  270.         }
  271.     }
  272.     public static ServiceBinding getEnumServiceBinding(String value){
  273.         if(value==null){
  274.             return null;
  275.         }
  276.         else{
  277.             return ServiceBinding.toEnumConstant(value);
  278.         }
  279.     }
  280.     public static MessageType getEnumMessageType(String value){
  281.         if(value==null){
  282.             return null;
  283.         }
  284.         else{
  285.             return MessageType.toEnumConstant(value);
  286.         }
  287.     }
  288.     public static HttpMethod getEnumHttpMethod(String value){
  289.         if(value==null || CostantiDB.API_RESOURCE_HTTP_METHOD_ALL_VALUE.equalsIgnoreCase(value)){
  290.             return null;
  291.         }
  292.         else{
  293.             return HttpMethod.toEnumConstant(value);
  294.         }
  295.     }
  296.     public static FormatoSpecifica getEnumFormatoSpecifica(String value){
  297.         if(value==null){
  298.             return null;
  299.         }
  300.         else{
  301.             return FormatoSpecifica.toEnumConstant(value);
  302.         }
  303.     }
  304.     public static RepresentationType getEnumRepresentationType(String value){
  305.         if(value==null){
  306.             return null;
  307.         }
  308.         else{
  309.             return RepresentationType.toEnumConstant(value);
  310.         }
  311.     }
  312.     public static RepresentationXmlType getEnumRepresentationXmlType(String value){
  313.         if(value==null){
  314.             return null;
  315.         }
  316.         else{
  317.             return RepresentationXmlType.toEnumConstant(value);
  318.         }
  319.     }
  320.     public static ParameterType getEnumParameterType(String value){
  321.         if(value==null){
  322.             return null;
  323.         }
  324.         else{
  325.             return ParameterType.toEnumConstant(value);
  326.         }
  327.     }


  330.     /**
  331.      * Utility per formattare la string sql con i parametri passati, e stamparla
  332.      * per debug
  333.      * 
  334.      * @param sql
  335.      *            la string sql utilizzata nel prepared statement
  336.      * @param params
  337.      *            i parametri da inserire nella stringa che sostituiranno i '?'
  338.      * @return La stringa sql con al posto dei '?' ha i parametri passati
  339.      */
  340.     public static String formatSQLString(String sql, Object... params) {
  341.         String res = sql;

  343.         for (int i = 0; i < params.length; i++) {
  344.             res = res.replaceFirst("\\?", "{" + i + "}");
  345.         }

  347.         return MessageFormat.format(res, params);

  349.     }

  351.     
  352.     
  353.     public static void CRUDGruppo(int type, Gruppo gruppo, Connection con)
  354.             throws DriverRegistroServiziException {
  355.         if (gruppo == null) {
  356.             throw new DriverRegistroServiziException(
  357.             "[DriverRegistroServiziDB_LIB::CRUDGruppo] Parametro non valido.");
  358.         }

  360.         /**if ((type != CostantiDB.CREATE) && (pdd.getId() <= 0)) {
  361.             throw new DriverRegistroServiziException(
  362.             "[DriverRegistroServiziDB_LIB::CRUDGruppo] ID Gruppo non valido.");
  363.         }*/

  365.         String nome = gruppo.getNome();
  366.         String descrizione = gruppo.getDescrizione();
  367.         ServiceBinding serviceBinding = gruppo.getServiceBinding();

  369.         String superuser = gruppo.getSuperUser();

  371.         PreparedStatement updateStmt = null;
  372.         String updateQuery = "";
  373.         PreparedStatement selectStmt = null;
  374.         String selectQuery = "";
  375.         ResultSet selectRS = null;
  376.         int n = 0;

  378.         try {

  380.             // preparo lo statement in base al tipo di operazione
  381.             switch (type) {
  382.             case CREATE:
  383.                 // CREATE
  384.                 
  385.                 String utenteRichiedente = null;
  386.                 if(gruppo.getProprietaOggetto()!=null && gruppo.getProprietaOggetto().getUtenteRichiedente()!=null) {
  387.                     utenteRichiedente = gruppo.getProprietaOggetto().getUtenteRichiedente();
  388.                 }
  389.                 else {
  390.                     utenteRichiedente = superuser;
  391.                 }
  392.                 
  393.                 Timestamp dataCreazione = null;
  394.                 if(gruppo.getProprietaOggetto()!=null && gruppo.getProprietaOggetto().getDataCreazione()!=null) {
  395.                     dataCreazione = new Timestamp(gruppo.getProprietaOggetto().getDataCreazione().getTime());
  396.                 }
  397.                 else if(gruppo.getOraRegistrazione()!=null){
  398.                     dataCreazione = new Timestamp(gruppo.getOraRegistrazione().getTime());
  399.                 }
  400.                 else {
  401.                     dataCreazione = DateManager.getTimestamp();
  402.                 }
  403.                 
  404.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  405.                 sqlQueryObject.addInsertTable(CostantiDB.GRUPPI);
  406.                 sqlQueryObject.addInsertField("nome", "?");
  407.                 sqlQueryObject.addInsertField("descrizione", "?");
  408.                 sqlQueryObject.addInsertField("service_binding", "?");
  409.                 sqlQueryObject.addInsertField("superuser", "?");
  410.                 if(gruppo.getOraRegistrazione()!=null)
  411.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  412.                 if(utenteRichiedente!=null) {
  413.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  414.                 }
  415.                 if(dataCreazione!=null) {
  416.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  417.                 }

  419.                 updateQuery = sqlQueryObject.createSQLInsert();
  420.                 updateStmt = con.prepareStatement(updateQuery);

  422.                 int index = 1;
  423.                 updateStmt.setString(index++, nome);
  424.                 updateStmt.setString(index++, descrizione);
  425.                 updateStmt.setString(index++, serviceBinding!=null? serviceBinding.getValue() : null);
  426.                 updateStmt.setString(index++, superuser);
  427.                 
  428.                 if(gruppo.getOraRegistrazione()!=null)
  429.                     updateStmt.setTimestamp(index++, new Timestamp(gruppo.getOraRegistrazione().getTime()));
  430.                 
  431.                 if(utenteRichiedente!=null) {
  432.                     updateStmt.setString(index++, utenteRichiedente);
  433.                 }
  434.                 
  435.                 if(dataCreazione!=null) {
  436.                     updateStmt.setTimestamp(index++, dataCreazione);
  437.                 }

  439.                 // eseguo lo statement
  440.                 n = updateStmt.executeUpdate();

  442.                 updateStmt.close();

  444.                 DriverRegistroServiziDB_LIB.logDebug("CRUDGruppo type = " + type
  445.                         + " row affected =" + n);

  447.                 DriverRegistroServiziDB_LIB.logDebug("CRUDGruppo CREATE : \n"
  448.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  449.                                 updateQuery, nome, descrizione,(serviceBinding!=null? serviceBinding.getValue() : null),
  450.                                 superuser));

  452.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  453.                 sqlQueryObject.addFromTable(CostantiDB.GRUPPI);
  454.                 sqlQueryObject.addSelectField("id");
  455.                 sqlQueryObject.addWhereCondition("nome = ?");
  456.                 selectQuery = sqlQueryObject.createSQLQuery();
  457.                 selectStmt = con.prepareStatement(selectQuery);
  458.                 selectStmt.setString(1, nome);

  460.                 selectRS = selectStmt.executeQuery();
  461.                 if (selectRS.next()) {
  462.                     gruppo.setId(selectRS.getLong("id"));
  463.                 }
  464.                 selectRS.close();
  465.                 selectStmt.close();
  466.                 break;

  468.             case UPDATE:
  469.                 // UPDATE1

  471.                 String nomeGruppo = gruppo.getOldIDGruppoForUpdate()!=null ? gruppo.getOldIDGruppoForUpdate().getNome() : null;
  472.                 if(nomeGruppo==null || "".equals(nomeGruppo))
  473.                     nomeGruppo = gruppo.getNome();
  474.                 
  475.                 IDGruppo idG = new IDGruppo(nomeGruppo);
  476.                 long idGruppo = DBUtils.getIdGruppo(idG, con, DriverRegistroServiziDB_LIB.tipoDB);
  477.                 if (idGruppo <= 0)
  478.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDGruppo(UPDATE)] Id Gruppo non valido.");
  479.                 
  480.                 String utenteUltimaModifica = null;
  481.                 if(gruppo.getProprietaOggetto()!=null && gruppo.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  482.                     utenteUltimaModifica = gruppo.getProprietaOggetto().getUtenteUltimaModifica();
  483.                 }
  484.                 else {
  485.                     utenteUltimaModifica = superuser;
  486.                 }
  487.                 
  488.                 Timestamp dataUltimaModifica = null;
  489.                 if(gruppo.getProprietaOggetto()!=null && gruppo.getProprietaOggetto().getDataUltimaModifica()!=null) {
  490.                     dataUltimaModifica = new Timestamp(gruppo.getProprietaOggetto().getDataUltimaModifica().getTime());
  491.                 }
  492.                 else {
  493.                     dataUltimaModifica = DateManager.getTimestamp();
  494.                 }
  495.                 
  496.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  497.                 sqlQueryObject.addUpdateTable(CostantiDB.GRUPPI);
  498.                 sqlQueryObject.addUpdateField("nome", "?");
  499.                 sqlQueryObject.addUpdateField("descrizione", "?");
  500.                 sqlQueryObject.addUpdateField("service_binding", "?");
  501.                 sqlQueryObject.addUpdateField("superuser", "?");
  502.                 if(gruppo.getOraRegistrazione()!=null)
  503.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  504.                 if(utenteUltimaModifica!=null) {
  505.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  506.                 }
  507.                 if(dataUltimaModifica!=null) {
  508.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  509.                 }
  510.                 
  511.                 sqlQueryObject.addWhereCondition("id=?");
  512.                 updateQuery = sqlQueryObject.createSQLUpdate();
  513.                 updateStmt = con.prepareStatement(updateQuery);

  515.                 index = 1;
  516.                 updateStmt.setString(index++, nome);
  517.                 updateStmt.setString(index++, descrizione);
  518.                 updateStmt.setString(index++, serviceBinding!=null? serviceBinding.getValue() : null);
  519.                 updateStmt.setString(index++, superuser);
  520.                 if(gruppo.getOraRegistrazione()!=null)
  521.                     updateStmt.setTimestamp(index++, new Timestamp(gruppo.getOraRegistrazione().getTime()));
  522.                 if(utenteUltimaModifica!=null) {
  523.                     updateStmt.setString(index++, utenteUltimaModifica);
  524.                 }
  525.                 if(dataUltimaModifica!=null) {
  526.                     updateStmt.setTimestamp(index++, dataUltimaModifica);
  527.                 }
  528.     
  529.                 updateStmt.setLong(index++, idGruppo);

  531.                 // eseguo lo statement
  532.                 n = updateStmt.executeUpdate();
  533.                 updateStmt.close();
  534.                 DriverRegistroServiziDB_LIB.logDebug("CRUDGruppo type = " + type
  535.                         + " row affected =" + n);

  537.                 DriverRegistroServiziDB_LIB.logDebug("CRUDGruppo UPDATE : \n"
  538.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  539.                                 updateQuery, nome, descrizione,(serviceBinding!=null? serviceBinding.getValue() : null),
  540.                                 superuser,idGruppo));

  542.                 break;

  544.             case DELETE:
  545.                 // DELETE

  547.                 idG = new IDGruppo(nome);
  548.                 idGruppo = DBUtils.getIdGruppo(idG, con, DriverRegistroServiziDB_LIB.tipoDB);
  549.                 if (idGruppo <= 0)
  550.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDGruppo(DELETE)] Id Gruppo non valido.");
  551.                 
  552.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  553.                 sqlQueryObject.addDeleteTable(CostantiDB.GRUPPI);
  554.                 sqlQueryObject.addWhereCondition("id=?");
  555.                 updateQuery = sqlQueryObject.createSQLDelete();
  556.                 updateStmt = con.prepareStatement(updateQuery);

  558.                 updateStmt.setLong(1, idGruppo);

  560.                 // eseguo lo statement
  561.                 n = updateStmt.executeUpdate();
  562.                 updateStmt.close();
  563.                 DriverRegistroServiziDB_LIB.logDebug("CRUDGruppo type = " + type
  564.                         + " row affected =" + n);

  566.                 DriverRegistroServiziDB_LIB.logDebug("CRUDGruppo DELETE : \n"
  567.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  568.                                 updateQuery, idGruppo));

  570.                 break;
  571.             }

  573.         } catch (SQLException se) {
  574.             throw new DriverRegistroServiziException(
  575.                     "[DriverControlStationDB_LIB::CRUDGruppo] SQLException ["
  576.                     + se.getMessage() + "].",se);
  577.         } catch (Exception se) {
  578.             throw new DriverRegistroServiziException(
  579.                     "[DriverControlStationDB_LIB::CRUDGruppo] Exception ["
  580.                     + se.getMessage() + "].",se);
  581.         } finally {

  583.             JDBCUtilities.closeResources(updateStmt);
  584.             JDBCUtilities.closeResources(selectRS, selectStmt);

  586.         }
  587.     }
  588.     
  589.     public static void CRUDRuolo(int type, Ruolo ruolo, Connection con)
  590.             throws DriverRegistroServiziException {
  591.         if (ruolo == null) {
  592.             throw new DriverRegistroServiziException(
  593.             "[DriverRegistroServiziDB_LIB::CRUDRuolo] Parametro non valido.");
  594.         }

  596.         /**if ((type != CostantiDB.CREATE) && (pdd.getId() <= 0)) {
  597.             throw new DriverRegistroServiziException(
  598.             "[DriverRegistroServiziDB_LIB::CRUDRuolo] ID Ruolo non valido.");
  599.         }*/

  601.         String nome = ruolo.getNome();
  602.         String descrizione = ruolo.getDescrizione();
  603.         RuoloTipologia ruoloTipologia = ruolo.getTipologia();
  604.         String nomeEsterno = ruolo.getNomeEsterno();
  605.         RuoloContesto ruoloContesto = ruolo.getContestoUtilizzo();

  607.         String superuser = ruolo.getSuperUser();

  609.         PreparedStatement updateStmt = null;
  610.         String updateQuery = "";
  611.         PreparedStatement selectStmt = null;
  612.         String selectQuery = "";
  613.         ResultSet selectRS = null;
  614.         int n = 0;

  616.         try {

  618.             // preparo lo statement in base al tipo di operazione
  619.             switch (type) {
  620.             case CREATE:
  621.                 
  622.                 String utenteRichiedente = null;
  623.                 if(ruolo.getProprietaOggetto()!=null && ruolo.getProprietaOggetto().getUtenteRichiedente()!=null) {
  624.                     utenteRichiedente = ruolo.getProprietaOggetto().getUtenteRichiedente();
  625.                 }
  626.                 else {
  627.                     utenteRichiedente = superuser;
  628.                 }
  629.                 
  630.                 Timestamp dataCreazione = null;
  631.                 if(ruolo.getProprietaOggetto()!=null && ruolo.getProprietaOggetto().getDataCreazione()!=null) {
  632.                     dataCreazione = new Timestamp(ruolo.getProprietaOggetto().getDataCreazione().getTime());
  633.                 }
  634.                 else if(ruolo.getOraRegistrazione()!=null){
  635.                     dataCreazione = new Timestamp(ruolo.getOraRegistrazione().getTime());
  636.                 }
  637.                 else {
  638.                     dataCreazione = DateManager.getTimestamp();
  639.                 }
  640.                 
  641.                 // CREATE
  642.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  643.                 sqlQueryObject.addInsertTable(CostantiDB.RUOLI);
  644.                 sqlQueryObject.addInsertField("nome", "?");
  645.                 sqlQueryObject.addInsertField("descrizione", "?");
  646.                 sqlQueryObject.addInsertField("tipologia", "?");
  647.                 sqlQueryObject.addInsertField("nome_esterno", "?");
  648.                 sqlQueryObject.addInsertField("contesto_utilizzo", "?");
  649.                 sqlQueryObject.addInsertField("superuser", "?");
  650.                 if(ruolo.getOraRegistrazione()!=null)
  651.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  652.                 if(utenteRichiedente!=null) {
  653.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  654.                 }
  655.                 if(dataCreazione!=null) {
  656.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  657.                 }

  659.                 updateQuery = sqlQueryObject.createSQLInsert();
  660.                 updateStmt = con.prepareStatement(updateQuery);

  662.                 int index = 1;
  663.                 updateStmt.setString(index++, nome);
  664.                 updateStmt.setString(index++, descrizione);
  665.                 updateStmt.setString(index++, ruoloTipologia!=null? ruoloTipologia.getValue() : null);
  666.                 updateStmt.setString(index++, nomeEsterno);
  667.                 updateStmt.setString(index++, ruoloContesto!=null? ruoloContesto.getValue() : null);
  668.                 updateStmt.setString(index++, superuser);
  669.                 
  670.                 if(ruolo.getOraRegistrazione()!=null)
  671.                     updateStmt.setTimestamp(index++, new Timestamp(ruolo.getOraRegistrazione().getTime()));
  672.                 
  673.                 if(utenteRichiedente!=null) {
  674.                     updateStmt.setString(index++, utenteRichiedente);
  675.                 }
  676.                 
  677.                 if(dataCreazione!=null) {
  678.                     updateStmt.setTimestamp(index++, dataCreazione);
  679.                 }

  681.                 // eseguo lo statement
  682.                 n = updateStmt.executeUpdate();

  684.                 updateStmt.close();

  686.                 DriverRegistroServiziDB_LIB.logDebug("CRUDRuolo type = " + type
  687.                         + " row affected =" + n);

  689.                 DriverRegistroServiziDB_LIB.logDebug("CRUDRuolo CREATE : \n"
  690.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  691.                                 updateQuery, nome, descrizione,(ruoloTipologia!=null? ruoloTipologia.getValue() : null),
  692.                                 (ruoloContesto!=null? ruoloContesto.getValue() : null),superuser));

  694.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  695.                 sqlQueryObject.addFromTable(CostantiDB.RUOLI);
  696.                 sqlQueryObject.addSelectField("id");
  697.                 sqlQueryObject.addWhereCondition("nome = ?");
  698.                 selectQuery = sqlQueryObject.createSQLQuery();
  699.                 selectStmt = con.prepareStatement(selectQuery);
  700.                 selectStmt.setString(1, nome);

  702.                 selectRS = selectStmt.executeQuery();
  703.                 if (selectRS.next()) {
  704.                     ruolo.setId(selectRS.getLong("id"));
  705.                 }
  706.                 selectRS.close();
  707.                 selectStmt.close();
  708.                 break;

  710.             case UPDATE:
  711.                 // UPDATE1

  713.                 String nomeRuolo = ruolo.getOldIDRuoloForUpdate()!=null ? ruolo.getOldIDRuoloForUpdate().getNome() : null;
  714.                 if(nomeRuolo==null || "".equals(nomeRuolo))
  715.                     nomeRuolo = ruolo.getNome();
  716.                 
  717.                 IDRuolo idR = new IDRuolo(nomeRuolo);
  718.                 long idRuolo = DBUtils.getIdRuolo(idR, con, DriverRegistroServiziDB_LIB.tipoDB);
  719.                 if (idRuolo <= 0)
  720.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDRuolo(UPDATE)] Id Ruolo non valido.");
  721.                 
  722.                 String utenteUltimaModifica = null;
  723.                 if(ruolo.getProprietaOggetto()!=null && ruolo.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  724.                     utenteUltimaModifica = ruolo.getProprietaOggetto().getUtenteUltimaModifica();
  725.                 }
  726.                 else {
  727.                     utenteUltimaModifica = superuser;
  728.                 }
  729.                 
  730.                 Timestamp dataUltimaModifica = null;
  731.                 if(ruolo.getProprietaOggetto()!=null && ruolo.getProprietaOggetto().getDataUltimaModifica()!=null) {
  732.                     dataUltimaModifica = new Timestamp(ruolo.getProprietaOggetto().getDataUltimaModifica().getTime());
  733.                 }
  734.                 else {
  735.                     dataUltimaModifica = DateManager.getTimestamp();
  736.                 }
  737.                 
  738.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  739.                 sqlQueryObject.addUpdateTable(CostantiDB.RUOLI);
  740.                 sqlQueryObject.addUpdateField("nome", "?");
  741.                 sqlQueryObject.addUpdateField("descrizione", "?");
  742.                 sqlQueryObject.addUpdateField("tipologia", "?");
  743.                 sqlQueryObject.addUpdateField("nome_esterno", "?");
  744.                 sqlQueryObject.addUpdateField("contesto_utilizzo", "?");
  745.                 sqlQueryObject.addUpdateField("superuser", "?");
  746.                 if(ruolo.getOraRegistrazione()!=null)
  747.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  748.                 if(utenteUltimaModifica!=null) {
  749.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  750.                 }
  751.                 if(dataUltimaModifica!=null) {
  752.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  753.                 }
  754.                 
  755.                 sqlQueryObject.addWhereCondition("id=?");
  756.                 updateQuery = sqlQueryObject.createSQLUpdate();
  757.                 updateStmt = con.prepareStatement(updateQuery);

  759.                 index = 1;
  760.                 updateStmt.setString(index++, nome);
  761.                 updateStmt.setString(index++, descrizione);
  762.                 updateStmt.setString(index++, ruoloTipologia!=null? ruoloTipologia.getValue() : null);
  763.                 updateStmt.setString(index++, nomeEsterno);
  764.                 updateStmt.setString(index++, ruoloContesto!=null? ruoloContesto.getValue() : null);
  765.                 updateStmt.setString(index++, superuser);
  766.                 if(ruolo.getOraRegistrazione()!=null)
  767.                     updateStmt.setTimestamp(index++, new Timestamp(ruolo.getOraRegistrazione().getTime()));
  768.                 if(utenteUltimaModifica!=null) {
  769.                     updateStmt.setString(index++, utenteUltimaModifica);
  770.                 }
  771.                 if(dataUltimaModifica!=null) {
  772.                     updateStmt.setTimestamp(index++, dataUltimaModifica);
  773.                 }
  774.     
  775.                 updateStmt.setLong(index++, idRuolo);

  777.                 // eseguo lo statement
  778.                 n = updateStmt.executeUpdate();
  779.                 updateStmt.close();
  780.                 DriverRegistroServiziDB_LIB.logDebug("CRUDRuolo type = " + type
  781.                         + " row affected =" + n);

  783.                 DriverRegistroServiziDB_LIB.logDebug("CRUDRuolo UPDATE : \n"
  784.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  785.                                 updateQuery, nome, descrizione,(ruoloTipologia!=null? ruoloTipologia.getValue() : null),
  786.                                 (ruoloContesto!=null? ruoloContesto.getValue() : null),superuser,idRuolo));

  788.                 break;

  790.             case DELETE:
  791.                 // DELETE

  793.                 idR = new IDRuolo(nome);
  794.                 idRuolo = DBUtils.getIdRuolo(idR, con, DriverRegistroServiziDB_LIB.tipoDB);
  795.                 if (idRuolo <= 0)
  796.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDRuolo(DELETE)] Id Ruolo non valido.");
  797.                 
  798.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  799.                 sqlQueryObject.addDeleteTable(CostantiDB.RUOLI);
  800.                 sqlQueryObject.addWhereCondition("id=?");
  801.                 updateQuery = sqlQueryObject.createSQLDelete();
  802.                 updateStmt = con.prepareStatement(updateQuery);

  804.                 updateStmt.setLong(1, idRuolo);

  806.                 // eseguo lo statement
  807.                 n = updateStmt.executeUpdate();
  808.                 updateStmt.close();
  809.                 DriverRegistroServiziDB_LIB.logDebug("CRUDRuolo type = " + type
  810.                         + " row affected =" + n);

  812.                 DriverRegistroServiziDB_LIB.logDebug("CRUDRuolo DELETE : \n"
  813.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  814.                                 updateQuery, idRuolo));

  816.                 break;
  817.             }

  819.         } catch (SQLException se) {
  820.             throw new DriverRegistroServiziException(
  821.                     "[DriverControlStationDB_LIB::CRUDRuolo] SQLException ["
  822.                     + se.getMessage() + "].",se);
  823.         } catch (Exception se) {
  824.             throw new DriverRegistroServiziException(
  825.                     "[DriverControlStationDB_LIB::CRUDRuolo] Exception ["
  826.                     + se.getMessage() + "].",se);
  827.         } finally {

  829.             JDBCUtilities.closeResources(updateStmt);
  830.             JDBCUtilities.closeResources(selectRS, selectStmt);
  831.         }
  832.     }
  833.     
  834.     public static void CRUDScope(int type, Scope scope, Connection con)
  835.             throws DriverRegistroServiziException {
  836.         if (scope == null) {
  837.             throw new DriverRegistroServiziException(
  838.             "[DriverRegistroServiziDB_LIB::CRUDScope] Parametro non valido.");
  839.         }

  841.         /**if ((type != CostantiDB.CREATE) && (pdd.getId() <= 0)) {
  842.             throw new DriverRegistroServiziException(
  843.             "[DriverRegistroServiziDB_LIB::CRUDScope] ID Scope non valido.");
  844.         }*/

  846.         String nome = scope.getNome();
  847.         String descrizione = scope.getDescrizione();
  848.         String scopeTipologia = scope.getTipologia();
  849.         String nomeEsterno = scope.getNomeEsterno();
  850.         ScopeContesto scopeContesto = scope.getContestoUtilizzo();

  852.         String superuser = scope.getSuperUser();

  854.         PreparedStatement updateStmt = null;
  855.         String updateQuery = "";
  856.         PreparedStatement selectStmt = null;
  857.         String selectQuery = "";
  858.         ResultSet selectRS = null;
  859.         int n = 0;

  861.         try {

  863.             // preparo lo statement in base al tipo di operazione
  864.             switch (type) {
  865.             case CREATE:
  866.                 
  867.                 String utenteRichiedente = null;
  868.                 if(scope.getProprietaOggetto()!=null && scope.getProprietaOggetto().getUtenteRichiedente()!=null) {
  869.                     utenteRichiedente = scope.getProprietaOggetto().getUtenteRichiedente();
  870.                 }
  871.                 else {
  872.                     utenteRichiedente = superuser;
  873.                 }
  874.                 
  875.                 Timestamp dataCreazione = null;
  876.                 if(scope.getProprietaOggetto()!=null && scope.getProprietaOggetto().getDataCreazione()!=null) {
  877.                     dataCreazione = new Timestamp(scope.getProprietaOggetto().getDataCreazione().getTime());
  878.                 }
  879.                 else if(scope.getOraRegistrazione()!=null){
  880.                     dataCreazione = new Timestamp(scope.getOraRegistrazione().getTime());
  881.                 }
  882.                 else {
  883.                     dataCreazione = DateManager.getTimestamp();
  884.                 }               
  885.                 
  886.                 // CREATE
  887.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  888.                 sqlQueryObject.addInsertTable(CostantiDB.SCOPE);
  889.                 sqlQueryObject.addInsertField("nome", "?");
  890.                 sqlQueryObject.addInsertField("descrizione", "?");
  891.                 sqlQueryObject.addInsertField("tipologia", "?");
  892.                 sqlQueryObject.addInsertField("nome_esterno", "?");
  893.                 sqlQueryObject.addInsertField("contesto_utilizzo", "?");
  894.                 sqlQueryObject.addInsertField("superuser", "?");
  895.                 if(scope.getOraRegistrazione()!=null)
  896.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  897.                 if(utenteRichiedente!=null) {
  898.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  899.                 }
  900.                 if(dataCreazione!=null) {
  901.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  902.                 }

  904.                 updateQuery = sqlQueryObject.createSQLInsert();
  905.                 updateStmt = con.prepareStatement(updateQuery);

  907.                 int index = 1;
  908.                 updateStmt.setString(index++, nome);
  909.                 updateStmt.setString(index++, descrizione);
  910.                 updateStmt.setString(index++, scopeTipologia);
  911.                 updateStmt.setString(index++, nomeEsterno);
  912.                 updateStmt.setString(index++, scopeContesto!=null? scopeContesto.getValue() : null);
  913.                 updateStmt.setString(index++, superuser);
  914.                 
  915.                 if(scope.getOraRegistrazione()!=null)
  916.                     updateStmt.setTimestamp(index++, new Timestamp(scope.getOraRegistrazione().getTime()));
  917.                 
  918.                 if(utenteRichiedente!=null) {
  919.                     updateStmt.setString(index++, utenteRichiedente);
  920.                 }
  921.                 
  922.                 if(dataCreazione!=null) {
  923.                     updateStmt.setTimestamp(index++, dataCreazione);
  924.                 }

  926.                 // eseguo lo statement
  927.                 n = updateStmt.executeUpdate();

  929.                 updateStmt.close();

  931.                 DriverRegistroServiziDB_LIB.logDebug("CRUDScope type = " + type
  932.                         + " row affected =" + n);

  934.                 DriverRegistroServiziDB_LIB.logDebug("CRUDScope CREATE : \n"
  935.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  936.                                 updateQuery, nome, descrizione,scopeTipologia,
  937.                                 (scopeContesto!=null? scopeContesto.getValue() : null),superuser));

  939.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  940.                 sqlQueryObject.addFromTable(CostantiDB.SCOPE);
  941.                 sqlQueryObject.addSelectField("id");
  942.                 sqlQueryObject.addWhereCondition("nome = ?");
  943.                 selectQuery = sqlQueryObject.createSQLQuery();
  944.                 selectStmt = con.prepareStatement(selectQuery);
  945.                 selectStmt.setString(1, nome);

  947.                 selectRS = selectStmt.executeQuery();
  948.                 if (selectRS.next()) {
  949.                     scope.setId(selectRS.getLong("id"));
  950.                 }
  951.                 selectRS.close();
  952.                 selectStmt.close();
  953.                 break;

  955.             case UPDATE:
  956.                 // UPDATE1

  958.                 String nomeScope = scope.getOldIDScopeForUpdate()!=null ? scope.getOldIDScopeForUpdate().getNome() : null;
  959.                 if(nomeScope==null || "".equals(nomeScope))
  960.                     nomeScope = scope.getNome();
  961.                 
  962.                 IDScope idS = new IDScope(nomeScope);
  963.                 long idScope = DBUtils.getIdScope(idS, con, DriverRegistroServiziDB_LIB.tipoDB);
  964.                 if (idScope <= 0)
  965.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDScope(UPDATE)] Id Scope non valido.");
  966.                 
  967.                 String utenteUltimaModifica = null;
  968.                 if(scope.getProprietaOggetto()!=null && scope.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  969.                     utenteUltimaModifica = scope.getProprietaOggetto().getUtenteUltimaModifica();
  970.                 }
  971.                 else {
  972.                     utenteUltimaModifica = superuser;
  973.                 }
  974.                 
  975.                 Timestamp dataUltimaModifica = null;
  976.                 if(scope.getProprietaOggetto()!=null && scope.getProprietaOggetto().getDataUltimaModifica()!=null) {
  977.                     dataUltimaModifica = new Timestamp(scope.getProprietaOggetto().getDataUltimaModifica().getTime());
  978.                 }
  979.                 else {
  980.                     dataUltimaModifica = DateManager.getTimestamp();
  981.                 }
  982.                 
  983.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  984.                 sqlQueryObject.addUpdateTable(CostantiDB.SCOPE);
  985.                 sqlQueryObject.addUpdateField("nome", "?");
  986.                 sqlQueryObject.addUpdateField("descrizione", "?");
  987.                 sqlQueryObject.addUpdateField("tipologia", "?");
  988.                 sqlQueryObject.addUpdateField("nome_esterno", "?");
  989.                 sqlQueryObject.addUpdateField("contesto_utilizzo", "?");
  990.                 sqlQueryObject.addUpdateField("superuser", "?");
  991.                 if(scope.getOraRegistrazione()!=null)
  992.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  993.                 if(utenteUltimaModifica!=null) {
  994.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  995.                 }
  996.                 if(dataUltimaModifica!=null) {
  997.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  998.                 }
  999.                 
  1000.                 sqlQueryObject.addWhereCondition("id=?");
  1001.                 updateQuery = sqlQueryObject.createSQLUpdate();
  1002.                 updateStmt = con.prepareStatement(updateQuery);

  1004.                 index = 1;
  1005.                 updateStmt.setString(index++, nome);
  1006.                 updateStmt.setString(index++, descrizione);
  1007.                 updateStmt.setString(index++, scopeTipologia);
  1008.                 updateStmt.setString(index++, nomeEsterno);
  1009.                 updateStmt.setString(index++, scopeContesto!=null? scopeContesto.getValue() : null);
  1010.                 updateStmt.setString(index++, superuser);
  1011.                 if(scope.getOraRegistrazione()!=null)
  1012.                     updateStmt.setTimestamp(index++, new Timestamp(scope.getOraRegistrazione().getTime()));
  1013.                 if(utenteUltimaModifica!=null) {
  1014.                     updateStmt.setString(index++, utenteUltimaModifica);
  1015.                 }
  1016.                 if(dataUltimaModifica!=null) {
  1017.                     updateStmt.setTimestamp(index++, dataUltimaModifica);
  1018.                 }
  1019.                 
  1020.                 updateStmt.setLong(index++, idScope);

  1022.                 // eseguo lo statement
  1023.                 n = updateStmt.executeUpdate();
  1024.                 updateStmt.close();
  1025.                 DriverRegistroServiziDB_LIB.logDebug("CRUDScope type = " + type
  1026.                         + " row affected =" + n);

  1028.                 DriverRegistroServiziDB_LIB.logDebug("CRUDScope UPDATE : \n"
  1029.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  1030.                                 updateQuery, nome, descrizione,scopeTipologia,
  1031.                                 (scopeContesto!=null? scopeContesto.getValue() : null),superuser,idScope));

  1033.                 break;

  1035.             case DELETE:
  1036.                 // DELETE

  1038.                 idS = new IDScope(nome);
  1039.                 idScope = DBUtils.getIdScope(idS, con, DriverRegistroServiziDB_LIB.tipoDB);
  1040.                 if (idScope <= 0)
  1041.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDScope(DELETE)] Id Scope non valido.");
  1042.                 
  1043.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1044.                 sqlQueryObject.addDeleteTable(CostantiDB.SCOPE);
  1045.                 sqlQueryObject.addWhereCondition("id=?");
  1046.                 updateQuery = sqlQueryObject.createSQLDelete();
  1047.                 updateStmt = con.prepareStatement(updateQuery);

  1049.                 updateStmt.setLong(1, idScope);

  1051.                 // eseguo lo statement
  1052.                 n = updateStmt.executeUpdate();
  1053.                 updateStmt.close();
  1054.                 DriverRegistroServiziDB_LIB.logDebug("CRUDScope type = " + type
  1055.                         + " row affected =" + n);

  1057.                 DriverRegistroServiziDB_LIB.logDebug("CRUDScope DELETE : \n"
  1058.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  1059.                                 updateQuery, idScope));

  1061.                 break;
  1062.             }

  1064.         } catch (SQLException se) {
  1065.             throw new DriverRegistroServiziException(
  1066.                     "[DriverControlStationDB_LIB::CRUDScope] SQLException ["
  1067.                     + se.getMessage() + "].",se);
  1068.         } catch (Exception se) {
  1069.             throw new DriverRegistroServiziException(
  1070.                     "[DriverControlStationDB_LIB::CRUDScope] Exception ["
  1071.                     + se.getMessage() + "].",se);
  1072.         } finally {

  1074.             JDBCUtilities.closeResources(updateStmt);
  1075.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1076.         }
  1077.     }
  1078.     

  1080.     
  1081.     
  1082.     // UTILS ID
  1083.     
  1084.     /**
  1085.      * Ritorna l'id del connettore di un soggetto
  1086.      * 
  1087.      * @param nomeSoggetto
  1088.      * @param tipoSoggetto
  1089.      * @param con
  1090.      * @return id del connettore del soggetto
  1091.      * @throws DriverRegistroServiziException
  1092.      */
  1093.     static long getIdConnettoreSoggetto(String nomeSoggetto, String tipoSoggetto, Connection con) throws DriverRegistroServiziException {
  1094.         PreparedStatement stm = null;
  1095.         ResultSet rs = null;
  1096.         long idConnettore = -1;
  1097.         try {
  1098.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1099.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1100.             sqlQueryObject.addSelectField("*");
  1101.             sqlQueryObject.addWhereCondition("tipo_soggetto = ?");
  1102.             sqlQueryObject.addWhereCondition("nome_soggetto = ?");
  1103.             sqlQueryObject.setANDLogicOperator(true);
  1104.             String query = sqlQueryObject.createSQLQuery();
  1105.             stm = con.prepareStatement(query);
  1106.             stm.setString(1, tipoSoggetto);
  1107.             stm.setString(2, nomeSoggetto);

  1109.             rs = stm.executeQuery();

  1111.             if (rs.next()) {
  1112.                 idConnettore = rs.getLong("id_connettore");
  1113.             }

  1115.             return idConnettore;

  1117.         } catch (SQLException e) {
  1118.             DriverRegistroServiziDB_LIB.log.error("Errore SQL", e);
  1119.             throw new DriverRegistroServiziException(e);
  1120.         }catch (Exception e) {
  1121.             DriverRegistroServiziDB_LIB.log.error("Errore", e);
  1122.             throw new DriverRegistroServiziException(e);
  1123.         } finally {
  1124.             JDBCUtilities.closeResources(rs, stm);
  1125.         }
  1126.     }

  1128.     /**
  1129.      * Ritorna l'id del connettore del servizio fornito da un soggetto
  1130.      * 
  1131.      * @param nomeServizio
  1132.      * @param tipoServizio
  1133.      * @param nomeSoggetto
  1134.      * @param tipoSoggetto
  1135.      * @param con 
  1136.      * @return id del connettore del servizio
  1137.      * @throws DriverRegistroServiziException
  1138.      */
  1139.     static long getIdConnettoreServizio(String nomeServizio, String tipoServizio, Integer versioneServizio, String nomeSoggetto, String tipoSoggetto, Connection con) throws DriverRegistroServiziException {
  1140.         PreparedStatement stm = null;
  1141.         ResultSet rs = null;
  1142.         long idConnettore = -1;
  1143.         long idSoggetto;
  1144.         try {

  1146.             idSoggetto = DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, DriverRegistroServiziDB_LIB.tipoDB);

  1148.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1149.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1150.             sqlQueryObject.addSelectField("*");
  1151.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  1152.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  1153.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  1154.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  1155.             sqlQueryObject.setANDLogicOperator(true);
  1156.             String query = sqlQueryObject.createSQLQuery();
  1157.             stm = con.prepareStatement(query);
  1158.             int index = 1;
  1159.             stm.setString(index++, tipoServizio);
  1160.             stm.setString(index++, nomeServizio);
  1161.             stm.setInt(index++, versioneServizio);
  1162.             stm.setLong(index++, idSoggetto);

  1164.             rs = stm.executeQuery();

  1166.             if (rs.next()) {
  1167.                 idConnettore = rs.getLong("id_connettore");
  1168.             }

  1170.             return idConnettore;

  1172.         } catch (CoreException e) {
  1173.             DriverRegistroServiziDB_LIB.log.error("Errore Driver.", e);
  1174.             throw new DriverRegistroServiziException(e);
  1175.         } catch (SQLException e) {
  1176.             DriverRegistroServiziDB_LIB.log.error("Errore SQL", e);
  1177.             throw new DriverRegistroServiziException(e);
  1178.         } catch (Exception e) {
  1179.             DriverRegistroServiziDB_LIB.log.error("Errore", e);
  1180.             throw new DriverRegistroServiziException(e);
  1181.         }finally {
  1182.             JDBCUtilities.closeResources(rs, stm);
  1183.         }
  1184.     }

  1186.     static long getIdFruizione(long idServizio, String nomeSoggetto, String tipoSoggetto, Connection con) throws DriverRegistroServiziException {
  1187.         PreparedStatement stm = null;
  1188.         ResultSet rs = null;
  1189.         long idFruizione = -1;
  1190.         long idSoggetto;
  1191.         try {

  1193.             idSoggetto = DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, DriverRegistroServiziDB_LIB.tipoDB);

  1195.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1196.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1197.             sqlQueryObject.addSelectField("id");
  1198.             sqlQueryObject.addWhereCondition("id_servizio = ?");
  1199.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  1200.             sqlQueryObject.setANDLogicOperator(true);
  1201.             String query = sqlQueryObject.createSQLQuery();
  1202.             stm = con.prepareStatement(query);
  1203.             stm.setLong(1, idServizio);
  1204.             stm.setLong(2, idSoggetto);

  1206.             rs = stm.executeQuery();

  1208.             if (rs.next()) {
  1209.                 idFruizione = rs.getLong("id");
  1210.             }

  1212.             return idFruizione;

  1214.         } catch (CoreException e) {
  1215.             DriverRegistroServiziDB_LIB.log.error("Errore Core: "+e.getMessage(),e);
  1216.             throw new DriverRegistroServiziException(e);
  1217.         } catch (SQLException e) {
  1218.             DriverRegistroServiziDB_LIB.log.error("Errore SQL: "+e.getMessage(), e);
  1219.             throw new DriverRegistroServiziException(e);
  1220.         }catch (Exception e) {
  1221.             DriverRegistroServiziDB_LIB.log.error("Errore Generico: "+e.getMessage(), e);
  1222.             throw new DriverRegistroServiziException(e);
  1223.         } finally {
  1224.             JDBCUtilities.closeResources(rs, stm);
  1225.         }
  1226.     }
  1227.     
  1228.     static long getIdConnettoreServizioFruitore(long idServizio, String nomeSoggetto, String tipoSoggetto, Connection con) throws DriverRegistroServiziException {
  1229.         PreparedStatement stm = null;
  1230.         ResultSet rs = null;
  1231.         long idConnettore = -1;
  1232.         long idSoggetto;
  1233.         try {

  1235.             idSoggetto = DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, DriverRegistroServiziDB_LIB.tipoDB);

  1237.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1238.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1239.             sqlQueryObject.addSelectField("*");
  1240.             sqlQueryObject.addWhereCondition("id_servizio = ?");
  1241.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  1242.             sqlQueryObject.setANDLogicOperator(true);
  1243.             String query = sqlQueryObject.createSQLQuery();
  1244.             stm = con.prepareStatement(query);
  1245.             stm.setLong(1, idServizio);
  1246.             stm.setLong(2, idSoggetto);

  1248.             rs = stm.executeQuery();

  1250.             if (rs.next()) {
  1251.                 idConnettore = rs.getLong("id_connettore");
  1252.             }

  1254.             return idConnettore;

  1256.         } catch (CoreException e) {
  1257.             DriverRegistroServiziDB_LIB.log.error("Errore Core: "+e.getMessage(),e);
  1258.             throw new DriverRegistroServiziException(e);
  1259.         } catch (SQLException e) {
  1260.             DriverRegistroServiziDB_LIB.log.error("Errore SQL: "+e.getMessage(), e);
  1261.             throw new DriverRegistroServiziException(e);
  1262.         }catch (Exception e) {
  1263.             DriverRegistroServiziDB_LIB.log.error("Errore Generico: "+e.getMessage(), e);
  1264.             throw new DriverRegistroServiziException(e);
  1265.         } finally {
  1266.             JDBCUtilities.closeResources(rs, stm);
  1267.         }
  1268.     }
  1269.     
  1270.     static long getIdConnettoreServizioAzione(long idServizio, String azione, Connection con) throws DriverRegistroServiziException {
  1271.         PreparedStatement stm = null;
  1272.         ResultSet rs = null;
  1273.         long idConnettore = -1;
  1274.         try {

  1276.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1277.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_AZIONI);
  1278.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_AZIONE);
  1279.             sqlQueryObject.addSelectField("*");
  1280.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_AZIONI+".id="+CostantiDB.SERVIZI_AZIONE+".id_servizio_azioni");
  1281.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_AZIONI+".id_servizio = ?");
  1282.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_AZIONE+".nome_azione = ?");
  1283.             sqlQueryObject.setANDLogicOperator(true);
  1284.             String query = sqlQueryObject.createSQLQuery();
  1285.             stm = con.prepareStatement(query);
  1286.             stm.setLong(1, idServizio);
  1287.             stm.setString(2, azione);

  1289.             rs = stm.executeQuery();

  1291.             if (rs.next()) {
  1292.                 idConnettore = rs.getLong("id_connettore");
  1293.             }

  1295.             return idConnettore;

  1297.         } catch (SQLException e) {
  1298.             DriverRegistroServiziDB_LIB.log.error("Errore SQL", e);
  1299.             throw new DriverRegistroServiziException(e);
  1300.         }catch (Exception e) {
  1301.             DriverRegistroServiziDB_LIB.log.error("Errore", e);
  1302.             throw new DriverRegistroServiziException(e);
  1303.         } finally {
  1304.             JDBCUtilities.closeResources(rs, stm);
  1305.         }
  1306.     }
  1307.     
  1308.     static long getIdConnettoreFruizioneServizioAzione(long idFruizione, String azione, Connection con) throws DriverRegistroServiziException {
  1309.         PreparedStatement stm = null;
  1310.         ResultSet rs = null;
  1311.         long idConnettore = -1;
  1312.         try {

  1314.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  1315.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1316.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONE);
  1317.             sqlQueryObject.addSelectField("*");
  1318.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONI+".id="+CostantiDB.SERVIZI_FRUITORI_AZIONE+".id_fruizione_azioni");
  1319.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONI+".id_fruizione = ?");
  1320.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONE+".nome_azione = ?");
  1321.             sqlQueryObject.setANDLogicOperator(true);
  1322.             String query = sqlQueryObject.createSQLQuery();
  1323.             stm = con.prepareStatement(query);
  1324.             stm.setLong(1, idFruizione);
  1325.             stm.setString(2, azione);

  1327.             rs = stm.executeQuery();

  1329.             if (rs.next()) {
  1330.                 idConnettore = rs.getLong("id_connettore");
  1331.             }

  1333.             return idConnettore;

  1335.         } catch (SQLException e) {
  1336.             DriverRegistroServiziDB_LIB.log.error("Errore SQL", e);
  1337.             throw new DriverRegistroServiziException(e);
  1338.         }catch (Exception e) {
  1339.             DriverRegistroServiziDB_LIB.log.error("Errore", e);
  1340.             throw new DriverRegistroServiziException(e);
  1341.         } finally {
  1342.             JDBCUtilities.closeResources(rs, stm);
  1343.         }
  1344.     }

  1346.     
  1347.     
  1348.     
  1349.     
  1350.     

  1352.     public static void CRUDProtocolProperty(int type, List<ProtocolProperty> listPP, long idProprietario,
  1353.             org.openspcoop2.core.constants.ProprietariProtocolProperty tipologiaProprietarioProtocolProperty, Connection connection,
  1354.             String tipoDatabase, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  1355.         try {
  1356.             DBProtocolPropertiesUtils.crudRegistryProtocolProperty(log, type, listPP, idProprietario, tipologiaProprietarioProtocolProperty, connection, tipoDatabase, driverBYOK);
  1357.         }catch(Exception e) {
  1358.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1359.         }
  1360.     }
  1361.     
  1362.     
  1363.     public static List<ProtocolProperty> getListaProtocolProperty(long idProprietario, org.openspcoop2.core.constants.ProprietariProtocolProperty tipologiaProprietario, 
  1364.             Connection connection,
  1365.             String tipoDatabase, IDriverBYOK driverBYOK) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1366.         try {
  1367.             return DBProtocolPropertiesUtils.getListaProtocolPropertyRegistry(idProprietario,tipologiaProprietario,connection,tipoDatabase, driverBYOK);
  1368.         }
  1369.         catch(NotFoundException e) {
  1370.             throw new DriverRegistroServiziNotFound(e.getMessage(),e);
  1371.         }
  1372.         catch(Exception e) {
  1373.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1374.         }
  1375.     }
  1376.     
  1377.     public static ProtocolProperty getProtocolProperty(long id, Connection connection, String tipoDatabase, IDriverBYOK driverBYOK) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1378.         try {
  1379.             return DBProtocolPropertiesUtils.getProtocolPropertyRegistry(id, connection, tipoDatabase, driverBYOK);
  1380.         }
  1381.         catch(NotFoundException e) {
  1382.             throw new DriverRegistroServiziNotFound(e.getMessage(),e);
  1383.         }
  1384.         catch(Exception e) {
  1385.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1386.         }
  1387.     }
  1388.     
  1389. }
Created with JaCoCo 0.8.8.202204050719