DriverRegistroServiziDB_accordiCooperazioneLIB.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.util.ArrayList;
  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.constants.ProprietariProtocolProperty;
  42. import org.openspcoop2.core.id.IDAccordoCooperazione;
  43. import org.openspcoop2.core.id.IDSoggetto;
  44. import org.openspcoop2.core.registry.AccordoCooperazionePartecipanti;
  45. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioComposto;
  46. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
  47. import org.openspcoop2.core.registry.Documento;
  48. import org.openspcoop2.core.registry.IdSoggetto;
  49. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  50. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  51. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  52. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  53. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  54. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  55. import org.openspcoop2.utils.sql.ISQLQueryObject;
  56. import org.openspcoop2.utils.sql.SQLObjectFactory;

  58. /**
  59.  * Classe utilizzata per effettuare query ad un registro dei servizi openspcoop
  60.  * formato db.
  61.  * 
  62.  * 
  63.  * @author Sandra Giangrandi (sandra@link.it)
  64.  * @author Stefano Corallo (corallo@link.it)
  65.  * @author $Author$
  66.  * @version $Rev$, $Date$
  67.  */
  68. public class DriverRegistroServiziDB_accordiCooperazioneLIB {
  69.     
  70.         
  71.     
  72.     public static void CRUDAccordoServizioParteComuneServizioComposto(int type, AccordoServizioParteComuneServizioComposto asServComposto, Connection con, long idAccordo) throws DriverRegistroServiziException {
  73.         PreparedStatement updateStmt = null;
  74.         String updateQuery;
  75.         PreparedStatement selectStmt = null;
  76.         ResultSet selectRS = null;
  77.         if (idAccordo <= 0)
  78.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID Accordo non valido.");
  79.         
  80. //      if(asServComposto!=null){
  81. //          if (asServComposto.getIdAccordoCooperazione() <= 0 && (type==CostantiDB.CREATE || type==CostantiDB.UPDATE)){
  82. //              
  83. //          }
  84. //              new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID Accordo Cooperazione non valido.");
  85. //      }
  86.         
  87.         try {
  88.             switch (type) {
  89.             case CREATE:
  90.                 // create
  91.                 
  92.                 if (asServComposto == null)
  93.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] Accordo Cooperazione non valido.");
  94.                 
  95.                 long idAccordoCooperazione = -1;
  96.                 if(asServComposto.getIdAccordoCooperazione()!=null){
  97.                     idAccordoCooperazione = asServComposto.getIdAccordoCooperazione();
  98.                 }
  99.                 //if(idAccordoCooperazione<=0){
  100.                 // Necessario sempre per la sincronizzazione
  101.                 if(asServComposto.getAccordoCooperazione()!=null){
  102.                     idAccordoCooperazione = 
  103.                             DBUtils.getIdAccordoCooperazione(IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromUri(asServComposto.getAccordoCooperazione()),
  104.                                 con, DriverRegistroServiziDB_LIB.tipoDB);
  105.                 }
  106.                 //}
  107.                 if(idAccordoCooperazione<=0){
  108.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] idAccordoCooperazione non fornito");
  109.                 }
  110.                 
  111.                 // Servizio composto
  112.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  113.                 sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  114.                 sqlQueryObject.addInsertField("id_accordo", "?");
  115.                 sqlQueryObject.addInsertField("id_accordo_cooperazione", "?");
  116.                 updateQuery = sqlQueryObject.createSQLInsert();
  117.                 updateStmt = con.prepareStatement(updateQuery);
  118.                 updateStmt.setLong(1, idAccordo);
  119.                 updateStmt.setLong(2, idAccordoCooperazione);
  120.                 updateStmt.executeUpdate();
  121.                 updateStmt.close();
  122.                 DriverRegistroServiziDB_LIB.log.debug("Aggiungo acc servizio composto");

  124.                 // Recupero id
  125.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  126.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  127.                 sqlQueryObject.addSelectField("id");
  128.                 sqlQueryObject.addWhereCondition("id_accordo=?");
  129.                 sqlQueryObject.setANDLogicOperator(true);
  130.                 updateQuery = sqlQueryObject.createSQLQuery();
  131.                 updateStmt = con.prepareStatement(updateQuery);
  132.                 updateStmt.setLong(1, idAccordo);
  133.                 selectRS = updateStmt.executeQuery();
  134.                 long idAccServComposto = -1;
  135.                 if(selectRS.next()){
  136.                     idAccServComposto = selectRS.getLong("id");
  137.                     asServComposto.setId(idAccServComposto);
  138.                 }else{
  139.                     throw new  DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID AccordoServizioComposto inserito non recuperato.");
  140.                 }
  141.                 selectRS.close();
  142.                 updateStmt.close();
  143.                 
  144.                 // Servizio componenti
  145.                 for(int i=0; i< asServComposto.sizeServizioComponenteList(); i++){
  146.                 
  147.                     AccordoServizioParteComuneServizioCompostoServizioComponente tmp = asServComposto.getServizioComponente(i);
  148.                     long idServizioComponente = -1;
  149.                     //if(idServizioComponente<=0){
  150.                     // Necessario sempre per la sincronizzazione
  151.                     // Provo a prenderlo attraverso la uri dell'accordo
  152.                     if(tmp.getTipoSoggetto()!=null && tmp.getNomeSoggetto()!=null && tmp.getTipo()!=null && tmp.getNome()!=null){
  153.                         // Provo a prenderlo attraverso la uri dell'accordo
  154.                         DriverRegistroServiziDB_LIB.log.debug("Provo a recuperare l'id del servizio con tipo/nome soggetto erogatore ["+tmp.getTipoSoggetto()+"/"+tmp.getNomeSoggetto()
  155.                                 +"] e tipo/nome servizio ["+tmp.getTipo()+"/"+tmp.getNome()+"]");
  156.                         if(tmp.getTipoSoggetto()!=null && tmp.getNomeSoggetto()!=null && tmp.getTipo()!=null  &&  tmp.getNome()!=null)
  157.                             idServizioComponente = DBUtils.getIdServizio(tmp.getNome(), tmp.getTipo(), tmp.getVersione(), tmp.getNomeSoggetto(), tmp.getTipoSoggetto(), con, DriverRegistroServiziDB_LIB.tipoDB);
  158.                     }
  159.                     if(idServizioComponente<=0){
  160.                         idServizioComponente = tmp.getIdServizioComponente();
  161.                     }
  162.                     //}
  163.                     if(idServizioComponente <=0 )
  164.                         throw new  DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID ServizioComponente non definito.");
  165.                             
  166.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  167.                     sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  168.                     sqlQueryObject.addInsertField("id_servizio_composto", "?");
  169.                     sqlQueryObject.addInsertField("id_servizio_componente", "?");
  170.                     sqlQueryObject.addInsertField("azione", "?");
  171.                     updateQuery = sqlQueryObject.createSQLInsert();
  172.                     updateStmt = con.prepareStatement(updateQuery);
  173.                     updateStmt.setLong(1, idAccServComposto);
  174.                     updateStmt.setLong(2, idServizioComponente);
  175.                     updateStmt.setString(3, tmp.getAzione());
  176.                     updateStmt.executeUpdate();
  177.                     updateStmt.close();
  178.                     DriverRegistroServiziDB_LIB.log.debug("Aggiunto acc servizio componente");
  179.                     
  180.                 }

  182.                                 
  183.                 break;

  185.             case UPDATE:
  186.                 // update
  187.                 
  188.                 if (asServComposto == null)
  189.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] Accordo Cooperazione non valido.");
  190.                 
  191.                 idAccServComposto = asServComposto.getId();
  192.                 if(idAccServComposto <=0 )
  193.                     throw new  DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID AccordoServizioComposto non definito.");
  194.                 
  195.                 
  196.                 idAccordoCooperazione = -1;
  197.                 if(asServComposto.getIdAccordoCooperazione()!=null){
  198.                     idAccordoCooperazione = asServComposto.getIdAccordoCooperazione();
  199.                 }
  200.                 //if(idAccordoCooperazione<=0){
  201.                 // Necessario sempre per la sincronizzazione
  202.                 if(asServComposto.getAccordoCooperazione()!=null){
  203.                     idAccordoCooperazione = 
  204.                             DBUtils.getIdAccordoCooperazione(IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromUri(asServComposto.getAccordoCooperazione()),
  205.                                 con, DriverRegistroServiziDB_LIB.tipoDB);
  206.                 }
  207.                 //}
  208.                 if(idAccordoCooperazione<=0){
  209.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] idAccordoCooperazione non fornito");
  210.                 }
  211.                 
  212.                 
  213.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  214.                 sqlQueryObject.addUpdateTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  215.                 sqlQueryObject.addUpdateField("id_accordo_cooperazione", "?");
  216.                 sqlQueryObject.addWhereCondition("id=?");
  217.                 sqlQueryObject.setANDLogicOperator(true);
  218.                 updateQuery = sqlQueryObject.createSQLUpdate();
  219.                 updateStmt = con.prepareStatement(updateQuery);
  220.                 updateStmt.setLong(1, idAccordoCooperazione);
  221.                 updateStmt.executeUpdate();
  222.                 updateStmt.close();
  223.                 DriverRegistroServiziDB_LIB.log.debug("Aggiornato acc servizio composto");
  224.                 
  225.                 // Elimino vecchi servizi componenti
  226.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  227.                 sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  228.                 sqlQueryObject.addWhereCondition("id_servizio_composto=?");
  229.                 sqlQueryObject.setANDLogicOperator(true);
  230.                 updateQuery = sqlQueryObject.createSQLDelete();
  231.                 updateStmt = con.prepareStatement(updateQuery);
  232.                 updateStmt.setLong(1, idAccServComposto);
  233.                 updateStmt.executeUpdate();
  234.                 updateStmt.close();

  236.                 // Inserisco nuovi servizi componenti
  237.                 for(int i=0; i< asServComposto.sizeServizioComponenteList(); i++){
  238.                     
  239.                     AccordoServizioParteComuneServizioCompostoServizioComponente tmp = asServComposto.getServizioComponente(i);
  240.                     long idServizioComponente = -1;
  241.                     //if(idServizioComponente<=0){
  242.                     // Necessario sempre per la sincronizzazione
  243.                     // Provo a prenderlo attraverso la uri dell'accordo
  244.                     if(tmp.getTipoSoggetto()!=null && tmp.getNomeSoggetto()!=null && tmp.getTipo()!=null && tmp.getNome()!=null){
  245.                         // Provo a prenderlo attraverso la uri dell'accordo
  246.                         DriverRegistroServiziDB_LIB.log.debug("Provo a recuperare l'id del servizio con tipo/nome soggetto erogatore ["+tmp.getTipoSoggetto()+"/"+tmp.getNomeSoggetto()
  247.                                 +"] e tipo/nome servizio ["+tmp.getTipo()+"/"+tmp.getNome()+"]");
  248.                         if(tmp.getTipoSoggetto()!=null && tmp.getNomeSoggetto()!=null && tmp.getTipo()!=null  &&  tmp.getNome()!=null)
  249.                             idServizioComponente = DBUtils.getIdServizio(tmp.getNome(), tmp.getTipo(), tmp.getVersione(), tmp.getNomeSoggetto(), tmp.getTipoSoggetto(), con, DriverRegistroServiziDB_LIB.tipoDB);
  250.                     }
  251.                     if(idServizioComponente<=0){
  252.                         idServizioComponente = tmp.getIdServizioComponente();
  253.                     }
  254.                     if(idServizioComponente <=0 )
  255.                         throw new  DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID ServizioComponente non definito.");
  256.                         
  257.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  258.                     sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  259.                     sqlQueryObject.addInsertField("id_servizio_composto", "?");
  260.                     sqlQueryObject.addInsertField("id_servizio_componente", "?");
  261.                     sqlQueryObject.addInsertField("azione", "?");
  262.                     updateQuery = sqlQueryObject.createSQLInsert();
  263.                     updateStmt = con.prepareStatement(updateQuery);
  264.                     updateStmt.setLong(1, idAccServComposto);
  265.                     updateStmt.setLong(2, idServizioComponente);
  266.                     updateStmt.setString(3, tmp.getAzione());
  267.                     updateStmt.executeUpdate();
  268.                     updateStmt.close();
  269.                     DriverRegistroServiziDB_LIB.log.debug("Aggiungo acc servizio componente");
  270.                     
  271.                 }
  272.                 
  273.                 break;

  275.             case DELETE:
  276.                 // delete

  278.                 idAccServComposto = -1;
  279.                 
  280.                 if(asServComposto!=null){
  281.                     idAccServComposto = asServComposto.getId();
  282.                     if(idAccServComposto <=0 ){
  283.                         //throw new  DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID AccordoServizioComposto non definito.");
  284.                         
  285.                         // lo cerco
  286.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  287.                         sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  288.                         sqlQueryObject.addSelectField("id");
  289.                         sqlQueryObject.addWhereCondition("id_accordo=?");
  290.                         updateQuery = sqlQueryObject.createSQLQuery();
  291.                         updateStmt = con.prepareStatement(updateQuery);
  292.                         updateStmt.setLong(1, idAccordo);
  293.                         selectRS = updateStmt.executeQuery();
  294.                         if(selectRS.next()){
  295.                             idAccServComposto = selectRS.getLong("id");
  296.                         }
  297.                         selectRS.close();
  298.                         updateStmt.close();
  299.                         
  300.                         if(idAccServComposto <=0 ){
  301.                             throw new  DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] ID AccordoServizioComposto non definito e non recuperabile.");
  302.                         }
  303.                     }
  304.                 }else{
  305.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  306.                     sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  307.                     sqlQueryObject.addSelectField("id");
  308.                     sqlQueryObject.addWhereCondition("id_accordo=?");
  309.                     updateQuery = sqlQueryObject.createSQLQuery();
  310.                     updateStmt = con.prepareStatement(updateQuery);
  311.                     updateStmt.setLong(1, idAccordo);
  312.                     selectRS = updateStmt.executeQuery();
  313.                     if(selectRS.next()){
  314.                         idAccServComposto = selectRS.getLong("id");
  315.                     }
  316.                     selectRS.close();
  317.                     updateStmt.close();
  318.                 }
  319.                 
  320.                 if(idAccServComposto>0){
  321.                 
  322.                     // Elimino vecchi servizi componenti
  323.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  324.                     sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  325.                     sqlQueryObject.addWhereCondition("id_servizio_composto=?");
  326.                     sqlQueryObject.setANDLogicOperator(true);
  327.                     updateQuery = sqlQueryObject.createSQLDelete();
  328.                     updateStmt = con.prepareStatement(updateQuery);
  329.                     updateStmt.setLong(1, idAccServComposto);
  330.                     updateStmt.executeUpdate();
  331.                     updateStmt.close();
  332.                     
  333.                     // Elimino servizio composto
  334.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  335.                     sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  336.                     sqlQueryObject.addWhereCondition("id=?");
  337.                     sqlQueryObject.setANDLogicOperator(true);
  338.                     updateQuery = sqlQueryObject.createSQLDelete();
  339.                     updateStmt = con.prepareStatement(updateQuery);
  340.                     updateStmt.setLong(1, idAccServComposto);
  341.                     updateStmt.executeUpdate();
  342.                     updateStmt.close();

  344.                 }
  345.                 
  346.                 break;
  347.             }

  349.         } catch (SQLException se) {
  350.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] SQLException : " + se.getMessage(),se);
  351.         } catch (Exception se) {
  352.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoServizioServizioComposto] Exception : " + se.getMessage(),se);
  353.         } finally {
  354.             JDBCUtilities.closeResources(selectRS, selectStmt);
  355.             JDBCUtilities.closeResources(updateStmt);
  356.         }
  357.     }
  358.     
  359.     
  360.     
  361.     
  362.     
  363.     
  364.     /**
  365.      * Accordo di Cooperazione CRUD
  366.      */
  367.     public static void CRUDAccordoCooperazione(int type, org.openspcoop2.core.registry.AccordoCooperazione accordoCooperazione, 
  368.             Connection con, String tipoDatabase, IDriverBYOK driverBYOK) throws DriverRegistroServiziException {
  369.         if (accordoCooperazione == null)
  370.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoCooperazione] Accordo di Cooperazione non valido.");

  372.         String nome = accordoCooperazione.getNome();
  373.         String descrizione = accordoCooperazione.getDescrizione();
  374.         
  375.         String stato = accordoCooperazione.getStatoPackage();
  376.         boolean privato = accordoCooperazione.getPrivato()!=null && accordoCooperazione.getPrivato();
  377.         String superUser = accordoCooperazione.getSuperUser();  
  378.         
  379.         if (nome == null || nome.equals(""))
  380.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoCooperazione] Parametro Nome non valido.");
  381.         
  382.         IDSoggetto soggettoReferente = null;
  383.         if(accordoCooperazione.getSoggettoReferente()!=null){
  384.             soggettoReferente = new IDSoggetto(accordoCooperazione.getSoggettoReferente().getTipo(), accordoCooperazione.getSoggettoReferente().getNome());
  385.         }
  386.         
  387.         PreparedStatement updateStmt = null;
  388.         ResultSet updateRS = null;
  389.         try {
  390.             
  391.             switch (type) {
  392.             case CREATE:
  393.                 // CREATE

  395.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  396.                 sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_COOPERAZIONE);
  397.                 sqlQueryObject.addInsertField("nome", "?");
  398.                 sqlQueryObject.addInsertField("descrizione", "?");
  399.                 sqlQueryObject.addInsertField("versione", "?");
  400.                 sqlQueryObject.addInsertField("privato", "?");
  401.                 sqlQueryObject.addInsertField("superuser", "?");
  402.                 if(stato!=null)
  403.                     sqlQueryObject.addInsertField("stato", "?");
  404.                 if(accordoCooperazione.getSoggettoReferente()!=null)
  405.                     sqlQueryObject.addInsertField("id_referente", "?");
  406.                 if(accordoCooperazione.getOraRegistrazione()!=null)
  407.                     sqlQueryObject.addInsertField("ora_registrazione", "?");
  408.                 
  409.                 String updateQuery = sqlQueryObject.createSQLInsert();
  410.                 updateStmt = con.prepareStatement(updateQuery);

  412.                 updateStmt.setString(1, nome);
  413.                 updateStmt.setString(2, descrizione);
  414.                 
  415.                 updateStmt.setInt(3, accordoCooperazione.getVersione());
  416.                 
  417.                 if(privato)
  418.                     updateStmt.setInt(4, 1);
  419.                 else
  420.                     updateStmt.setInt(4, 0);
  421.                 updateStmt.setString(5, superUser);
  422.                 
  423.                 int index = 6;
  424.                 
  425.                 if(stato!=null){
  426.                     updateStmt.setString(index, stato);
  427.                     index++;
  428.                 }
  429.                 
  430.                 if(accordoCooperazione.getSoggettoReferente()!=null){
  431.                     long idReferente = DBUtils.getIdSoggetto(accordoCooperazione.getSoggettoReferente().getNome(), accordoCooperazione.getSoggettoReferente().getTipo(), con, DriverRegistroServiziDB_LIB.tipoDB);
  432.                     if(idReferente<=0){
  433.                         throw new DriverRegistroServiziException("Soggetto Referente ["+accordoCooperazione.getSoggettoReferente().getTipo()+"/"+accordoCooperazione.getSoggettoReferente().getNome()+"] non trovato");
  434.                     }
  435.                     updateStmt.setLong(index, idReferente);
  436.                     index++;
  437.                 }
  438.                 
  439.                 if(accordoCooperazione.getOraRegistrazione()!=null){
  440.                     updateStmt.setTimestamp(index, new Timestamp(accordoCooperazione.getOraRegistrazione().getTime()));
  441.                     index++;
  442.                 }
  443.                 
  444.                 // eseguo lo statement
  445.                 int n = updateStmt.executeUpdate();
  446.                 updateStmt.close();
  447.                 DriverRegistroServiziDB_LIB.log.debug("CRUDAccordoServizioParteSpecifica CREATE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(updateQuery, nome, descrizione));
  448.                 DriverRegistroServiziDB_LIB.log.debug("CRUDAccordoServizioParteSpecifica type = " + type + " row affected =" + n);

  450.                 
  451.                 // recupero l-id dell'accordo appena inserito
  452.                 IDAccordoCooperazione idAccordoObject = IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromValues(accordoCooperazione.getNome(),
  453.                         soggettoReferente, accordoCooperazione.getVersione());
  454.                 long idAccordoCooperazione = DBUtils.getIdAccordoCooperazione(idAccordoObject, con, DriverRegistroServiziDB_LIB.tipoDB);
  455.                 if (idAccordoCooperazione<=0) {
  456.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB::CRUDAccordoCooperazione] non riesco a trovare l'id del'Accordo inserito");
  457.                 }
  458.                 accordoCooperazione.setId(idAccordoCooperazione);
  459.                                 
  460.                 
  461.                 // aggiungo partecipanti
  462.                 if(accordoCooperazione.getElencoPartecipanti()!=null){
  463.                     AccordoCooperazionePartecipanti partecipanti = accordoCooperazione.getElencoPartecipanti();
  464.                     for(int i=0; i<partecipanti.sizeSoggettoPartecipanteList(); i++){
  465.                         
  466.                         IdSoggetto soggettoPartecipante = partecipanti.getSoggettoPartecipante(i);
  467.                         long idSoggettoPartecipante = -1;
  468.                         if(idSoggettoPartecipante <=0 ){
  469.                             // Provo a prenderlo attraverso il tipo/nome
  470.                             DriverRegistroServiziDB_LIB.log.debug("Provo a recuperare l'id del soggetto con tipo/nome ["+soggettoPartecipante.getTipo()+"]/["+soggettoPartecipante.getNome()+"]");
  471.                             if(soggettoPartecipante.getTipo()!=null && soggettoPartecipante.getNome()!=null)
  472.                                 idSoggettoPartecipante = DBUtils.getIdSoggetto(soggettoPartecipante.getNome(),soggettoPartecipante.getTipo(), con, DriverRegistroServiziDB_LIB.tipoDB);
  473.                         }
  474.                         if(idSoggettoPartecipante<=0){
  475.                             idSoggettoPartecipante = soggettoPartecipante.getIdSoggetto();
  476.                         }
  477.                         if(idSoggettoPartecipante<=0)
  478.                             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::CRUDAccordoCooperazione] idSoggettoPartecipante non presente");
  479.                         
  480.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  481.                         sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_COOPERAZIONE_PARTECIPANTI);
  482.                         sqlQueryObject.addInsertField("id_accordo_cooperazione", "?");
  483.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  484.                         updateQuery = sqlQueryObject.createSQLInsert();
  485.                         updateStmt = con.prepareStatement(updateQuery);
  486.     
  487.                         updateStmt.setLong(1, idAccordoCooperazione);
  488.                         updateStmt.setLong(2, idSoggettoPartecipante);
  489.                         
  490.                         n = updateStmt.executeUpdate();
  491.                         updateStmt.close();
  492.                         DriverRegistroServiziDB_LIB.log.debug("CRUDAccordoCooperazione (servizioComposto) type = " + type + " row affected =" + n);
  493.                     }
  494.                 }
  495.                 
  496.                 
  497.                 // Documenti generici servizio
  498.                 List<Documento> documenti = new ArrayList<Documento>();
  499.                 // Allegati
  500.                 for(int i=0; i<accordoCooperazione.sizeAllegatoList(); i++){
  501.                     Documento doc = accordoCooperazione.getAllegato(i);
  502.                     doc.setRuolo(RuoliDocumento.allegato.toString());
  503.                     documenti.add(doc);
  504.                 }
  505.                 // Specifiche Semiformali
  506.                 for(int i=0; i<accordoCooperazione.sizeSpecificaSemiformaleList(); i++){
  507.                     Documento doc = accordoCooperazione.getSpecificaSemiformale(i);
  508.                     doc.setRuolo(RuoliDocumento.specificaSemiformale.toString());
  509.                     documenti.add(doc);
  510.                 }
  511.                 // CRUD
  512.                 DriverRegistroServiziDB_documentiLIB.CRUDDocumento(CostantiDB.CREATE, documenti, idAccordoCooperazione, ProprietariDocumento.accordoCooperazione, con, tipoDatabase);
  513.                 
  514.                 
  515.                 // ProtocolProperties
  516.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.CREATE, accordoCooperazione.getProtocolPropertyList(), 
  517.                         idAccordoCooperazione, ProprietariProtocolProperty.ACCORDO_COOPERAZIONE, con, tipoDatabase, driverBYOK);
  518.                 

  520.                 break;

  522.             case UPDATE:
  523.                 // UPDATE
  524.                 
  525.                 IDAccordoCooperazione idAccordoAttualeInseritoDB = null;
  526.                 if(accordoCooperazione.getOldIDAccordoForUpdate()!=null){
  527.                     idAccordoAttualeInseritoDB = accordoCooperazione.getOldIDAccordoForUpdate();
  528.                 }else{
  529.                     idAccordoAttualeInseritoDB = IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromAccordo(accordoCooperazione);
  530.                 }
  531.                 
  532.                 long idAccordoLong = DBUtils.getIdAccordoCooperazione(idAccordoAttualeInseritoDB, con,DriverRegistroServiziDB_LIB.tipoDB);

  534.                 if (idAccordoLong <= 0)
  535.                     throw new DriverRegistroServiziException("Impossibile recuperare l'id dell'Accordo di Cooperazione : " + nome);
  536.                 
  537.                 
  538.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  539.                 sqlQueryObject.addUpdateTable(CostantiDB.ACCORDI_COOPERAZIONE);
  540.                 sqlQueryObject.addUpdateField("nome", "?");
  541.                 sqlQueryObject.addUpdateField("descrizione", "?");
  542.                 sqlQueryObject.addUpdateField("versione", "?");
  543.                 sqlQueryObject.addUpdateField("privato", "?");
  544.                 sqlQueryObject.addUpdateField("superuser", "?");
  545.                 sqlQueryObject.addUpdateField("id_referente", "?");
  546.                 if(stato!=null)
  547.                     sqlQueryObject.addUpdateField("stato", "?");
  548.                 if(accordoCooperazione.getOraRegistrazione()!=null)
  549.                     sqlQueryObject.addUpdateField("ora_registrazione", "?");
  550.                 sqlQueryObject.addWhereCondition("id=?");
  551.                 
  552.                 updateQuery = sqlQueryObject.createSQLUpdate();
  553.                 updateStmt = con.prepareStatement(updateQuery);
  554.                 
  555.                 updateStmt.setString(1, nome);
  556.                 updateStmt.setString(2, descrizione);
  557.                 
  558.                 updateStmt.setInt(3, accordoCooperazione.getVersione());
  559.                 
  560.                 if(privato)
  561.                     updateStmt.setInt(4, 1);
  562.                 else
  563.                     updateStmt.setInt(4, 0);
  564.                 updateStmt.setString(5, superUser);
  565.                 
  566.                 index = 6;
  567.                 
  568.                 if(accordoCooperazione.getSoggettoReferente()!=null) {
  569.                     long idSRef = DBUtils.getIdSoggetto(accordoCooperazione.getSoggettoReferente().getNome(), 
  570.                             accordoCooperazione.getSoggettoReferente().getTipo(), con, DriverRegistroServiziDB_LIB.tipoDB);
  571.                     updateStmt.setLong(index, idSRef);
  572.                 }else{
  573.                     updateStmt.setLong(index, CostantiRegistroServizi.SOGGETTO_REFERENTE_DEFAULT);
  574.                 }
  575.                 index++;
  576.                 
  577.                 if(stato!=null){
  578.                     updateStmt.setString(index, stato);
  579.                     index++;
  580.                 }
  581.                 
  582.                 if(accordoCooperazione.getOraRegistrazione()!=null){
  583.                     updateStmt.setTimestamp(index, new Timestamp(accordoCooperazione.getOraRegistrazione().getTime()));
  584.                     index++;
  585.                 }
  586.                 
  587.                 updateStmt.setLong(index, idAccordoLong);
  588.                 
  589.                 n = updateStmt.executeUpdate();
  590.                 updateStmt.close();
  591.                 DriverRegistroServiziDB_LIB.log.debug("CRUDAccordoCooperazione type = " + type + " row affected =" + n);
  592.                 
  593.                 
  594.                 /*
  595.                 // update servizi componenti, elimino i vecchi e riaggiungo i nuovi
  596.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  597.                 sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_COOPERAZIONE_SERVIZI_COMPOSTI);
  598.                 sqlQueryObject.addWhereCondition("id_accordo_cooperazione=?");
  599.                 sqlQueryObject.setANDLogicOperator(true);
  600.                 updateQuery = sqlQueryObject.createSQLDelete();
  601.                 updateStmt = con.prepareStatement(updateQuery);
  602.                 updateStmt.setLong(1, idAccordoLong);
  603.                 updateStmt.executeUpdate();
  604.                 updateStmt.close();
  605.                 
  606.                 // aggiungo servizi componenti
  607.                 for(int i=0; i<accordoCooperazione.sizeServizioCompostoList(); i++){
  608.                     
  609.                     AccordoCooperazioneServizioComposto sComposto = accordoCooperazione.getServizioComposto(i);
  610.                     long idAccordoServizioComposto = sComposto.getIdAccordo();
  611.                     if(idAccordoServizioComposto <=0 ){
  612.                         // Provo a prenderlo attraverso la uri dell'accordo
  613.                         DriverRegistroServiziDB_LIB.log.debug("Provo a recuperare l'id dell'accordo di servizio con uri ["+sComposto.getNomeAccordoServizio()+"]");
  614.                         if(sComposto.getNomeAccordoServizio()!=null)
  615.                             idAccordoServizioComposto = DBUtils.getIdAccordoServizio(IDAccordo.getIDAccordoFromUri(sComposto.getNomeAccordoServizio()), con, DriverRegistroServiziDB_LIB.tipoDB);
  616.                     }
  617.                     if(idAccordoServizioComposto<=0)
  618.                         throw new DriverRegistroServiziException("[DriverRegistroServiziDB::CRUDAccordoCooperazione] idAccordoServizio composto non presente");
  619.                     
  620.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  621.                     sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_COOPERAZIONE_SERVIZI_COMPOSTI);
  622.                     sqlQueryObject.addInsertField("id_accordo_cooperazione", "?");
  623.                     sqlQueryObject.addInsertField("id_accordo_servizio", "?");
  624.                     updateQuery = sqlQueryObject.createSQLInsert();
  625.                     updateStmt = con.prepareStatement(updateQuery);

  627.                     updateStmt.setLong(1, idAccordoLong);
  628.                     updateStmt.setLong(2, idAccordoServizioComposto);
  629.                     
  630.                     n = updateStmt.executeUpdate();
  631.                     updateStmt.close();
  632.                     DriverRegistroServiziDB_LIB.log.debug("CRUDAccordoCooperazione (Partecipante) type = " + type + " row affected =" + n);
  633.                 }*/
  634.                 
  635.                 
  636.                 // update partecipanti, elimino i vecchi e riaggiungo i nuovi
  637.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  638.                 sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_COOPERAZIONE_PARTECIPANTI);
  639.                 sqlQueryObject.addWhereCondition("id_accordo_cooperazione=?");
  640.                 sqlQueryObject.setANDLogicOperator(true);
  641.                 updateQuery = sqlQueryObject.createSQLDelete();
  642.                 updateStmt = con.prepareStatement(updateQuery);
  643.                 updateStmt.setLong(1, idAccordoLong);
  644.                 updateStmt.executeUpdate();
  645.                 updateStmt.close();
  646.                 
  647.                 // aggiungo partecipanti
  648.                 if(accordoCooperazione.getElencoPartecipanti()!=null){
  649.                     AccordoCooperazionePartecipanti partecipanti = accordoCooperazione.getElencoPartecipanti();
  650.                     for(int i=0; i<partecipanti.sizeSoggettoPartecipanteList(); i++){
  651.                         
  652.                         IdSoggetto soggettoPartecipante = partecipanti.getSoggettoPartecipante(i);
  653.                     
  654.                         Long idSoggettoPartecipante = -1L;
  655.                         if(idSoggettoPartecipante==null || idSoggettoPartecipante <=0 ){
  656.                             // Provo a prenderlo attraverso il tipo/nome
  657.                             DriverRegistroServiziDB_LIB.log.debug("Provo a recuperare l'id del soggetto con tipo/nome ["+soggettoPartecipante.getTipo()+"]/["+soggettoPartecipante.getNome()+"]");
  658.                             if(soggettoPartecipante.getTipo()!=null && soggettoPartecipante.getNome()!=null)
  659.                                 idSoggettoPartecipante = DBUtils.getIdSoggetto(soggettoPartecipante.getNome(),soggettoPartecipante.getTipo(), con, DriverRegistroServiziDB_LIB.tipoDB);
  660.                         }
  661.                         if(idSoggettoPartecipante<=0){
  662.                             idSoggettoPartecipante = soggettoPartecipante.getIdSoggetto();
  663.                         }
  664.                         if(idSoggettoPartecipante<=0)
  665.                             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::CRUDAccordoCooperazione] idSoggettoPartecipante non presente");
  666.                         
  667.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  668.                         sqlQueryObject.addInsertTable(CostantiDB.ACCORDI_COOPERAZIONE_PARTECIPANTI);
  669.                         sqlQueryObject.addInsertField("id_accordo_cooperazione", "?");
  670.                         sqlQueryObject.addInsertField("id_soggetto", "?");
  671.                         updateQuery = sqlQueryObject.createSQLInsert();
  672.                         updateStmt = con.prepareStatement(updateQuery);
  673.     
  674.                         updateStmt.setLong(1, idAccordoLong);
  675.                         updateStmt.setLong(2, idSoggettoPartecipante);
  676.                         
  677.                         n = updateStmt.executeUpdate();
  678.                         updateStmt.close();
  679.                         DriverRegistroServiziDB_LIB.log.debug("CRUDAccordoCooperazione (servizioComposto) type = " + type + " row affected =" + n);
  680.                     }
  681.                 }
  682.                 
  683.                 
  684.                 // Documenti generici servizio
  685.                 documenti = new ArrayList<Documento>();
  686.                 // Allegati
  687.                 for(int i=0; i<accordoCooperazione.sizeAllegatoList(); i++){
  688.                     Documento doc = accordoCooperazione.getAllegato(i);
  689.                     doc.setRuolo(RuoliDocumento.allegato.toString());
  690.                     documenti.add(doc);
  691.                 }
  692.                 // Specifiche Semiformali
  693.                 for(int i=0; i<accordoCooperazione.sizeSpecificaSemiformaleList(); i++){
  694.                     Documento doc = accordoCooperazione.getSpecificaSemiformale(i);
  695.                     doc.setRuolo(RuoliDocumento.specificaSemiformale.toString());
  696.                     documenti.add(doc);
  697.                 }
  698.                 // CRUD
  699.                 DriverRegistroServiziDB_documentiLIB.CRUDDocumento(CostantiDB.UPDATE, documenti, idAccordoLong, ProprietariDocumento.accordoCooperazione, con,tipoDatabase);
  700.                 
  701.                 
  702.                 // ProtocolProperties
  703.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.UPDATE, accordoCooperazione.getProtocolPropertyList(), 
  704.                         idAccordoLong, ProprietariProtocolProperty.ACCORDO_COOPERAZIONE, con, tipoDatabase, driverBYOK);
  705.                 
  706.                 
  707.                 
  708.                 break;

  710.             case DELETE:
  711.                 // DELETE
  712.                 
  713.                 IDAccordoCooperazione idAccordo = IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromValues(nome,soggettoReferente,accordoCooperazione.getVersione());
  714.                 idAccordoLong = DBUtils.getIdAccordoCooperazione(idAccordo, con, DriverRegistroServiziDB_LIB.tipoDB);
  715.                 if (idAccordoLong <= 0)
  716.                     throw new DriverRegistroServiziException("Impossibile recuperare l'id dell'Accordo di Cooperazione : " + nome);
  717.                 
  718.                 /*
  719.                 // delete servizi componenti
  720.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  721.                 sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_COOPERAZIONE_SERVIZI_COMPOSTI);
  722.                 sqlQueryObject.addWhereCondition("id_accordo_cooperazione=?");
  723.                 sqlQueryObject.setANDLogicOperator(true);
  724.                 updateQuery = sqlQueryObject.createSQLDelete();
  725.                 updateStmt = con.prepareStatement(updateQuery);
  726.                 updateStmt.setLong(1, idAccordoLong);
  727.                 updateStmt.executeUpdate();
  728.                 updateStmt.close();
  729.                 */
  730.                 
  731.                 // delete partecipanti
  732.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  733.                 sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_COOPERAZIONE_PARTECIPANTI);
  734.                 sqlQueryObject.addWhereCondition("id_accordo_cooperazione=?");
  735.                 sqlQueryObject.setANDLogicOperator(true);
  736.                 updateQuery = sqlQueryObject.createSQLDelete();
  737.                 updateStmt = con.prepareStatement(updateQuery);
  738.                 updateStmt.setLong(1, idAccordoLong);
  739.                 updateStmt.executeUpdate();
  740.                 updateStmt.close();
  741.                 
  742.                 // Documenti generici accordo di servizio
  743.                 // Allegati
  744.                 // Specifiche Semiformali
  745.                 DriverRegistroServiziDB_documentiLIB.CRUDDocumento(CostantiDB.DELETE, null, idAccordoLong, ProprietariDocumento.accordoCooperazione, con,tipoDatabase);
  746.                 
  747.                 
  748.                 // ProtocolProperties
  749.                 DriverRegistroServiziDB_LIB.CRUDProtocolProperty(CostantiDB.DELETE, null, 
  750.                         idAccordoLong, ProprietariProtocolProperty.ACCORDO_COOPERAZIONE, con, tipoDatabase, driverBYOK);
  751.                 
  752.                 
  753.                 // delete Accordo di Cooperazione
  754.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  755.                 sqlQueryObject.addDeleteTable(CostantiDB.ACCORDI_COOPERAZIONE);
  756.                 sqlQueryObject.addWhereCondition("id=?");
  757.                 sqlQueryObject.setANDLogicOperator(true);
  758.                 updateQuery = sqlQueryObject.createSQLDelete();
  759.                 updateStmt = con.prepareStatement(updateQuery);
  760.                 updateStmt.setLong(1, idAccordoLong);
  761.                 updateStmt.executeUpdate();
  762.                 updateStmt.close();

  764.                 break;
  765.             }

  767.         } catch (CoreException e) {
  768.             throw new DriverRegistroServiziException(e);
  769.         } catch (SQLException se) {
  770.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoCooperazione] SQLException [" + se.getMessage() + "].", se);

  772.         } catch (Exception se) {
  773.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDAccordoCooperazione] Exception [" + se.getMessage() + "].", se);

  775.         } finally {
  776.             JDBCUtilities.closeResources(updateRS, updateStmt);
  777.         }

  779.     }
  780.     
  781. }
Created with JaCoCo 0.8.8.202204050719