DriverRegistroServiziDB_soggettiLIB.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;

  35. import org.openspcoop2.core.byok.BYOKUtilities;
  36. import org.openspcoop2.core.byok.BYOKWrappedValue;
  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.constants.ProprietariProtocolProperty;
  42. import org.openspcoop2.core.id.IDRuolo;
  43. import org.openspcoop2.core.registry.Connettore;
  44. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  45. import org.openspcoop2.core.registry.PortaDominio;
  46. import org.openspcoop2.core.registry.Proprieta;
  47. import org.openspcoop2.core.registry.RuoloSoggetto;
  48. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  49. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  50. import org.openspcoop2.utils.certificate.CertificateUtils;
  51. import org.openspcoop2.utils.certificate.PrincipalType;
  52. import org.openspcoop2.utils.date.DateManager;
  53. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  54. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  55. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  56. import org.openspcoop2.utils.sql.ISQLQueryObject;
  57. import org.openspcoop2.utils.sql.SQLObjectFactory;

  59. /**
  60.  * Classe utilizzata per effettuare query ad un registro dei servizi openspcoop
  61.  * formato db.
  62.  * 
  63.  * 
  64.  * @author Sandra Giangrandi (sandra@link.it)
  65.  * @author Stefano Corallo (corallo@link.it)
  66.  * @author $Author$
  67.  * @version $Rev$, $Date$
  68.  */
  69. public class DriverRegistroServiziDB_soggettiLIB {

  71.     

  73.     /** Metodi CRUD */

  75.     public static void CRUDPortaDominio(int type, PortaDominio pdd, Connection con)
  76.     throws DriverRegistroServiziException {
  77.         if (pdd == null) {
  78.             throw new DriverRegistroServiziException(
  79.             "[DriverRegistroServiziDB_LIB::CRUDPdd] Parametro non valido.");
  80.         }

  82.         /**if ((type != CostantiDB.CREATE) && (pdd.getId() <= 0)) {
  83.             throw new DriverRegistroServiziException(
  84.             "[DriverRegistroServiziDB_LIB::CRUDPdd] ID Pdd non valido.");
  85.         }*/

  87.         String nome = pdd.getNome();
  88.         String descrizione = pdd.getDescrizione();
  89.         String implementazione = pdd.getImplementazione();

  91.         String subject = pdd.getSubject();
  92.         StatoFunzionalita client_auth = pdd.getClientAuth();
  93.         
  94.         String superuser = pdd.getSuperUser();

  96.         PreparedStatement updateStmt = null;
  97.         String updateQuery = "";
  98.         PreparedStatement selectStmt = null;
  99.         String selectQuery = "";
  100.         ResultSet selectRS = null;
  101.         int n = 0;

  103.         try {

  105.             // preparo lo statement in base al tipo di operazione
  106.             switch (type) {
  107.             case CREATE:
  108.                 // CREATE
  109.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  110.                 sqlQueryObject.addInsertTable(CostantiDB.PDD);
  111.                 sqlQueryObject.addInsertField("nome", "?");
  112.                 sqlQueryObject.addInsertField("descrizione", "?");
  113.                 sqlQueryObject.addInsertField("implementazione", "?");
  114.                 sqlQueryObject.addInsertField("subject", "?");
  115.                 sqlQueryObject.addInsertField("client_auth", "?");
  116.                 sqlQueryObject.addInsertField("superuser", "?");
  117.                 if(pdd.getOraRegistrazione()!=null)
  118.                     sqlQueryObject.addInsertField("ora_registrazione", "?");

  120.                 updateQuery = sqlQueryObject.createSQLInsert();
  121.                 updateStmt = con.prepareStatement(updateQuery);

  123.                 updateStmt.setString(1, nome);
  124.                 updateStmt.setString(2, descrizione);
  125.                 updateStmt.setString(3, implementazione);
  126.                 updateStmt.setString(4, (subject != null ? CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT) : null));
  127.                 updateStmt.setString(5, DriverRegistroServiziDB_LIB.getValue(client_auth));
  128.                 updateStmt.setString(6, superuser);
  129.                 if(pdd.getOraRegistrazione()!=null)
  130.                     updateStmt.setTimestamp(7, new Timestamp(pdd.getOraRegistrazione().getTime()));

  132.                 // eseguo lo statement
  133.                 n = updateStmt.executeUpdate();

  135.                 updateStmt.close();

  137.                 DriverRegistroServiziDB_LIB.logDebug("CRUDPdd type = " + type
  138.                         + " row affected =" + n);

  140.                 DriverRegistroServiziDB_LIB.logDebug("CRUDPdd CREATE : \n"
  141.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  142.                                 updateQuery, nome, descrizione,implementazione,subject,client_auth));

  144.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  145.                 sqlQueryObject.addFromTable(CostantiDB.PDD);
  146.                 sqlQueryObject.addSelectField("id");
  147.                 sqlQueryObject.addWhereCondition("nome = ?");
  148.                 selectQuery = sqlQueryObject.createSQLQuery();
  149.                 selectStmt = con.prepareStatement(selectQuery);
  150.                 selectStmt.setString(1, nome);

  152.                 selectRS = selectStmt.executeQuery();
  153.                 if (selectRS.next()) {
  154.                     pdd.setId(selectRS.getLong("id"));
  155.                 }
  156.                 selectRS.close();
  157.                 selectStmt.close();
  158.                 break;

  160.             case UPDATE:
  161.                 // UPDATE

  163.                 String nomePdd = pdd.getOldNomeForUpdate();
  164.                 if(nomePdd==null || "".equals(nomePdd))
  165.                     nomePdd = pdd.getNome();
  166.                 
  167.                 long idPdd = DBUtils.getIdPortaDominio(nomePdd, con, DriverRegistroServiziDB_LIB.tipoDB);
  168.                 if (idPdd <= 0)
  169.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDPortaDominio(UPDATE)] Id Porta di Dominio non valido.");
  170.                 
  171.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  172.                 sqlQueryObject.addUpdateTable(CostantiDB.PDD);
  173.                 sqlQueryObject.addUpdateField("nome", "?");
  174.                 sqlQueryObject.addUpdateField("descrizione", "?");
  175.                 sqlQueryObject.addUpdateField("implementazione", "?");
  176.                 sqlQueryObject.addUpdateField("subject", "?");
  177.                 sqlQueryObject.addUpdateField("client_auth", "?");
  178.                 sqlQueryObject.addUpdateField("superuser", "?");
  179.                 if(pdd.getOraRegistrazione()!=null)
  180.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  181.                 sqlQueryObject.addWhereCondition("id=?");
  182.                 updateQuery = sqlQueryObject.createSQLUpdate();
  183.                 updateStmt = con.prepareStatement(updateQuery);

  185.                 updateStmt.setString(1, nome);
  186.                 updateStmt.setString(2, descrizione);
  187.                 updateStmt.setString(3, implementazione);
  188.                 updateStmt.setString(4, (subject != null ? CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT) : null));
  189.                 updateStmt.setString(5, DriverRegistroServiziDB_LIB.getValue(client_auth));
  190.                 updateStmt.setString(6, superuser);

  192.                 int paramIndex = 6;

  194.                 if(pdd.getOraRegistrazione()!=null)
  195.                     updateStmt.setTimestamp(++paramIndex, new Timestamp(pdd.getOraRegistrazione().getTime()));

  197.                 updateStmt.setLong(++paramIndex, idPdd);

  199.                 // eseguo lo statement
  200.                 n = updateStmt.executeUpdate();
  201.                 updateStmt.close();
  202.                 DriverRegistroServiziDB_LIB.logDebug("CRUDPdd type = " + type
  203.                         + " row affected =" + n);

  205.                 DriverRegistroServiziDB_LIB.logDebug("CRUDPdd UPDATE : \n"
  206.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  207.                                 updateQuery, descrizione, implementazione,subject,client_auth,idPdd));

  209.                 break;

  211.             case DELETE:
  212.                 // DELETE

  214.                 idPdd = DBUtils.getIdPortaDominio(nome, con, DriverRegistroServiziDB_LIB.tipoDB);
  215.                 if (idPdd <= 0)
  216.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDPortaDominio(DELETE)] Id Porta di Dominio non valido.");
  217.                 
  218.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  219.                 sqlQueryObject.addDeleteTable(CostantiDB.PDD);
  220.                 sqlQueryObject.addWhereCondition("id=?");
  221.                 updateQuery = sqlQueryObject.createSQLDelete();
  222.                 updateStmt = con.prepareStatement(updateQuery);

  224.                 updateStmt.setLong(1, idPdd);

  226.                 // eseguo lo statement
  227.                 n = updateStmt.executeUpdate();
  228.                 updateStmt.close();
  229.                 DriverRegistroServiziDB_LIB.logDebug("CRUDPdd type = " + type
  230.                         + " row affected =" + n);

  232.                 DriverRegistroServiziDB_LIB.logDebug("CRUDPdd DELETE : \n"
  233.                         + DriverRegistroServiziDB_LIB.formatSQLString(
  234.                                 updateQuery, idPdd));

  236.                 break;
  237.             }

  239.         } catch (SQLException se) {
  240.             throw new DriverRegistroServiziException(
  241.                     "[DriverControlStationDB_LIB::CRUDPdd] SQLException ["
  242.                     + se.getMessage() + "].",se);
  243.         } catch (Exception se) {
  244.             throw new DriverRegistroServiziException(
  245.                     "[DriverControlStationDB_LIB::CRUDPdd] Exception ["
  246.                     + se.getMessage() + "].",se);
  247.         } finally {
  248.             JDBCUtilities.closeResources(updateStmt);
  249.             JDBCUtilities.closeResources(selectRS, selectStmt);
  250.         }
  251.     }
  252.     
  253.     /**
  254.      * CRUD oggetto Soggetto Non si occupa di chiudere la connessione con
  255.      * il db in caso di errore in quanto verra' gestita dal metodo chiamante
  256.      * 
  257.      * @param type
  258.      *            Tipo operazione {1 (CREATE),2 (UPDATE),3 (DELETE)}
  259.      * @param soggetto
  260.      * @throws DriverRegistroServiziException
  261.      */
  262.     public static long CRUDSoggetto(int type, org.openspcoop2.core.registry.Soggetto soggetto, 
  263.             Connection con, String tipoDatabase, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  264.         if (soggetto == null)
  265.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto] Parametro non valido.");

  267.         String nome = soggetto.getNome();
  268.         String tipo = soggetto.getTipo();

  270.         if (nome == null || nome.equals(""))
  271.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto] Parametro Nome non valido.");
  272.         if (tipo == null || tipo.equals(""))
  273.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto] Parametro Tipo non valido.");

  275.         String descizione = soggetto.getDescrizione();
  276.         String identificativoPorta = soggetto.getIdentificativoPorta();
  277.         String server = soggetto.getPortaDominio();
  278.         Connettore connettore = soggetto.getConnettore();
  279.         String codiceIPA = soggetto.getCodiceIpa();
  280.         String superUser = soggetto.getSuperUser();

  282.         if (connettore == null && type != CostantiDB.CREATE && type!=CostantiDB.DELETE)
  283.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto] Il connettore del soggetto e' null.");

  285.         PreparedStatement updateStmt = null;
  286.         String updateQuery = "";
  287.         PreparedStatement selectStmt = null;
  288.         String selectQuery = "";
  289.         ResultSet selectRS = null;
  290.         long idSoggetto = 0;
  291.         int n = 0;

  293.         try {
  294.             long idConnettore;

  296.             // preparo lo statement in base al tipo di operazione
  297.             switch (type) {
  298.             case CREATE:
  299.                 // CREATE

  301.                 String utenteRichiedente = null;
  302.                 if(soggetto.getProprietaOggetto()!=null && soggetto.getProprietaOggetto().getUtenteRichiedente()!=null) {
  303.                     utenteRichiedente = soggetto.getProprietaOggetto().getUtenteRichiedente();
  304.                 }
  305.                 else {
  306.                     utenteRichiedente = superUser;
  307.                 }
  308.                 
  309.                 Timestamp dataCreazione = null;
  310.                 if(soggetto.getProprietaOggetto()!=null && soggetto.getProprietaOggetto().getDataCreazione()!=null) {
  311.                     dataCreazione = new Timestamp(soggetto.getProprietaOggetto().getDataCreazione().getTime());
  312.                 }
  313.                 else if(soggetto.getOraRegistrazione()!=null){
  314.                     dataCreazione = new Timestamp(soggetto.getOraRegistrazione().getTime());
  315.                 }
  316.                 else {
  317.                     dataCreazione = DateManager.getTimestamp();
  318.                 }
  319.                 
  320.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  321.                 sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI);
  322.                 sqlQueryObject.addInsertField("nome_soggetto", "?");
  323.                 sqlQueryObject.addInsertField("descrizione", "?");
  324.                 sqlQueryObject.addInsertField("identificativo_porta", "?");
  325.                 sqlQueryObject.addInsertField("tipo_soggetto", "?");
  326.                 sqlQueryObject.addInsertField("id_connettore", "?");
  327.                 sqlQueryObject.addInsertField("server", "?");
  328.                 sqlQueryObject.addInsertField("superuser", "?");
  329.                 sqlQueryObject.addInsertField("privato", "?");
  330.                 sqlQueryObject.addInsertField("profilo", "?");
  331.                 sqlQueryObject.addInsertField("codice_ipa", "?");
  332.                 sqlQueryObject.addInsertField("tipoauth", "?");
  333.                 sqlQueryObject.addInsertField("utente", "?");
  334.                 sqlQueryObject.addInsertField("password", "?");
  335.                 sqlQueryObject.addInsertField("subject", "?");
  336.                 sqlQueryObject.addInsertField("cn_subject", "?");
  337.                 sqlQueryObject.addInsertField("issuer", "?");
  338.                 sqlQueryObject.addInsertField("cn_issuer", "?");
  339.                 sqlQueryObject.addInsertField("certificate", "?");
  340.                 sqlQueryObject.addInsertField("cert_strict_verification", "?");
  341.                 if(soggetto.getOraRegistrazione()!=null)
  342.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  343.                 if(utenteRichiedente!=null) {
  344.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, "?");
  345.                 }
  346.                 if(dataCreazione!=null) {
  347.                     sqlQueryObject.addInsertField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, "?");
  348.                 }
  349.                 updateQuery = sqlQueryObject.createSQLInsert();
  350.                 updateStmt = con.prepareStatement(updateQuery);

  352.                 // Controllo se il connettore non e' presente ne creo uno
  353.                 // disabilitato
  354.                 // in questo caso setto il nome del connettore
  355.                 if (connettore == null) {
  356.                     connettore = new Connettore();
  357.                     connettore.setNome("CNT_" + tipo + "_" + nome);
  358.                 }

  360.                 if (connettore.getNome() == null || connettore.getNome().equals(""))
  361.                     connettore.setNome("CNT_" + tipo + "_" + nome);

  363.                 idConnettore = DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(CostantiDB.CREATE, connettore, con, driverBYOK);

  365.                 int index = 1;
  366.                 
  367.                 updateStmt.setString(index++, nome);
  368.                 updateStmt.setString(index++, descizione);
  369.                 updateStmt.setString(index++, identificativoPorta);
  370.                 updateStmt.setString(index++, tipo);
  371.                 updateStmt.setLong(index++, idConnettore);
  372.                 updateStmt.setString(index++, server);
  373.                 updateStmt.setString(index++, superUser);
  374.                 if(soggetto.getPrivato()!=null && soggetto.getPrivato())
  375.                     updateStmt.setInt(index++, 1);
  376.                 else
  377.                     updateStmt.setInt(index++, 0);
  378.                 updateStmt.setString(index++, soggetto.getVersioneProtocollo());
  379.                 updateStmt.setString(index++, codiceIPA);
  380.                 
  381.                 CredenzialiSoggetto credenziali = (soggetto.sizeCredenzialiList() > 0 ? soggetto.getCredenziali(0) : null);
  382.                 updateStmt.setString(index++, (credenziali != null ? DriverRegistroServiziDB_LIB.getValue(credenziali.getTipo()) : null));
  383.                 updateStmt.setString(index++, (credenziali != null ? credenziali.getUser() : null));
  384.                 updateStmt.setString(index++, (credenziali != null ? credenziali.getPassword() : null));
  385.                 
  386.                 String subject = null;
  387.                 if(credenziali!=null && credenziali.getSubject()!=null && !"".equals(credenziali.getSubject()))
  388.                     subject = credenziali.getSubject();
  389.                 updateStmt.setString(index++, (subject != null ? CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT) : null));
  390.                 String subjectCN = null;
  391.                 if(credenziali!=null && credenziali.getCnSubject()!=null && !"".equals(credenziali.getCnSubject()))
  392.                     subjectCN = credenziali.getCnSubject();
  393.                 updateStmt.setString(index++, subjectCN);
  394.                 
  395.                 String issuer = null;
  396.                 if(credenziali != null && org.openspcoop2.core.registry.constants.CredenzialeTipo.APIKEY.equals(credenziali.getTipo())) {
  397.                     updateStmt.setString(index++, CostantiDB.getIssuerApiKey(credenziali.isAppId()));
  398.                 }
  399.                 else {
  400.                     if(credenziali!=null && credenziali.getIssuer()!=null && !"".equals(credenziali.getIssuer()))
  401.                         issuer = credenziali.getIssuer();
  402.                     updateStmt.setString(index++, (issuer != null ? CertificateUtils.formatPrincipal(issuer, PrincipalType.ISSUER) : null));
  403.                 }
  404.                 String issuerCN = null;
  405.                 if(credenziali!=null && credenziali.getCnIssuer()!=null && !"".equals(credenziali.getCnIssuer()))
  406.                     issuerCN = credenziali.getCnIssuer();
  407.                 updateStmt.setString(index++, issuerCN);
  408.                 
  409.                 byte [] certificate = null;
  410.                 if(credenziali!=null && credenziali.getCertificate()!=null) {
  411.                     certificate = credenziali.getCertificate();
  412.                 }
  413.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverRegistroServiziDB_LIB.tipoDB);
  414.                 jdbcAdapter.setBinaryData(updateStmt, index++, certificate);
  415.                 if(credenziali!=null && credenziali.isCertificateStrictVerification()) {
  416.                     updateStmt.setInt(index++, CostantiDB.TRUE);
  417.                 }               
  418.                 else {
  419.                     updateStmt.setInt(index++, CostantiDB.FALSE);
  420.                 }
  421.                                 
  422.                 if(soggetto.getOraRegistrazione()!=null){
  423.                     updateStmt.setTimestamp(index++, new Timestamp(soggetto.getOraRegistrazione().getTime()));
  424.                 }
  425.                 
  426.                 if(utenteRichiedente!=null) {
  427.                     updateStmt.setString(index++, utenteRichiedente);
  428.                 }
  429.                 
  430.                 if(dataCreazione!=null) {
  431.                     updateStmt.setTimestamp(index++, dataCreazione);
  432.                 }

  434.                 // eseguo lo statement
  435.                 n = updateStmt.executeUpdate();
  436.                 updateStmt.close();
  437.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n);
  438.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, nome, descizione, identificativoPorta, tipo, idConnettore, server));

  440.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  441.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  442.                 sqlQueryObject.addSelectField("id");
  443.                 sqlQueryObject.addWhereCondition("tipo_soggetto = ?");
  444.                 sqlQueryObject.addWhereCondition("nome_soggetto = ?");
  445.                 sqlQueryObject.setANDLogicOperator(true);
  446.                 selectQuery = sqlQueryObject.createSQLQuery();
  447.                 selectStmt = con.prepareStatement(selectQuery);
  448.                 selectStmt.setString(1, tipo);
  449.                 selectStmt.setString(2, nome);
  450.                 selectRS = selectStmt.executeQuery();
  451.                 if (selectRS.next())
  452.                     idSoggetto = selectRS.getLong("id");

  454.                 soggetto.setId(idSoggetto);

  456.                 selectRS.close();
  457.                 selectStmt.close();
  458.                 
  459.                 
  460.                 // ProtocolProperties
  461.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.CREATE, soggetto.getProtocolPropertyList(), 
  462.                         idSoggetto, ProprietariProtocolProperty.SOGGETTO, con, tipoDatabase, driverBYOK);
  463.                 
  464.                 
  465.                 // ruoli
  466.                 
  467.                 n = 0;
  468.                 if(soggetto.getRuoli()!=null && soggetto.getRuoli().sizeRuoloList()>0){
  469.                     for (int i = 0; i < soggetto.getRuoli().sizeRuoloList(); i++) {
  470.                         RuoloSoggetto ruoloSoggetto = soggetto.getRuoli().getRuolo(i);
  471.                         
  472.                         IDRuolo idRuoloObject= new IDRuolo(ruoloSoggetto.getNome());
  473.                         long idRuolo = DBUtils.getIdRuolo(idRuoloObject, con, DriverRegistroServiziDB_LIB.tipoDB);
  474.                         
  475.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  476.                         sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI_RUOLI);
  477.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  478.                         sqlQueryObject.addInsertField("id_ruolo", "?");
  479.                         updateQuery = sqlQueryObject.createSQLInsert();
  480.                         updateStmt = con.prepareStatement(updateQuery);
  481.                         
  482.                         updateStmt.setLong(1, idSoggetto);
  483.                         updateStmt.setLong(2, idRuolo);
  484.                         
  485.                         int r= updateStmt.executeUpdate();
  486.                         n++;
  487.                         updateStmt.close();
  488.                         DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + r+" create role ["+ruoloSoggetto.getNome()+"]");
  489.                     }
  490.                 }
  491.                 
  492.                 DriverRegistroServiziDB_LIB.logDebug("Aggiunti " + n + " ruoli al soggetto "+idSoggetto);
  493.                 
  494.                 
  495.                 // credenziali (le credenziali in questa tabella partono dal numero maggiore di 1)
  496.                 
  497.                 n = 0;
  498.                 if(soggetto.sizeCredenzialiList()>1){
  499.                     for (int i = 1; i < soggetto.sizeCredenzialiList(); i++) {
  500.                         CredenzialiSoggetto credenzialiSoggetto = soggetto.getCredenziali(i);
  501.                         
  502.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  503.                         sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI_CREDENZIALI);
  504.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  505.                         sqlQueryObject.addInsertField("subject", "?");
  506.                         sqlQueryObject.addInsertField("cn_subject", "?");
  507.                         sqlQueryObject.addInsertField("issuer", "?");
  508.                         sqlQueryObject.addInsertField("cn_issuer", "?");
  509.                         sqlQueryObject.addInsertField("certificate", "?");
  510.                         sqlQueryObject.addInsertField("cert_strict_verification", "?");
  511.                         updateQuery = sqlQueryObject.createSQLInsert();
  512.                         updateStmt = con.prepareStatement(updateQuery);
  513.                         
  514.                         index = 1;
  515.                         updateStmt.setLong(index++, idSoggetto);
  516.                         
  517.                         String subjectCredenziali = null;
  518.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getSubject()!=null && !"".equals(credenzialiSoggetto.getSubject()))
  519.                             subjectCredenziali = credenzialiSoggetto.getSubject();
  520.                         updateStmt.setString(index++, (subjectCredenziali != null ? CertificateUtils.formatPrincipal(subjectCredenziali, PrincipalType.SUBJECT) : null));
  521.                         String subjectCredenzialiCN = null;
  522.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getCnSubject()!=null && !"".equals(credenzialiSoggetto.getCnSubject()))
  523.                             subjectCredenzialiCN = credenzialiSoggetto.getCnSubject();
  524.                         updateStmt.setString(index++, subjectCredenzialiCN);
  525.                         
  526.                         String issuerCredenziali = null;
  527.                         if(credenzialiSoggetto != null && org.openspcoop2.core.registry.constants.CredenzialeTipo.APIKEY.equals(credenzialiSoggetto.getTipo())) {
  528.                             updateStmt.setString(index++, CostantiDB.getIssuerApiKey(credenzialiSoggetto.isAppId()));
  529.                         }
  530.                         else {
  531.                             if(credenzialiSoggetto!=null && credenzialiSoggetto.getIssuer()!=null && !"".equals(credenzialiSoggetto.getIssuer()))
  532.                                 issuerCredenziali = credenzialiSoggetto.getIssuer();
  533.                             updateStmt.setString(index++, (issuerCredenziali != null ? CertificateUtils.formatPrincipal(issuerCredenziali, PrincipalType.ISSUER) : null));
  534.                         }
  535.                         String issuerCredenzialiCN = null;
  536.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getCnIssuer()!=null && !"".equals(credenzialiSoggetto.getCnIssuer()))
  537.                             issuerCredenzialiCN = credenzialiSoggetto.getCnIssuer();
  538.                         updateStmt.setString(index++, issuerCredenzialiCN);
  539.                         
  540.                         byte [] certificateCredenziali = null;
  541.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getCertificate()!=null) {
  542.                             certificateCredenziali = credenzialiSoggetto.getCertificate();
  543.                         }
  544.                         jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverRegistroServiziDB_LIB.tipoDB);
  545.                         jdbcAdapter.setBinaryData(updateStmt, index++, certificateCredenziali);
  546.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.isCertificateStrictVerification()) {
  547.                             updateStmt.setInt(index++, CostantiDB.TRUE);
  548.                         }               
  549.                         else {
  550.                             updateStmt.setInt(index++, CostantiDB.FALSE);
  551.                         }
  552.                         
  553.                         int r = updateStmt.executeUpdate();
  554.                         n++;
  555.                         updateStmt.close();
  556.                         DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + r+" create credenziale");
  557.                     }
  558.                     
  559.                 }
  560.                 
  561.                 DriverRegistroServiziDB_LIB.logDebug("Aggiunte " + n + " credenziali al soggetto "+idSoggetto);
  562.                 
  563.                 
  564.                 // properties
  565.                 
  566.                 n = 0;
  567.                 if(soggetto.sizeProprietaList()>0){
  568.                     for (int i = 0; i < soggetto.sizeProprietaList(); i++) {
  569.                         
  570.                         Proprieta proprieta = soggetto.getProprieta(i);
  571.                         
  572.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  573.                         sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI_PROPS);
  574.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  575.                         sqlQueryObject.addInsertField("nome", "?");
  576.                         sqlQueryObject.addInsertField("valore", "?");
  577.                         sqlQueryObject.addInsertField("enc_value", "?");
  578.                         updateQuery = sqlQueryObject.createSQLInsert();
  579.                         updateStmt = con.prepareStatement(updateQuery);
  580.                         
  581.                         int indexP = 1;
  582.                         updateStmt.setLong(indexP++, idSoggetto);
  583.                         updateStmt.setString(indexP++, proprieta.getNome());
  584.                         
  585.                         String plainValue = proprieta.getValore();
  586.                         String encValue = null;
  587.                         if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValue) ) {
  588.                             BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  589.                             if(byokValue!=null) {
  590.                                 encValue = byokValue.getWrappedValue();
  591.                                 plainValue = byokValue.getWrappedPlainValue();
  592.                             }
  593.                         }
  594.                         
  595.                         updateStmt.setString(indexP++, plainValue);
  596.                         updateStmt.setString(indexP++, encValue);
  597.                         
  598.                         int r= updateStmt.executeUpdate();
  599.                         n++;
  600.                         updateStmt.close();
  601.                         DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + r+" create property ["+proprieta.getNome()+"]");
  602.                     }
  603.                 }
  604.                 
  605.                 DriverRegistroServiziDB_LIB.logDebug("Aggiunti " + n + " proprietà al soggetto "+idSoggetto);
  606.                 
  607.                 
  608.                 break;

  610.             case UPDATE:
  611.                 // UPDATE
  612.                 String oldNomeSoggetto = null;
  613.                 String oldTipoSoggetto = null;
  614.                 if(soggetto.getOldIDSoggettoForUpdate()!=null){
  615.                     oldNomeSoggetto = soggetto.getOldIDSoggettoForUpdate().getNome();
  616.                     oldTipoSoggetto = soggetto.getOldIDSoggettoForUpdate().getTipo();
  617.                 }

  619.                 // se i valori old... non sono settati allora uso quelli normali
  620.                 if (oldNomeSoggetto == null || oldNomeSoggetto.equals(""))
  621.                     oldNomeSoggetto = nome;
  622.                 if (oldTipoSoggetto == null || oldTipoSoggetto.equals(""))
  623.                     oldTipoSoggetto = tipo;

  625.                 String utenteUltimaModifica = null;
  626.                 if(soggetto.getProprietaOggetto()!=null && soggetto.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  627.                     utenteUltimaModifica = soggetto.getProprietaOggetto().getUtenteUltimaModifica();
  628.                 }
  629.                 else {
  630.                     utenteUltimaModifica = superUser;
  631.                 }
  632.                 
  633.                 Timestamp dataUltimaModifica = null;
  634.                 if(soggetto.getProprietaOggetto()!=null && soggetto.getProprietaOggetto().getDataUltimaModifica()!=null) {
  635.                     dataUltimaModifica = new Timestamp(soggetto.getProprietaOggetto().getDataUltimaModifica().getTime());
  636.                 }
  637.                 else {
  638.                     dataUltimaModifica = DateManager.getTimestamp();
  639.                 }
  640.                 
  641.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  642.                 sqlQueryObject.addUpdateTable(CostantiDB.SOGGETTI);
  643.                 sqlQueryObject.addUpdateField("nome_soggetto", "?");
  644.                 sqlQueryObject.addUpdateField("descrizione", "?");
  645.                 sqlQueryObject.addUpdateField("identificativo_porta", "?");
  646.                 sqlQueryObject.addUpdateField("tipo_soggetto", "?");
  647.                 sqlQueryObject.addUpdateField("server", "?");
  648.                 sqlQueryObject.addUpdateField("superuser", "?");
  649.                 sqlQueryObject.addUpdateField("privato", "?");
  650.                 sqlQueryObject.addUpdateField("profilo", "?");
  651.                 sqlQueryObject.addUpdateField("codice_ipa", "?");
  652.                 sqlQueryObject.addUpdateField("tipoauth", "?");
  653.                 sqlQueryObject.addUpdateField("utente", "?");
  654.                 sqlQueryObject.addUpdateField("password", "?");
  655.                 sqlQueryObject.addUpdateField("subject", "?");
  656.                 sqlQueryObject.addUpdateField("cn_subject", "?");
  657.                 sqlQueryObject.addUpdateField("issuer", "?");
  658.                 sqlQueryObject.addUpdateField("cn_issuer", "?");
  659.                 sqlQueryObject.addUpdateField("certificate", "?");
  660.                 sqlQueryObject.addUpdateField("cert_strict_verification", "?");
  661.                 if(soggetto.getOraRegistrazione()!=null)
  662.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  663.                 if(utenteUltimaModifica!=null) {
  664.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  665.                 }
  666.                 if(dataUltimaModifica!=null) {
  667.                     sqlQueryObject.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  668.                 }
  669.                 
  670.                 sqlQueryObject.addWhereCondition("id=?");
  671.                 updateQuery = sqlQueryObject.createSQLUpdate();
  672.                 updateStmt = con.prepareStatement(updateQuery);

  674.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreSoggetto(oldNomeSoggetto, oldTipoSoggetto, con);
  675.                 connettore.setId(idConnettore);

  677.                 idSoggetto = DBUtils.getIdSoggetto(oldNomeSoggetto, oldTipoSoggetto, con, DriverRegistroServiziDB_LIB.tipoDB);
  678.                 if (idSoggetto <= 0)
  679.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto(UPDATE)] Id Soggetto non valido.");

  681.                 index = 1;
  682.                 
  683.                 updateStmt.setString(index++, nome);
  684.                 updateStmt.setString(index++, descizione);
  685.                 updateStmt.setString(index++, identificativoPorta);
  686.                 updateStmt.setString(index++, tipo);
  687.                 updateStmt.setString(index++, server);
  688.                 updateStmt.setString(index++, superUser);
  689.                 if(soggetto.getPrivato()!=null && soggetto.getPrivato())
  690.                     updateStmt.setInt(index++, 1);
  691.                 else
  692.                     updateStmt.setInt(index++, 0);
  693.                 updateStmt.setString(index++, soggetto.getVersioneProtocollo());
  694.                 updateStmt.setString(index++, codiceIPA);
  695.                 
  696.                 credenziali = (soggetto.sizeCredenzialiList() > 0 ? soggetto.getCredenziali(0) : null);
  697.                 updateStmt.setString(index++, (credenziali != null ? DriverRegistroServiziDB_LIB.getValue(credenziali.getTipo()) : null));
  698.                 updateStmt.setString(index++, (credenziali != null ? credenziali.getUser() : null));
  699.                 updateStmt.setString(index++, (credenziali != null ? credenziali.getPassword() : null));
  700.                 
  701.                 subject = null;
  702.                 if(credenziali!=null && credenziali.getSubject()!=null && !"".equals(credenziali.getSubject()))
  703.                     subject = credenziali.getSubject();
  704.                 updateStmt.setString(index++, (subject != null ? CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT) : null));
  705.                 subjectCN = null;
  706.                 if(credenziali!=null && credenziali.getCnSubject()!=null && !"".equals(credenziali.getCnSubject()))
  707.                     subjectCN = credenziali.getCnSubject();
  708.                 updateStmt.setString(index++, subjectCN);
  709.                 
  710.                 issuer = null;
  711.                 if(credenziali != null && org.openspcoop2.core.registry.constants.CredenzialeTipo.APIKEY.equals(credenziali.getTipo())) {
  712.                     updateStmt.setString(index++, CostantiDB.getIssuerApiKey(credenziali.isAppId()));
  713.                 }
  714.                 else {
  715.                     if(credenziali!=null && credenziali.getIssuer()!=null && !"".equals(credenziali.getIssuer()))
  716.                         issuer = credenziali.getIssuer();
  717.                     updateStmt.setString(index++, (issuer != null ? CertificateUtils.formatPrincipal(issuer, PrincipalType.ISSUER) : null));
  718.                 }
  719.                 issuerCN = null;
  720.                 if(credenziali!=null && credenziali.getCnIssuer()!=null && !"".equals(credenziali.getCnIssuer()))
  721.                     issuerCN = credenziali.getCnIssuer();
  722.                 updateStmt.setString(index++, issuerCN);
  723.                 
  724.                 certificate = null;
  725.                 if(credenziali!=null && credenziali.getCertificate()!=null) {
  726.                     certificate = credenziali.getCertificate();
  727.                 }
  728.                 jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverRegistroServiziDB_LIB.tipoDB);
  729.                 jdbcAdapter.setBinaryData(updateStmt, index++, certificate);
  730.                 if(credenziali!=null && credenziali.isCertificateStrictVerification()) {
  731.                     updateStmt.setInt(index++, CostantiDB.TRUE);
  732.                 }               
  733.                 else {
  734.                     updateStmt.setInt(index++, CostantiDB.FALSE);
  735.                 }
  736.                 
  737.                 if(soggetto.getOraRegistrazione()!=null){
  738.                     updateStmt.setTimestamp(index++, new Timestamp(soggetto.getOraRegistrazione().getTime()));
  739.                 }
  740.                 
  741.                 if(utenteUltimaModifica!=null) {
  742.                     updateStmt.setString(index++, utenteUltimaModifica);
  743.                 }
  744.                 
  745.                 if(dataUltimaModifica!=null) {
  746.                     updateStmt.setTimestamp(index++, dataUltimaModifica);
  747.                 }
  748.                 
  749.                 updateStmt.setLong(index++, idSoggetto);

  751.                 // eseguo lo statement
  752.                 n = updateStmt.executeUpdate();
  753.                 updateStmt.close();
  754.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n);
  755.                 // modifico i dati del connettore
  756.                 //setto il nuovo nome
  757.                 String newNomeConnettore = "CNT_" + tipo + "_" + nome;
  758.                 connettore.setNome(newNomeConnettore);
  759.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(2, connettore, con, driverBYOK);

  761.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto UPDATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, nome, descizione, identificativoPorta, tipo, idSoggetto));

  763.                 
  764.                 // Ruoli
  765.                 
  766.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  767.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI_RUOLI);
  768.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  769.                 updateQuery = sqlQueryObject.createSQLDelete();
  770.                 updateStmt = con.prepareStatement(updateQuery);
  771.                 updateStmt.setLong(1, idSoggetto);
  772.                 n = updateStmt.executeUpdate();
  773.                 updateStmt.close();
  774.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n+" delete roles");
  775.                 
  776.                 n = 0;
  777.                 if(soggetto.getRuoli()!=null && soggetto.getRuoli().sizeRuoloList()>0){
  778.                     for (int i = 0; i < soggetto.getRuoli().sizeRuoloList(); i++) {
  779.                         RuoloSoggetto ruoloSoggetto = soggetto.getRuoli().getRuolo(i);
  780.                         
  781.                         IDRuolo idRuoloObject= new IDRuolo(ruoloSoggetto.getNome());
  782.                         long idRuolo = DBUtils.getIdRuolo(idRuoloObject, con, DriverRegistroServiziDB_LIB.tipoDB);
  783.                         
  784.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  785.                         sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI_RUOLI);
  786.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  787.                         sqlQueryObject.addInsertField("id_ruolo", "?");
  788.                         updateQuery = sqlQueryObject.createSQLInsert();
  789.                         updateStmt = con.prepareStatement(updateQuery);
  790.                         
  791.                         updateStmt.setLong(1, idSoggetto);
  792.                         updateStmt.setLong(2, idRuolo);
  793.                         
  794.                         int r = updateStmt.executeUpdate();
  795.                         n++;
  796.                         updateStmt.close();
  797.                         DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + r+" create role ["+ruoloSoggetto.getNome()+"]");
  798.                     }
  799.                 }
  800.                 
  801.                 DriverRegistroServiziDB_LIB.logDebug("Aggiunti " + n + " ruoli al soggetto "+idSoggetto);
  802.                 
  803.                 
  804.                 // credenziali (le credenziali in questa tabella partono dal numero maggiore di 1)

  806.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  807.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI_CREDENZIALI);
  808.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  809.                 updateQuery = sqlQueryObject.createSQLDelete();
  810.                 updateStmt = con.prepareStatement(updateQuery);
  811.                 updateStmt.setLong(1, idSoggetto);
  812.                 n = updateStmt.executeUpdate();
  813.                 updateStmt.close();
  814.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n+" delete roles");

  816.                 n = 0;
  817.                 if(soggetto.sizeCredenzialiList()>1){
  818.                     for (int i = 1; i < soggetto.sizeCredenzialiList(); i++) {
  819.                         CredenzialiSoggetto credenzialiSoggetto = soggetto.getCredenziali(i);
  820.                         
  821.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  822.                         sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI_CREDENZIALI);
  823.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  824.                         sqlQueryObject.addInsertField("subject", "?");
  825.                         sqlQueryObject.addInsertField("cn_subject", "?");
  826.                         sqlQueryObject.addInsertField("issuer", "?");
  827.                         sqlQueryObject.addInsertField("cn_issuer", "?");
  828.                         sqlQueryObject.addInsertField("certificate", "?");
  829.                         sqlQueryObject.addInsertField("cert_strict_verification", "?");
  830.                         updateQuery = sqlQueryObject.createSQLInsert();
  831.                         updateStmt = con.prepareStatement(updateQuery);
  832.                         
  833.                         index = 1;
  834.                         updateStmt.setLong(index++, idSoggetto);
  835.                         
  836.                         String subjectCredenziali = null;
  837.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getSubject()!=null && !"".equals(credenzialiSoggetto.getSubject()))
  838.                             subjectCredenziali = credenzialiSoggetto.getSubject();
  839.                         updateStmt.setString(index++, (subjectCredenziali != null ? CertificateUtils.formatPrincipal(subjectCredenziali, PrincipalType.SUBJECT) : null));
  840.                         String subjectCredenzialiCN = null;
  841.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getCnSubject()!=null && !"".equals(credenzialiSoggetto.getCnSubject()))
  842.                             subjectCredenzialiCN = credenzialiSoggetto.getCnSubject();
  843.                         updateStmt.setString(index++, subjectCredenzialiCN);
  844.                         
  845.                         String issuerCredenziali = null;
  846.                         if(credenzialiSoggetto != null && org.openspcoop2.core.registry.constants.CredenzialeTipo.APIKEY.equals(credenzialiSoggetto.getTipo())) {
  847.                             updateStmt.setString(index++, CostantiDB.getIssuerApiKey(credenzialiSoggetto.isAppId()));
  848.                         }
  849.                         else {
  850.                             if(credenzialiSoggetto!=null && credenzialiSoggetto.getIssuer()!=null && !"".equals(credenzialiSoggetto.getIssuer()))
  851.                                 issuerCredenziali = credenzialiSoggetto.getIssuer();
  852.                             updateStmt.setString(index++, (issuerCredenziali != null ? CertificateUtils.formatPrincipal(issuerCredenziali, PrincipalType.ISSUER) : null));
  853.                         }
  854.                         String issuerCredenzialiCN = null;
  855.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getCnIssuer()!=null && !"".equals(credenzialiSoggetto.getCnIssuer()))
  856.                             issuerCredenzialiCN = credenzialiSoggetto.getCnIssuer();
  857.                         updateStmt.setString(index++, issuerCredenzialiCN);
  858.                         
  859.                         byte [] certificateCredenziali = null;
  860.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.getCertificate()!=null) {
  861.                             certificateCredenziali = credenzialiSoggetto.getCertificate();
  862.                         }
  863.                         jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverRegistroServiziDB_LIB.tipoDB);
  864.                         jdbcAdapter.setBinaryData(updateStmt, index++, certificateCredenziali);
  865.                         if(credenzialiSoggetto!=null && credenzialiSoggetto.isCertificateStrictVerification()) {
  866.                             updateStmt.setInt(index++, CostantiDB.TRUE);
  867.                         }               
  868.                         else {
  869.                             updateStmt.setInt(index++, CostantiDB.FALSE);
  870.                         }
  871.                         
  872.                         int r = updateStmt.executeUpdate();
  873.                         n++;
  874.                         updateStmt.close();
  875.                         DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + r+" create credenziale");
  876.                     }
  877.                     
  878.                 }
  879.                 
  880.                 DriverRegistroServiziDB_LIB.logDebug("Aggiunte " + n + " credenziali al soggetto "+idSoggetto);
  881.                 
  882.                 
  883.                 // properties
  884.                 
  885.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  886.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI_PROPS);
  887.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  888.                 updateQuery = sqlQueryObject.createSQLDelete();
  889.                 updateStmt = con.prepareStatement(updateQuery);
  890.                 updateStmt.setLong(1, idSoggetto);
  891.                 n = updateStmt.executeUpdate();
  892.                 updateStmt.close();
  893.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n+" delete properties");
  894.                 
  895.                 n = 0;
  896.                 if(soggetto.sizeProprietaList()>0){
  897.                     for (int i = 0; i < soggetto.sizeProprietaList(); i++) {
  898.                         
  899.                         Proprieta proprieta = soggetto.getProprieta(i);
  900.                         
  901.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  902.                         sqlQueryObject.addInsertTable(CostantiDB.SOGGETTI_PROPS);
  903.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  904.                         sqlQueryObject.addInsertField("nome", "?");
  905.                         sqlQueryObject.addInsertField("valore", "?");
  906.                         sqlQueryObject.addInsertField("enc_value", "?");
  907.                         updateQuery = sqlQueryObject.createSQLInsert();
  908.                         updateStmt = con.prepareStatement(updateQuery);
  909.                         
  910.                         int indexP = 1;
  911.                         updateStmt.setLong(indexP++, idSoggetto);
  912.                         updateStmt.setString(indexP++, proprieta.getNome());

  914.                         String plainValue = proprieta.getValore();
  915.                         String encValue = null;
  916.                         if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValue) ) {
  917.                             BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  918.                             if(byokValue!=null) {
  919.                                 encValue = byokValue.getWrappedValue();
  920.                                 plainValue = byokValue.getWrappedPlainValue();
  921.                             }
  922.                         }
  923.                         
  924.                         updateStmt.setString(indexP++, plainValue);
  925.                         updateStmt.setString(indexP++, encValue);
  926.                         
  927.                         int r= updateStmt.executeUpdate();
  928.                         n++;
  929.                         updateStmt.close();
  930.                         DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + r+" create property ["+proprieta.getNome()+"]");
  931.                     }
  932.                 }
  933.                 
  934.                 DriverRegistroServiziDB_LIB.logDebug("Aggiunti " + n + " proprietà al soggetto "+idSoggetto);
  935.                 
  936.                 
  937.                 // ProtocolProperties
  938.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.UPDATE, soggetto.getProtocolPropertyList(), 
  939.                         idSoggetto, ProprietariProtocolProperty.SOGGETTO, con, tipoDatabase, driverBYOK);
  940.                 
  941.                 
  942.                 break;

  944.             case DELETE:
  945.                                 
  946.                 // DELETE

  948.                 idSoggetto = DBUtils.getIdSoggetto(nome, tipo, con, DriverRegistroServiziDB_LIB.tipoDB);
  949.                 idConnettore = DriverRegistroServiziDB_LIB.getIdConnettoreSoggetto(nome, tipo, con);
  950.                 if (idSoggetto <= 0)
  951.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto(DELETE)] Id Soggetto non valido.");
  952.                 
  953.                 // ProtocolProperties
  954.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.DELETE, null, 
  955.                         idSoggetto, ProprietariProtocolProperty.SOGGETTO, con, tipoDatabase, driverBYOK);
  956.                 
  957.                 // elimino le proprieta' del soggetto
  958.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  959.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI_PROPS);
  960.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  961.                 updateQuery = sqlQueryObject.createSQLDelete();
  962.                 updateStmt = con.prepareStatement(updateQuery);
  963.                 updateStmt.setLong(1, idSoggetto);
  964.                 n = updateStmt.executeUpdate();
  965.                 updateStmt.close();
  966.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n+" delete properties");
  967.                 
  968.                 // elimino le credenziali del soggetto
  969.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  970.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI_CREDENZIALI);
  971.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  972.                 updateQuery = sqlQueryObject.createSQLDelete();
  973.                 updateStmt = con.prepareStatement(updateQuery);
  974.                 updateStmt.setLong(1, idSoggetto);
  975.                 n = updateStmt.executeUpdate();
  976.                 updateStmt.close();
  977.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n+" delete credentials");
  978.                 
  979.                 // elimino i ruoli del soggetto
  980.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  981.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI_RUOLI);
  982.                 sqlQueryObject.addWhereCondition("id_soggetto=?");
  983.                 updateQuery = sqlQueryObject.createSQLDelete();
  984.                 updateStmt = con.prepareStatement(updateQuery);
  985.                 updateStmt.setLong(1, idSoggetto);
  986.                 n = updateStmt.executeUpdate();
  987.                 updateStmt.close();
  988.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n+" delete roles");
  989.                 
  990.                 // elimino il soggetto
  991.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  992.                 sqlQueryObject.addDeleteTable(CostantiDB.SOGGETTI);
  993.                 sqlQueryObject.addWhereCondition("id=?");
  994.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  995.                 updateStmt = con.prepareStatement(sqlQuery);
  996.                 updateStmt.setLong(1, idSoggetto);
  997.                 n=updateStmt.executeUpdate();
  998.                 updateStmt.close();
  999.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto type = " + type + " row affected =" + n);

  1001.                 // elimino il connettore
  1002.                 connettore=new Connettore();
  1003.                 connettore.setId(idConnettore);
  1004.                 DriverRegistroServiziDB_connettoriLIB.CRUDConnettore(3, connettore, con, driverBYOK);

  1006.                 DriverRegistroServiziDB_LIB.logDebug("CRUDSoggetto DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, idSoggetto));

  1008.                 break;
  1009.             }

  1011.             if (type == CostantiDB.CREATE) {
  1012.                 return idSoggetto;
  1013.             } else {
  1014.                 return n;
  1015.             }

  1017.         } catch (CoreException e) {
  1018.             throw new DriverRegistroServiziException(e);
  1019.         } catch (SQLException se) {
  1020.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto] SQLException [" + se.getMessage() + "].",se);
  1021.         }catch (Exception se) {
  1022.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDSoggetto] Exception [" + se.getMessage() + "].",se);
  1023.         } finally {
  1024.             JDBCUtilities.closeResources(updateStmt);
  1025.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1026.         }

  1028.     }

  1030.     
  1031. }
Created with JaCoCo 0.8.8.202204050719