DBMappingUtils.java

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

  21. package org.openspcoop2.core.mapping;

  23. import java.sql.Connection;
  24. import java.sql.PreparedStatement;
  25. import java.sql.ResultSet;
  26. import java.util.ArrayList;
  27. import java.util.List;

  29. import org.openspcoop2.core.commons.CoreException;
  30. import org.openspcoop2.core.commons.DBUtils;
  31. import org.openspcoop2.core.commons.ISearch;
  32. import org.openspcoop2.core.commons.Liste;
  33. import org.openspcoop2.core.constants.CostantiDB;
  34. import org.openspcoop2.core.id.IDPortaApplicativa;
  35. import org.openspcoop2.core.id.IDPortaDelegata;
  36. import org.openspcoop2.core.id.IDServizio;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.core.id.IdentificativiErogazione;
  39. import org.openspcoop2.core.id.IdentificativiFruizione;
  40. import org.openspcoop2.utils.sql.ISQLQueryObject;
  41. import org.openspcoop2.utils.sql.SQLObjectFactory;

  43. /**
  44.  * Funzioni di utilita utilizzate dai driver
  45.  *
  46.  * @author Andrea Poli (apoli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class DBMappingUtils {

  52.     // -- MAPPING EROGAZIONE

  54.     public static int countMappingErogazione(Connection con, String tipoDB) throws CoreException{
  55.         return _countMappingErogazione(con, tipoDB, CostantiDB.SOGGETTI);
  56.     }
  57.     public static int countMappingErogazione(Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  58.         return _countMappingErogazione(con, tipoDB, tabellaSoggetti);
  59.     }
  60.     private static int _countMappingErogazione(Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  61.         PreparedStatement stmt = null;
  62.         ResultSet rs = null;
  63.         try {

  65.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  66.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  67.             sqlQueryObject.addSelectCountField("id","mapping_count");
  68.             String queryString = sqlQueryObject.createSQLQuery();
  69.             stmt = con.prepareStatement(queryString);
  70.             rs = stmt.executeQuery();
  71.             if (rs.next()) {
  72.                 return rs.getInt("mapping_count");
  73.             }
  74.             else{
  75.                 return 0;
  76.             }
  77.             
  78.         }catch(Exception e){
  79.             throw new CoreException("createMappingErogazione error",e);
  80.         } finally {

  82.             //Chiudo statement and resultset
  83.             try{
  84.                 if(rs!=null) rs.close();
  85.             }catch (Exception e) {
  86.                 //ignore
  87.             }
  88.             try{
  89.                 if(stmt!=null) stmt.close();
  90.             }catch (Exception e) {
  91.                 //ignore
  92.             }

  94.         }
  95.     }
  96.     
  97.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  98.             IDServizio idServizio, 
  99.             ISearch ricerca,boolean ricerca_useOffsetLimit,
  100.             boolean orderByDescrizione) throws CoreException{
  101.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  102.                 idServizio, DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(), 
  103.                         idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(), 
  104.                         con, tipoDB), 
  105.                 ricerca, ricerca_useOffsetLimit,CostantiDB.SOGGETTI,
  106.                 orderByDescrizione);
  107.     }
  108.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  109.             IDServizio idServizio, 
  110.             ISearch ricerca,boolean ricerca_useOffsetLimit,String tabellaSoggetti,
  111.             boolean orderByDescrizione) throws CoreException{
  112.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  113.                 idServizio, DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(), 
  114.                         idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(), 
  115.                         con, tipoDB), 
  116.                 ricerca, ricerca_useOffsetLimit,tabellaSoggetti,
  117.                 orderByDescrizione);
  118.     }
  119.     
  120.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  121.             IDServizio idServizio,
  122.             boolean orderByDescrizione) throws CoreException{
  123.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  124.                 idServizio, DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(), 
  125.                         idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(), 
  126.                         con, tipoDB), 
  127.                 null,false,CostantiDB.SOGGETTI,
  128.                 orderByDescrizione);
  129.     }
  130.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  131.             IDServizio idServizio, 
  132.             String tabellaSoggetti,
  133.             boolean orderByDescrizione) throws CoreException{
  134.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  135.                 idServizio, DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(), 
  136.                         idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(), 
  137.                         con, tipoDB), 
  138.                 null,false,tabellaSoggetti,
  139.                 orderByDescrizione);
  140.     }
  141.     
  142.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  143.             IDServizio idServizio, long idServizioAsLong, 
  144.             ISearch ricerca,boolean ricerca_useOffsetLimit,
  145.             boolean orderByDescrizione) throws CoreException{
  146.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  147.                 idServizio, idServizioAsLong, 
  148.                 ricerca, ricerca_useOffsetLimit,CostantiDB.SOGGETTI,
  149.                 orderByDescrizione);
  150.     }
  151.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  152.             IDServizio idServizio, long idServizioAsLong, 
  153.             ISearch ricerca,boolean ricerca_useOffsetLimit,String tabellaSoggetti,
  154.             boolean orderByDescrizione) throws CoreException{
  155.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  156.                 idServizio, idServizioAsLong, 
  157.                 ricerca, ricerca_useOffsetLimit,tabellaSoggetti,
  158.                 orderByDescrizione);
  159.     }
  160.     
  161.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  162.             IDServizio idServizio, long idServizioAsLong,
  163.             boolean orderByDescrizione) throws CoreException{
  164.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  165.                 idServizio, idServizioAsLong, 
  166.                 null,false,CostantiDB.SOGGETTI,
  167.                 orderByDescrizione);
  168.     }
  169.     public static List<MappingErogazionePortaApplicativa> mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  170.             IDServizio idServizio, long idServizioAsLong, 
  171.             String tabellaSoggetti,
  172.             boolean orderByDescrizione) throws CoreException{
  173.         return _mappingErogazionePortaApplicativaList(con, tipoDB, 
  174.                 idServizio, idServizioAsLong, 
  175.                 null,false,tabellaSoggetti,
  176.                 orderByDescrizione);
  177.     }
  178.     
  179.     private static List<MappingErogazionePortaApplicativa> _mappingErogazionePortaApplicativaList(Connection con, String tipoDB, 
  180.             IDServizio idServizio, long idServizioAsLong, 
  181.             ISearch ricerca,boolean ricerca_useOffsetLimit,String tabellaSoggetti,
  182.             boolean orderByDescrizione) throws CoreException{
  183.         int idLista = Liste.CONFIGURAZIONE_EROGAZIONE;
  184.         int offset = 0;
  185.         int limit = 0;
  186.         String search = "";
  187.         String queryString;

  189.         if(ricerca != null) {
  190.             if(ricerca_useOffsetLimit) {
  191.                 limit = ricerca.getPageSize(idLista);
  192.                 offset = ricerca.getIndexIniziale(idLista);
  193.             }
  194.             search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  195.         }
  196.         
  197.         PreparedStatement stmt = null;
  198.         ResultSet risultato = null;
  199.         
  200.         List<MappingErogazionePortaApplicativa> lista = new ArrayList<MappingErogazionePortaApplicativa>();
  201.         try {
  202.             if(ricerca != null) {
  203.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  204.                 sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  205.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  206.                 sqlQueryObject.addSelectCountField("*", "cont");
  207.                 sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".id_erogazione = ?");
  208.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  209.                 if (!search.equals("")) {
  210.                     sqlQueryObject.addWhereCondition(false, 
  211.                             sqlQueryObject.getWhereLikeCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".nome", search, true, true));
  212.                             //sqlQueryObject.getWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE +".nome_porta", search, true, true));
  213.                 } 
  214.                 
  215.                 sqlQueryObject.setANDLogicOperator(true);
  216.                 queryString = sqlQueryObject.createSQLQuery();
  217.                 stmt = con.prepareStatement(queryString);
  218.                 int index = 1;
  219.                 stmt.setLong(index++, idServizioAsLong);
  220.                 
  221.                 risultato = stmt.executeQuery();
  222.                 if (risultato.next())
  223.                     ricerca.setNumEntries(idLista,risultato.getInt(1));
  224.                 risultato.close();
  225.                 stmt.close();
  226.             }
  227.             
  228.             // ricavo le entries
  229.             if (limit == 0) // con limit
  230.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  231.             
  232.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  233.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  234.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  235.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_EROGAZIONE_PA+".id_erogazione");
  236.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  237.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_EROGAZIONE_PA+".is_default");
  238.             sqlQueryObject.addSelectAliasField(CostantiDB.MAPPING_EROGAZIONE_PA,"nome","nomeMapping");
  239.             sqlQueryObject.addSelectAliasField(CostantiDB.MAPPING_EROGAZIONE_PA,"descrizione","descrizioneMapping");
  240.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_EROGAZIONE_PA+".id");
  241.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  242.             sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".id_erogazione = ?");
  243.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  244.             
  245.             if (ricerca!=null && !search.equals("")) {
  246.                 sqlQueryObject.addWhereCondition(false, 
  247.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".nome", search, true, true));
  248.                         //sqlQueryObject.getWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE +".nome_porta", search, true, true));
  249.             } 
  250.             sqlQueryObject.setANDLogicOperator(true);
  251.             sqlQueryObject.addOrderBy(CostantiDB.MAPPING_EROGAZIONE_PA+".is_default",true);
  252.             if(orderByDescrizione) {
  253.                 sqlQueryObject.addOrderBy("descrizioneMapping");
  254.             }
  255.             else {
  256.                 sqlQueryObject.addOrderBy("nomeMapping");
  257.             }
  258.             sqlQueryObject.setSortType(true);
  259.             if(ricerca != null) {
  260.                 sqlQueryObject.setLimit(limit);
  261.                 sqlQueryObject.setOffset(offset);
  262.             }
  263.             queryString = sqlQueryObject.createSQLQuery();
  264.             
  265.             stmt = con.prepareStatement(queryString);
  266.             
  267.             int index = 1;
  268.             stmt.setLong(index++, idServizioAsLong);
  269.             
  270.             risultato = stmt.executeQuery();
  271.             
  272.             MappingErogazionePortaApplicativa mapping = null;

  274.             while (risultato.next()) {

  276.                 mapping = new MappingErogazionePortaApplicativa();
  277.                 
  278.                 Long id = risultato.getLong("id");
  279. //              Long idPorta = risultato.getLong("id_porta");
  280. //              Long idErogazione = risultato.getLong("id_erogazione");
  281.                 String nome = risultato.getString("nomeMapping");
  282.                 String descrizione = risultato.getString("descrizioneMapping");
  283.                 Integer isDefaultInt = risultato.getInt("is_default");
  284.                 boolean isDefault = isDefaultInt > 0 ;
  285.                 
  286.                 mapping.setNome(nome);
  287.                 mapping.setDescrizione(descrizione);
  288.                 mapping.setTableId(id);
  289.                 mapping.setDefault(isDefault);
  290.                 // evitiamo una join utilizzo l'id che mi sono passato come parametro
  291.                 mapping.setIdServizio(idServizio);
  292.                 
  293.                 IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  294.                 String nomePorta = risultato.getString("nome_porta");
  295.                 idPortaApplicativa.setNome(nomePorta);
  296.                 
  297.                 IdentificativiErogazione identificativiErogazione = new IdentificativiErogazione();
  298.                 identificativiErogazione.setIdServizio(idServizio);
  299.                 idPortaApplicativa.setIdentificativiErogazione(identificativiErogazione);
  300.                 
  301.                 mapping.setIdPortaApplicativa(idPortaApplicativa);

  303.                 lista.add(mapping);

  305.             }
  306.             
  307.         }catch(Exception e){
  308.             throw new CoreException("mappingErogazionePortaApplicativaList error",e);
  309.         } finally {

  311.             //Chiudo statement and resultset
  312.             try{
  313.                 if(risultato!=null) risultato.close();
  314.             }catch (Exception e) {
  315.                 //ignore
  316.             }
  317.             try{
  318.                 if(stmt!=null) stmt.close();
  319.             }catch (Exception e) {
  320.                 //ignore
  321.             }

  323.         }
  324.         
  325.         
  326.         return lista;
  327.     }
  328.     
  329.     
  330.     public static void createMappingErogazione(String nome, String descrizione, boolean isDefault, IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,  
  331.             Connection con, String tipoDB) throws CoreException{
  332.         createMappingErogazione(nome, descrizione, isDefault, idServizio, idPortaApplicativa, con, tipoDB, CostantiDB.SOGGETTI);
  333.     }
  334.     public static void createMappingErogazione(String nome, String descrizione, boolean isDefault, IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  335.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  336.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  337.         if(idServizioLong<=0){
  338.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  339.         }
  340.         _createMappingErogazione(nome, descrizione, isDefault, idServizioLong, idPortaApplicativa, con, tipoDB, tabellaSoggetti);
  341.     }
  342.     
  343.     private static void _createMappingErogazione(String nome, String descrizione, boolean isDefault, long idServizioLong, IDPortaApplicativa idPortaApplicativa,
  344.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  345.         PreparedStatement stmt = null;

  347.         try {

  349.             if(idServizioLong<=0){
  350.                 throw new Exception("IdServizio non fornito");
  351.             }
  352.             long idPA = DBUtils.getIdPortaApplicativa(idPortaApplicativa.getNome(), con, tipoDB);
  353.             if(idPA<=0){
  354.                 throw new Exception("PortaApplicativa ["+idPortaApplicativa+"] non esistente");
  355.             }
  356.             
  357.             int isDefaultInt = isDefault ? 1 : 0;
  358.             
  359.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  360.             sqlQueryObject.addInsertTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  361.             sqlQueryObject.addInsertField("id_erogazione", "?");
  362.             sqlQueryObject.addInsertField("id_porta", "?");
  363.             sqlQueryObject.addInsertField("nome", "?");
  364.             sqlQueryObject.addInsertField("descrizione", "?");
  365.             sqlQueryObject.addInsertField("is_default", "?");
  366.             String queryString = sqlQueryObject.createSQLInsert();
  367.             stmt = con.prepareStatement(queryString);
  368.             int index = 1;
  369.             stmt.setLong(index++, idServizioLong);
  370.             stmt.setLong(index++, idPA);
  371.             stmt.setString(index++, nome);
  372.             stmt.setString(index++, descrizione);
  373.             stmt.setInt(index++, isDefaultInt);
  374.             stmt.executeUpdate();
  375.             stmt.close();
  376.             
  377.         }catch(Exception e){
  378.             throw new CoreException("Creazione Mapping Erogazione fallita: "+e.getMessage(),e);
  379.         } finally {

  381.             //Chiudo statement and resultset
  382.             try{
  383.                 if(stmt!=null) stmt.close();
  384.             }catch (Exception e) {
  385.                 //ignore
  386.             }

  388.         }
  389.     }
  390.     
  391.     
  392.     public static void updateMappingErogazione(long tableId, String descrizione, Connection con, String tipoDB) throws CoreException{
  393.         PreparedStatement stmt = null;

  395.         try {

  397.             if(tableId<=0){
  398.                 throw new Exception("TableId non fornito");
  399.             }
  400.             
  401.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  402.             sqlQueryObject.addUpdateTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  403.             sqlQueryObject.addUpdateField("descrizione", "?");
  404.             sqlQueryObject.addWhereCondition("id=?");
  405.             String queryString = sqlQueryObject.createSQLUpdate();
  406.             stmt = con.prepareStatement(queryString);
  407.             int index = 1;
  408.             stmt.setString(index++, descrizione);
  409.             stmt.setLong(index++, tableId);
  410.             stmt.executeUpdate();
  411.             stmt.close();
  412.             
  413.         }catch(Exception e){
  414.             throw new CoreException("updateMappingErogazione error",e);
  415.         } finally {

  417.             //Chiudo statement and resultset
  418.             try{
  419.                 if(stmt!=null) stmt.close();
  420.             }catch (Exception e) {
  421.                 //ignore
  422.             }

  424.         }
  425.     }
  426.     
  427.         
  428.     public static void deleteMappingErogazione(IDServizio idServizio, 
  429.             Connection con, String tipoDB) throws CoreException{
  430.         deleteMappingErogazione(idServizio, null, con, tipoDB, CostantiDB.SOGGETTI);
  431.     }
  432.     public static void deleteMappingErogazione(IDServizio idServizio, 
  433.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  434.         deleteMappingErogazione(idServizio, null, con, tipoDB, tabellaSoggetti);
  435.     }
  436.     public static void deleteMappingErogazione(IDServizio idServizio, boolean deletePorte,
  437.             Connection con, String tipoDB) throws CoreException{
  438.         deleteMappingErogazione(idServizio, deletePorte, con, tipoDB, CostantiDB.SOGGETTI);
  439.     }
  440.     public static void deleteMappingErogazione(IDServizio idServizio, boolean deletePorte,
  441.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  442.         List<IDPortaApplicativa> list = null;
  443.         if(deletePorte) {
  444.             list = getIDPorteApplicativeAssociate(idServizio, con, tipoDB);
  445.         }
  446.         deleteMappingErogazione(idServizio, null, con, tipoDB, tabellaSoggetti);
  447.         if(list!=null && list.size()>0) {
  448.             for (IDPortaApplicativa idPortaApplicativa : list) {
  449.                 PreparedStatement stmt = null;
  450.                 try {
  451.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  452.                     sqlQueryObject.addDeleteTable(CostantiDB.PORTE_APPLICATIVE);
  453.                     sqlQueryObject.addWhereCondition("id=?");
  454.                     sqlQueryObject.setANDLogicOperator(true);
  455.                     String queryString = sqlQueryObject.createSQLDelete();
  456.                     stmt = con.prepareStatement(queryString);
  457.                     stmt.setLong(1, DBUtils.getIdPortaApplicativa(idPortaApplicativa.getNome(), con, tipoDB));
  458.                     stmt.executeUpdate();
  459.                     stmt.close();
  460.                 }catch(Exception e){
  461.                     throw new CoreException("deletePAMappingErogazione error",e);
  462.                 } finally {

  464.                     //Chiudo statement and resultset
  465.                     try{
  466.                         if(stmt!=null) stmt.close();
  467.                     }catch (Exception e) {
  468.                         //ignore
  469.                     }

  471.                 }
  472.             }
  473.         }
  474.     }
  475.     public static void deleteMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  476.             Connection con, String tipoDB) throws CoreException{
  477.         deleteMappingErogazione(idServizio, idPortaApplicativa, con, tipoDB, CostantiDB.SOGGETTI);
  478.     }
  479.     public static void deleteMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  480.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  481.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  482.         if(idServizioLong<=0){
  483.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  484.         }
  485.         _deleteMappingErogazione(idServizioLong, idPortaApplicativa, con, tipoDB, tabellaSoggetti);
  486.     }
  487.     
  488.     private static void _deleteMappingErogazione(long idServizioLong, IDPortaApplicativa idPortaApplicativa,
  489.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  490.         PreparedStatement stmt = null;

  492.         try {

  494.             if(idServizioLong<=0){
  495.                 throw new Exception("IdServizio non fornito");
  496.             }
  497.             long idPA = -1;
  498.             if(idPortaApplicativa!=null){
  499.                 idPA = DBUtils.getIdPortaApplicativa(idPortaApplicativa.getNome(), con, tipoDB);
  500.                 if(idPA<=0){
  501.                     throw new Exception("PortaApplicativa ["+idPortaApplicativa+"] non esistente");
  502.                 }
  503.             }
  504.             
  505.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  506.             sqlQueryObject.addDeleteTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  507.             sqlQueryObject.addWhereCondition("id_erogazione=?");
  508.             if(idPortaApplicativa!=null){
  509.                 sqlQueryObject.addWhereCondition("id_porta=?");
  510.             }
  511.             sqlQueryObject.setANDLogicOperator(true);
  512.             String queryString = sqlQueryObject.createSQLDelete();
  513.             stmt = con.prepareStatement(queryString);
  514.             stmt.setLong(1, idServizioLong);
  515.             if(idPortaApplicativa!=null){
  516.                 stmt.setLong(2, idPA);
  517.             }
  518.             stmt.executeUpdate();
  519.             stmt.close();
  520.             
  521.         }catch(Exception e){
  522.             throw new CoreException("deleteMappingErogazione error",e);
  523.         } finally {

  525.             //Chiudo statement and resultset
  526.             try{
  527.                 if(stmt!=null) stmt.close();
  528.             }catch (Exception e) {
  529.                 //ignore
  530.             }

  532.         }
  533.     }
  534.         

  536.     public static IDPortaApplicativa getIDPortaApplicativaAssociataDefault(IDServizio idServizio,
  537.             Connection con, String tipoDB) throws CoreException {
  538.         return getIDPortaApplicativaAssociataDefault(idServizio, con, tipoDB, CostantiDB.SOGGETTI);
  539.     }
  540.     public static IDPortaApplicativa getIDPortaApplicativaAssociataDefault(IDServizio idServizio,
  541.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  542.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  543.         if(idServizioLong<=0){
  544.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  545.         }
  546.         List<IDPortaApplicativa> l = _getIDPorteApplicativeAssociate(idServizioLong, true, null, con, tipoDB, tabellaSoggetti,
  547.                 idServizio);
  548.         if(l!=null && l.size()>0) {
  549.             if(l.size()>1) {
  550.                 throw new CoreException("Esiste più di un mapping di default per l'erogazione del servizio ["+idServizio.toString()+"]");
  551.             }
  552.             return l.get(0);
  553.         }
  554.         return null;
  555.     }
  556.     
  557.     public static IDPortaApplicativa getIDPortaApplicativaAssociataAzione(IDServizio idServizio,
  558.             Connection con, String tipoDB) throws CoreException {
  559.         return getIDPortaApplicativaAssociataAzione(idServizio, con, tipoDB, CostantiDB.SOGGETTI);
  560.     }
  561.     public static IDPortaApplicativa getIDPortaApplicativaAssociataAzione(IDServizio idServizio,
  562.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  563.         if(idServizio.getAzione()==null) {
  564.             throw new CoreException("Azione non indicata nel parametro 'idServizio'");
  565.         }
  566.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  567.         if(idServizioLong<=0){
  568.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  569.         }
  570.         List<IDPortaApplicativa> l = _getIDPorteApplicativeAssociate(idServizioLong, false, idServizio.getAzione(), con, tipoDB, tabellaSoggetti,
  571.                 idServizio);
  572.         if(l!=null && l.size()>0) {
  573.             if(l.size()>1) {
  574.                 throw new CoreException("Esiste più di un mapping per l'erogazione dell'azione '"+idServizio.getAzione()+"' del servizio ["+idServizio.toString()+"]");
  575.             }
  576.             return l.get(0);
  577.         }
  578.         return null;
  579.     }
  580.     
  581.     public static List<IDPortaApplicativa> getIDPorteApplicativeAssociate(IDServizio idServizio,
  582.             Connection con, String tipoDB) throws CoreException {
  583.         return getIDPorteApplicativeAssociate(idServizio, con, tipoDB, CostantiDB.SOGGETTI);
  584.     }
  585.     public static List<IDPortaApplicativa> getIDPorteApplicativeAssociate(IDServizio idServizio, 
  586.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  587.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  588.         if(idServizioLong<=0){
  589.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  590.         }
  591.         return _getIDPorteApplicativeAssociate(idServizioLong, false, null, con, tipoDB, tabellaSoggetti,
  592.                 idServizio);
  593.     }
  594.     
  595.     private static List<IDPortaApplicativa> _getIDPorteApplicativeAssociate(long idServizioLong, boolean defaultMapping, String azioneMapping,
  596.             Connection con, String tipoDB,String tabellaSoggetti,
  597.             IDServizio idServizio) throws CoreException {
  598.         PreparedStatement stm = null;
  599.         ResultSet rs = null;

  601.         try {

  603.             if(idServizioLong<=0){
  604.                 throw new Exception("IdServizio non fornito");
  605.             }

  607.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  608.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  609.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  610.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  611.             sqlQueryObject.addWhereCondition("id_erogazione = ?");
  612.             if(defaultMapping) {
  613.                 sqlQueryObject.addWhereCondition("is_default = ?");
  614.             }
  615.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  616.             if(azioneMapping!=null) {
  617.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AZIONI);
  618.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.PORTE_APPLICATIVE_AZIONI+".id_porta");
  619.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".azione = ?");
  620.             }
  621.             sqlQueryObject.setANDLogicOperator(true);
  622.             String sqlQuery = sqlQueryObject.createSQLQuery();
  623.             stm = con.prepareStatement(sqlQuery);
  624.             int indexStmt = 1;
  625.             stm.setLong(indexStmt++,idServizioLong);
  626.             if(defaultMapping) {
  627.                 stm.setInt(indexStmt++,1);
  628.             }
  629.             if(azioneMapping!=null) {
  630.                 stm.setString(indexStmt++,azioneMapping);
  631.             }
  632.         
  633.             rs = stm.executeQuery();
  634.             List<IDPortaApplicativa> list = new ArrayList<IDPortaApplicativa>();
  635.             while (rs.next()) {
  636.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  637.                 String nome = rs.getString("nome_porta");
  638.                 idPA.setNome(nome);
  639.                 
  640.                 IdentificativiErogazione identificativiErogazione = new IdentificativiErogazione();
  641.                 identificativiErogazione.setIdServizio(idServizio);
  642.                 idPA.setIdentificativiErogazione(identificativiErogazione);
  643.                 
  644.                 list.add(idPA);
  645.             }
  646.             if(list.size()<=0){
  647.                 return null;
  648.             }
  649.             else {
  650.                 return list;
  651.             }
  652.         }catch(CoreException de){
  653.             throw de;
  654.         }
  655.         catch(Exception e){
  656.             throw new CoreException("getIDPortaApplicativaAssociata error",e);
  657.         } finally {

  659.             //Chiudo statement and resultset
  660.             try{
  661.                 if(rs!=null) rs.close();
  662.             }catch (Exception e) {
  663.                 //ignore
  664.             }
  665.             try{
  666.                 if(stm!=null) stm.close();
  667.             }catch (Exception e) {
  668.                 //ignore
  669.             }

  671.         }
  672.     }
  673.     
  674.     public static boolean existsIDPortaApplicativaAssociataDefault(IDServizio idServizio,
  675.             Connection con, String tipoDB) throws CoreException {
  676.         return existsIDPortaApplicativaAssociataDefault(idServizio, con, tipoDB, CostantiDB.SOGGETTI);
  677.     }
  678.     public static boolean existsIDPortaApplicativaAssociataDefault(IDServizio idServizio, 
  679.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  680.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  681.         if(idServizioLong<=0){
  682.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  683.         }
  684.         int c = _countIDPorteApplicativeAssociate(idServizioLong, true, null, con, tipoDB, tabellaSoggetti);
  685.         if(c<=0) {
  686.             return false;
  687.         }
  688.         else {
  689.             if(c>1) {
  690.                 throw new CoreException("Esiste più di un mapping di default per l'erogazione del servizio ["+idServizio.toString()+"]");
  691.             }
  692.             return true;
  693.         }
  694.     }
  695.     
  696.     public static boolean existsIDPortaApplicativaAssociataAzione(IDServizio idServizio,
  697.             Connection con, String tipoDB) throws CoreException {
  698.         return existsIDPortaApplicativaAssociataAzione(idServizio, con, tipoDB, CostantiDB.SOGGETTI);
  699.     }
  700.     public static boolean existsIDPortaApplicativaAssociataAzione(IDServizio idServizio, 
  701.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  702.         if(idServizio.getAzione()==null) {
  703.             throw new CoreException("Azione non indicata nel parametro 'idServizio'");
  704.         }
  705.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  706.         if(idServizioLong<=0){
  707.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  708.         }
  709.         int c = _countIDPorteApplicativeAssociate(idServizioLong, false, idServizio.getAzione(), con, tipoDB, tabellaSoggetti);
  710.         if(c<=0) {
  711.             return false;
  712.         }
  713.         else {
  714.             if(c>1) {
  715.                 throw new CoreException("Esiste più di un mapping per l'erogazione dell'azione '"+idServizio.getAzione()+"' del servizio ["+idServizio.toString()+"]");
  716.             }
  717.             return true;
  718.         }
  719.     }
  720.     
  721.     public static boolean existsIDPorteApplicativeAssociate(IDServizio idServizio,
  722.             Connection con, String tipoDB) throws CoreException {
  723.         return existsIDPorteApplicativeAssociate(idServizio, con, tipoDB, CostantiDB.SOGGETTI);
  724.     }
  725.     public static boolean existsIDPorteApplicativeAssociate(IDServizio idServizio, 
  726.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  727.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  728.         if(idServizioLong<=0){
  729.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  730.         }
  731.         return _countIDPorteApplicativeAssociate(idServizioLong, false, null, con, tipoDB, tabellaSoggetti)>0;
  732.     }
  733.     
  734.     private static int _countIDPorteApplicativeAssociate(long idServizioLong, boolean defaultMapping, String azioneMapping, 
  735.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  736.         PreparedStatement stm = null;
  737.         ResultSet rs = null;

  739.         try {

  741.             if(idServizioLong<=0){
  742.                 throw new Exception("IdServizio non fornito");
  743.             }

  745.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  746.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  747.             sqlQueryObject.addWhereCondition("id_erogazione = ?");
  748.             if(defaultMapping) {
  749.                 sqlQueryObject.addWhereCondition("is_default = ?");
  750.             }
  751.             if(azioneMapping!=null) {
  752.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  753.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AZIONI);
  754.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  755.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.PORTE_APPLICATIVE_AZIONI+".id_porta");
  756.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".azione = ?");
  757.             }
  758.             sqlQueryObject.setANDLogicOperator(true);
  759.             String sqlQuery = sqlQueryObject.createSQLQuery();
  760.             stm = con.prepareStatement(sqlQuery);
  761.             int indexStmt = 1;
  762.             stm.setLong(indexStmt++,idServizioLong);
  763.             if(defaultMapping) {
  764.                 stm.setInt(indexStmt++,1);
  765.             }
  766.             if(azioneMapping!=null) {
  767.                 stm.setString(indexStmt++,azioneMapping);
  768.             }
  769.         
  770.             rs = stm.executeQuery();
  771.             int c = 0;
  772.             while(rs.next()) {
  773.                 c++;
  774.             }
  775.             return c;
  776.         }catch(CoreException de){
  777.             throw de;
  778.         }
  779.         catch(Exception e){
  780.             throw new CoreException("existsIDPortaApplicativaAssociata error",e);
  781.         } finally {

  783.             //Chiudo statement and resultset
  784.             try{
  785.                 if(rs!=null) rs.close();
  786.             }catch (Exception e) {
  787.                 //ignore
  788.             }
  789.             try{
  790.                 if(stm!=null) stm.close();
  791.             }catch (Exception e) {
  792.                 //ignore
  793.             }

  795.         }
  796.     }
  797.     
  798.     
  799.     

  801.     
  802.     public static boolean existsMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  803.             Connection con, String tipoDB) throws CoreException {
  804.         return existsMappingErogazione(idServizio, idPortaApplicativa, con, tipoDB, CostantiDB.SOGGETTI);
  805.     }
  806.     public static boolean existsMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  807.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  808.         try {
  809.             long id = getTableIdMappingErogazione(idServizio, idPortaApplicativa, con, tipoDB);
  810.             return id>0;
  811.         }catch(Exception e) {
  812.             return false;
  813.         }
  814.     }
  815.     
  816.     
  817.     
  818.     
  819.     public static long getTableIdMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  820.             Connection con, String tipoDB) throws CoreException {
  821.         return getTableIdMappingErogazione(idServizio, idPortaApplicativa, con, tipoDB, CostantiDB.SOGGETTI);
  822.     }
  823.     public static long getTableIdMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  824.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  825.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  826.         if(idServizioLong<=0){
  827.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  828.         }
  829.         return _getTableIdMappingErogazione(idServizioLong, idPortaApplicativa, con, tipoDB, tabellaSoggetti);
  830.     }
  831.     
  832.     private static long _getTableIdMappingErogazione(long idServizioLong, IDPortaApplicativa idPortaApplicativa,
  833.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  834.         if(idServizioLong<=0){
  835.             throw new CoreException("IdServizio non fornito");
  836.         }
  837.         long idPA = DBUtils.getIdPortaApplicativa(idPortaApplicativa.getNome(), con, tipoDB);
  838.         if(idPA<=0){
  839.             throw new CoreException("PortaApplicativa ["+idPortaApplicativa+"] non esistente");
  840.         }

  842.         PreparedStatement stm = null;
  843.         ResultSet rs = null;

  845.         try {

  847.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  848.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  849.             sqlQueryObject.addWhereCondition("id_erogazione=?");
  850.             sqlQueryObject.addWhereCondition("id_porta=?");
  851.             sqlQueryObject.setANDLogicOperator(true);
  852.             String queryString = sqlQueryObject.createSQLQuery();
  853.             stm = con.prepareStatement(queryString);
  854.             stm.setLong(1, idServizioLong);
  855.             stm.setLong(2, idPA);
  856.             rs = stm.executeQuery();
  857.             if (rs.next()) {
  858.                 return rs.getLong("id");
  859.             }
  860.             else{
  861.                 throw new CoreException("Mapping tra PA (id:"+idPA+") e servizio (id:"+idServizioLong+") non esistente");
  862.             }
  863.         }catch(CoreException de){
  864.             throw de;
  865.         }
  866.         catch(Exception e){
  867.             throw new CoreException("getIDPortaApplicativaAssociata error",e);
  868.         } finally {

  870.             //Chiudo statement and resultset
  871.             try{
  872.                 if(rs!=null) rs.close();
  873.             }catch (Exception e) {
  874.                 //ignore
  875.             }
  876.             try{
  877.                 if(stm!=null) stm.close();
  878.             }catch (Exception e) {
  879.                 //ignore
  880.             }

  882.         }
  883.     }
  884.     
  885.     public static boolean checkMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa, boolean isDefault,
  886.             Connection con, String tipoDB) throws CoreException {
  887.         return checkMappingErogazione(idServizio, idPortaApplicativa, isDefault, con, tipoDB, CostantiDB.SOGGETTI);
  888.     }
  889.     public static boolean checkMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa, boolean isDefault,
  890.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  891.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  892.         if(idServizioLong<=0){
  893.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  894.         }
  895.         return _checkMappingErogazione(idServizioLong, idPortaApplicativa, isDefault, con, tipoDB, tabellaSoggetti);
  896.     }
  897.     
  898.     private static boolean _checkMappingErogazione(long idServizioLong, IDPortaApplicativa idPortaApplicativa, boolean isDefault,
  899.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  900.         PreparedStatement stm = null;
  901.         ResultSet rs = null;

  903.         try {

  905.             if(idServizioLong<=0){
  906.                 throw new Exception("IdServizio non fornito");
  907.             }
  908.             long idPA = DBUtils.getIdPortaApplicativa(idPortaApplicativa.getNome(), con, tipoDB);
  909.             if(idPA<=0){
  910.                 throw new Exception("PortaApplicativa ["+idPortaApplicativa+"] non esistente");
  911.             }
  912.             
  913.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  914.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  915.             sqlQueryObject.addSelectCountField("id","mapping_count");
  916.             sqlQueryObject.addWhereCondition("id_erogazione=?");
  917.             sqlQueryObject.addWhereCondition("id_porta=?");
  918.             sqlQueryObject.addWhereCondition("is_default = ?");
  919.             sqlQueryObject.setANDLogicOperator(true);
  920.             String queryString = sqlQueryObject.createSQLQuery();
  921.             stm = con.prepareStatement(queryString);
  922.             stm.setLong(1, idServizioLong);
  923.             stm.setLong(2, idPA);
  924.             stm.setLong(3, (isDefault ? 1 : 0));
  925.             rs = stm.executeQuery();
  926.             int found = 0;
  927.             if (rs.next()) {
  928.                 found = rs.getInt("mapping_count");
  929.             }
  930.             
  931.             return found > 0;
  932.         }catch(CoreException de){
  933.             throw de;
  934.         }
  935.         catch(Exception e){
  936.             throw new CoreException("_checkIsDefaultMappingErogazione error",e);
  937.         } finally {

  939.             //Chiudo statement and resultset
  940.             try{
  941.                 if(rs!=null) rs.close();
  942.             }catch (Exception e) {
  943.                 //ignore
  944.             }
  945.             try{
  946.                 if(stm!=null) stm.close();
  947.             }catch (Exception e) {
  948.                 //ignore
  949.             }
  950.         }
  951.     }
  952.     
  953.     
  954.     public static MappingErogazionePortaApplicativa getMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  955.             Connection con, String tipoDB) throws CoreException {
  956.         return getMappingErogazione(idServizio, idPortaApplicativa, con, tipoDB, CostantiDB.SOGGETTI);
  957.     }
  958.     public static MappingErogazionePortaApplicativa getMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa,
  959.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  960.         long idServizioLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  961.         if(idServizioLong<=0){
  962.             throw new CoreException("Servizio ["+idServizio.toString()+"] non esistente");
  963.         }
  964.         
  965.         long idPA = DBUtils.getIdPortaApplicativa(idPortaApplicativa.getNome(), con, tipoDB);
  966.         if(idPA<=0){
  967.             throw new CoreException("PortaApplicativa ["+idPortaApplicativa+"] non esistente");
  968.         }
  969.         
  970.         MappingErogazionePortaApplicativa mapping = _getMappingErogazione(idServizioLong, idPA, con, tipoDB, tabellaSoggetti);
  971.         mapping.setIdPortaApplicativa(idPortaApplicativa);
  972.         mapping.setIdServizio(idServizio);
  973.         return mapping;
  974.     }
  975.     private static MappingErogazionePortaApplicativa _getMappingErogazione(long idServizioLong, long idPA,
  976.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  977.         PreparedStatement stm = null;
  978.         ResultSet rs = null;

  980.         try {

  982.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  983.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  984.             sqlQueryObject.addWhereCondition("id_erogazione=?");
  985.             sqlQueryObject.addWhereCondition("id_porta=?");
  986.             sqlQueryObject.setANDLogicOperator(true);
  987.             String queryString = sqlQueryObject.createSQLQuery();
  988.             stm = con.prepareStatement(queryString);
  989.             stm.setLong(1, idServizioLong);
  990.             stm.setLong(2, idPA);
  991.             rs = stm.executeQuery();
  992.             if (rs.next()) {
  993.                 MappingErogazionePortaApplicativa mapping = new MappingErogazionePortaApplicativa();
  994.                 int isDefault = rs.getInt("is_default");
  995.                 mapping.setDefault(isDefault == 1);
  996.                 
  997.                 mapping.setTableId(rs.getLong("id"));
  998.                 
  999.                 mapping.setNome(rs.getString("nome"));
  1000.                 mapping.setDescrizione(rs.getString("descrizione"));
  1001.                 
  1002.                 return mapping;
  1003.             }
  1004.             else{
  1005.                 throw new CoreException("Mapping tra PA (id:"+idPA+") e servizio (id:"+idServizioLong+") non esistente");
  1006.             }
  1007.         }catch(CoreException de){
  1008.             throw de;
  1009.         }
  1010.         catch(Exception e){
  1011.             throw new CoreException("getMappingErogazione error",e);
  1012.         } finally {

  1014.             //Chiudo statement and resultset
  1015.             try{
  1016.                 if(rs!=null) rs.close();
  1017.             }catch (Exception e) {
  1018.                 //ignore
  1019.             }
  1020.             try{
  1021.                 if(stm!=null) stm.close();
  1022.             }catch (Exception e) {
  1023.                 //ignore
  1024.             }

  1026.         }
  1027.     }
  1028.     
  1029.     
  1030.     
  1031.     
  1032.     
  1033.     // -- MAPPING FRUIZIONE
  1034.     
  1035.     public static int countMappingFruizione(Connection con, String tipoDB) throws CoreException{
  1036.         return _countMappingFruizione(con, tipoDB, CostantiDB.SOGGETTI);
  1037.     }
  1038.     public static int countMappingFruizione(Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1039.         return _countMappingFruizione(con, tipoDB, tabellaSoggetti);
  1040.     }
  1041.     private static int _countMappingFruizione(Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1042.         PreparedStatement stmt = null;
  1043.         ResultSet rs = null;
  1044.         try {

  1046.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1047.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1048.             sqlQueryObject.addSelectCountField("id","mapping_count");
  1049.             String queryString = sqlQueryObject.createSQLQuery();
  1050.             stmt = con.prepareStatement(queryString);
  1051.             rs = stmt.executeQuery();
  1052.             if (rs.next()) {
  1053.                 return rs.getInt("mapping_count");
  1054.             }
  1055.             else{
  1056.                 return 0;
  1057.             }
  1058.             
  1059.         }catch(Exception e){
  1060.             throw new CoreException("createMappingFruizione error",e);
  1061.         } finally {

  1063.             //Chiudo statement and resultset
  1064.             try{
  1065.                 if(rs!=null) rs.close();
  1066.             }catch (Exception e) {
  1067.                 //ignore
  1068.             }
  1069.             try{
  1070.                 if(stmt!=null) stmt.close();
  1071.             }catch (Exception e) {
  1072.                 //ignore
  1073.             }

  1075.         }
  1076.     }
  1077.     
  1078.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1079.             long idFruizione, 
  1080.             IDSoggetto idSoggettoFruitore,
  1081.             IDServizio idServizio,
  1082.             ISearch ricerca,boolean ricerca_useOffsetLimit,
  1083.             boolean orderByDescrizione) throws CoreException {
  1084.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1085.                 idFruizione, 
  1086.                 idSoggettoFruitore, 
  1087.                 idServizio,
  1088.                 ricerca, ricerca_useOffsetLimit, CostantiDB.SOGGETTI,
  1089.                 orderByDescrizione); 
  1090.     }
  1091.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1092.             long idFruizione, 
  1093.             IDSoggetto idSoggettoFruitore, 
  1094.             IDServizio idServizio,
  1095.             ISearch ricerca,boolean ricerca_useOffsetLimit,String tabellaSoggetti,
  1096.             boolean orderByDescrizione) throws CoreException {
  1097.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1098.                 idFruizione, 
  1099.                 idSoggettoFruitore, 
  1100.                 idServizio,
  1101.                 ricerca, ricerca_useOffsetLimit, tabellaSoggetti,
  1102.                 orderByDescrizione); 
  1103.     }
  1104.     
  1105.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1106.             long idFruizione, 
  1107.             IDSoggetto idSoggettoFruitore,
  1108.             IDServizio idServizio,
  1109.             boolean orderByDescrizione) throws CoreException {
  1110.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1111.                 idFruizione, 
  1112.                 idSoggettoFruitore, 
  1113.                 idServizio,
  1114.                 null, false, CostantiDB.SOGGETTI,
  1115.                 orderByDescrizione); 
  1116.     }
  1117.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1118.             long idFruizione, 
  1119.             IDSoggetto idSoggettoFruitore, 
  1120.             IDServizio idServizio,
  1121.             String tabellaSoggetti,
  1122.             boolean orderByDescrizione) throws CoreException {
  1123.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1124.                 idFruizione, 
  1125.                 idSoggettoFruitore, 
  1126.                 idServizio,
  1127.                 null, false, tabellaSoggetti,
  1128.                 orderByDescrizione); 
  1129.     }
  1130.     
  1131.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1132.             IDSoggetto idSoggettoFruitore,
  1133.             IDServizio idServizio,
  1134.             ISearch ricerca,boolean ricerca_useOffsetLimit,
  1135.             boolean orderByDescrizione) throws CoreException {
  1136.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1137.                 DBUtils.getIdFruizioneServizio(idServizio, idSoggettoFruitore, con, tipoDB), 
  1138.                 idSoggettoFruitore, 
  1139.                 idServizio,
  1140.                 ricerca, ricerca_useOffsetLimit, CostantiDB.SOGGETTI,
  1141.                 orderByDescrizione); 
  1142.     }
  1143.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1144.             IDSoggetto idSoggettoFruitore, 
  1145.             IDServizio idServizio,
  1146.             ISearch ricerca,boolean ricerca_useOffsetLimit,String tabellaSoggetti,
  1147.             boolean orderByDescrizione) throws CoreException {
  1148.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1149.                 DBUtils.getIdFruizioneServizio(idServizio, idSoggettoFruitore, con, tipoDB), 
  1150.                 idSoggettoFruitore, 
  1151.                 idServizio,
  1152.                 ricerca, ricerca_useOffsetLimit, tabellaSoggetti,
  1153.                 orderByDescrizione); 
  1154.     }
  1155.     
  1156.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1157.             IDSoggetto idSoggettoFruitore,
  1158.             IDServizio idServizio,
  1159.             boolean orderByDescrizione) throws CoreException {
  1160.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1161.                 DBUtils.getIdFruizioneServizio(idServizio, idSoggettoFruitore, con, tipoDB), 
  1162.                 idSoggettoFruitore, 
  1163.                 idServizio,
  1164.                 null, false, CostantiDB.SOGGETTI,
  1165.                 orderByDescrizione); 
  1166.     }
  1167.     public static List<MappingFruizionePortaDelegata> mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1168.             IDSoggetto idSoggettoFruitore, 
  1169.             IDServizio idServizio,
  1170.             String tabellaSoggetti,
  1171.             boolean orderByDescrizione) throws CoreException {
  1172.         return _mappingFruizionePortaDelegataList(con, tipoDB, 
  1173.                 DBUtils.getIdFruizioneServizio(idServizio, idSoggettoFruitore, con, tipoDB), 
  1174.                 idSoggettoFruitore, 
  1175.                 idServizio,
  1176.                 null, false, tabellaSoggetti,
  1177.                 orderByDescrizione); 
  1178.     }
  1179.     
  1180.     private static List<MappingFruizionePortaDelegata> _mappingFruizionePortaDelegataList(Connection con, String tipoDB, 
  1181.             long idFruizione,
  1182.             IDSoggetto idSoggettoFruitore, 
  1183.             IDServizio idServizio,
  1184.             ISearch ricerca,boolean ricerca_useOffsetLimit,String tabellaSoggetti,
  1185.             boolean orderByDescrizione) throws CoreException {
  1186.         int idLista = Liste.CONFIGURAZIONE_FRUIZIONE;
  1187.         int offset = 0;
  1188.         int limit = 0;
  1189.         String search = "";
  1190.         String queryString;

  1192.         if(ricerca != null) {
  1193.             if(ricerca_useOffsetLimit) {
  1194.                 limit = ricerca.getPageSize(idLista);
  1195.                 offset = ricerca.getIndexIniziale(idLista);
  1196.             }
  1197.             search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  1198.         }
  1199.         
  1200.         PreparedStatement stmt = null;
  1201.         ResultSet risultato = null;
  1202.         
  1203.         List<MappingFruizionePortaDelegata> lista = new ArrayList<MappingFruizionePortaDelegata>();
  1204.         try {
  1205.             if(ricerca != null) {
  1206.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1207.                 sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1208.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1209.                 sqlQueryObject.addSelectCountField("*", "cont");
  1210.                 sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione = ?");
  1211.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  1212.                 if (!search.equals("")) {
  1213.                     sqlQueryObject.addWhereCondition(false, 
  1214.                             sqlQueryObject.getWhereLikeCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".nome", search, true, true));
  1215.                             //sqlQueryObject.getWhereLikeCondition(CostantiDB.PORTE_DELEGATE +".nome_porta", search, true, true));
  1216.                 } 
  1217.                 
  1218.                 sqlQueryObject.setANDLogicOperator(true);
  1219.                 queryString = sqlQueryObject.createSQLQuery();
  1220.                 stmt = con.prepareStatement(queryString);
  1221.                 int index = 1;
  1222.                 stmt.setLong(index++, idFruizione);
  1223.                 
  1224.                 risultato = stmt.executeQuery();
  1225.                 if (risultato.next())
  1226.                     ricerca.setNumEntries(idLista,risultato.getInt(1));
  1227.                 risultato.close();
  1228.                 stmt.close();
  1229.             }
  1230.             
  1231.             // ricavo le entries
  1232.             if (limit == 0) // con limit
  1233.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  1234.             
  1235.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1236.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1237.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1238.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione");
  1239.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  1240.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_FRUIZIONE_PD+".is_default");
  1241.             sqlQueryObject.addSelectAliasField(CostantiDB.MAPPING_FRUIZIONE_PD,"nome","nomeMapping");
  1242.             sqlQueryObject.addSelectAliasField(CostantiDB.MAPPING_FRUIZIONE_PD,"descrizione","descrizioneMapping");
  1243.             sqlQueryObject.addSelectField(CostantiDB.MAPPING_FRUIZIONE_PD+".id");
  1244.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  1245.             sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione = ?");
  1246.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  1247.             
  1248.             if (ricerca != null && !search.equals("")) {
  1249.                 sqlQueryObject.addWhereCondition(false, 
  1250.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".nome", search, true, true));
  1251.                         //sqlQueryObject.getWhereLikeCondition(CostantiDB.PORTE_DELEGATE +".nome_porta", search, true, true));
  1252.             } 
  1253.             sqlQueryObject.setANDLogicOperator(true);
  1254.             sqlQueryObject.addOrderBy(CostantiDB.MAPPING_FRUIZIONE_PD+".is_default",true);
  1255.             if(orderByDescrizione) {
  1256.                 sqlQueryObject.addOrderBy("descrizioneMapping");
  1257.             }
  1258.             else {
  1259.                 sqlQueryObject.addOrderBy("nomeMapping");
  1260.             }
  1261.             sqlQueryObject.setSortType(true);
  1262.             if(ricerca != null) {
  1263.                 sqlQueryObject.setLimit(limit);
  1264.                 sqlQueryObject.setOffset(offset);
  1265.             }
  1266.             queryString = sqlQueryObject.createSQLQuery();
  1267.             
  1268.             stmt = con.prepareStatement(queryString);
  1269.             
  1270.             int index = 1;
  1271.             stmt.setLong(index++, idFruizione);
  1272.             
  1273.             risultato = stmt.executeQuery();
  1274.             
  1275.             MappingFruizionePortaDelegata mapping = null;

  1277.             while (risultato.next()) {

  1279.                 mapping = new MappingFruizionePortaDelegata();
  1280.                 
  1281.                 Long id = risultato.getLong("id");
  1282. //              Long idPorta = risultato.getLong("id_porta");
  1283. //              Long idFruizione = risultato.getLong("id_fruizione");
  1284.                 String nome = risultato.getString("nomeMapping");
  1285.                 String descrizione = risultato.getString("descrizioneMapping");
  1286.                 Integer isDefaultInt = risultato.getInt("is_default");
  1287.                 boolean isDefault = isDefaultInt > 0 ;
  1288.                 
  1289.                 mapping.setNome(nome);
  1290.                 mapping.setDescrizione(descrizione);
  1291.                 mapping.setTableId(id);
  1292.                 mapping.setDefault(isDefault);
  1293.                 // evitiamo una join utilizzo l'id che mi sono passato come parametro
  1294.                 mapping.setIdServizio(idServizio);
  1295.                 mapping.setIdFruitore(idSoggettoFruitore); 
  1296.                 
  1297.                 IDPortaDelegata idPortaDelegata = new IDPortaDelegata();
  1298.                 String nomePorta = risultato.getString("nome_porta");
  1299.                 idPortaDelegata.setNome(nomePorta);
  1300.                 
  1301.                 IdentificativiFruizione identificativiFruizione = new IdentificativiFruizione();
  1302.                 identificativiFruizione.setSoggettoFruitore(idSoggettoFruitore);
  1303.                 identificativiFruizione.setIdServizio(idServizio);
  1304.                 idPortaDelegata.setIdentificativiFruizione(identificativiFruizione);
  1305.                 
  1306.                 mapping.setIdPortaDelegata(idPortaDelegata);
  1307.                 
  1308.                 lista.add(mapping);

  1310.             }
  1311.             
  1312.         
  1313.         }catch(Exception e){
  1314.             throw new CoreException("mappingFruizionePortaDelegataList error",e);
  1315.         } finally {
  1316.         
  1317.             //Chiudo statement and resultset
  1318.             try{
  1319.                 if(risultato!=null) risultato.close();
  1320.             }catch (Exception e) {
  1321.                 //ignore
  1322.             }
  1323.             try{
  1324.                 if(stmt!=null) stmt.close();
  1325.             }catch (Exception e) {
  1326.                 //ignore
  1327.             }
  1328.         
  1329.         }
  1330.         
  1331.         return lista;
  1332.     }

  1334.     public static void createMappingFruizione(String nome, String descrizione, boolean isDefault, IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1335.             Connection con, String tipoDB) throws CoreException{
  1336.         createMappingFruizione(nome, descrizione, isDefault, idServizio, idFruitore, idPortaDelegata, con, tipoDB, CostantiDB.SOGGETTI);
  1337.     }
  1338.     public static void createMappingFruizione(String nome, String descrizione, boolean isDefault, IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1339.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1340.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1341.         if(idFruizione<=0){
  1342.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1343.         }
  1344.         _createMappingFruizione(nome, descrizione, isDefault, idFruizione, idPortaDelegata, con, tipoDB, tabellaSoggetti);
  1345.     }
  1346.     
  1347.     private static void _createMappingFruizione(String nome, String descrizione, boolean isDefault, long idFruizione, IDPortaDelegata idPortaDelegata,
  1348.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1349.         PreparedStatement stmt = null;

  1351.         try {

  1353.             if(idFruizione<=0){
  1354.                 throw new Exception("IdFruizione non fornita");
  1355.             }
  1356.             long idPD = DBUtils.getIdPortaDelegata(idPortaDelegata.getNome(), con, tipoDB);
  1357.             if(idPD<=0){
  1358.                 throw new Exception("PortaDelegata ["+idPortaDelegata+"] non esistente");
  1359.             }
  1360.             
  1361.             int isDefaultInt = isDefault ? 1 : 0;
  1362.             
  1363.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1364.             sqlQueryObject.addInsertTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1365.             sqlQueryObject.addInsertField("id_fruizione", "?");
  1366.             sqlQueryObject.addInsertField("id_porta", "?");
  1367.             sqlQueryObject.addInsertField("nome", "?");
  1368.             sqlQueryObject.addInsertField("descrizione", "?");
  1369.             sqlQueryObject.addInsertField("is_default", "?");
  1370.             String queryString = sqlQueryObject.createSQLInsert();
  1371.             stmt = con.prepareStatement(queryString);
  1372.             int index = 1;
  1373.             stmt.setLong(index++, idFruizione);
  1374.             stmt.setLong(index++, idPD);
  1375.             stmt.setString(index++, nome);
  1376.             stmt.setString(index++, descrizione);
  1377.             stmt.setInt(index++, isDefaultInt);
  1378.             stmt.executeUpdate();
  1379.             stmt.close();
  1380.             
  1381.         }catch(Exception e){
  1382.             throw new CoreException("Creazione Mapping Fruizione fallita: "+e.getMessage(),e);
  1383.         } finally {

  1385.             //Chiudo statement and resultset
  1386.             try{
  1387.                 if(stmt!=null) stmt.close();
  1388.             }catch (Exception e) {
  1389.                 //ignore
  1390.             }

  1392.         }
  1393.     }
  1394.     
  1395.     
  1396.     
  1397.     public static void updateMappingFruizione(long tableId, String descrizione, Connection con, String tipoDB) throws CoreException{
  1398.         PreparedStatement stmt = null;

  1400.         try {

  1402.             if(tableId<=0){
  1403.                 throw new Exception("TableId non fornito");
  1404.             }
  1405.             
  1406.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1407.             sqlQueryObject.addUpdateTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1408.             sqlQueryObject.addUpdateField("descrizione", "?");
  1409.             sqlQueryObject.addWhereCondition("id=?");
  1410.             String queryString = sqlQueryObject.createSQLUpdate();
  1411.             stmt = con.prepareStatement(queryString);
  1412.             int index = 1;
  1413.             stmt.setString(index++, descrizione);
  1414.             stmt.setLong(index++, tableId);
  1415.             stmt.executeUpdate();
  1416.             stmt.close();
  1417.             
  1418.         }catch(Exception e){
  1419.             throw new CoreException("updateMappingFruizione error",e);
  1420.         } finally {

  1422.             //Chiudo statement and resultset
  1423.             try{
  1424.                 if(stmt!=null) stmt.close();
  1425.             }catch (Exception e) {
  1426.                 //ignore
  1427.             }

  1429.         }
  1430.     }
  1431.     
  1432.     
  1433.     public static void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore,
  1434.             Connection con, String tipoDB) throws CoreException{
  1435.         deleteMappingFruizione(idServizio, idFruitore, null, con, tipoDB, CostantiDB.SOGGETTI);
  1436.     }
  1437.     public static void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore,
  1438.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1439.         deleteMappingFruizione(idServizio, idFruitore, null, con, tipoDB, tabellaSoggetti);
  1440.     }
  1441.     public static void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, boolean deletePorte,
  1442.             Connection con, String tipoDB) throws CoreException{
  1443.         deleteMappingFruizione(idServizio, idFruitore, deletePorte, con, tipoDB, CostantiDB.SOGGETTI);
  1444.     }
  1445.     public static void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, boolean deletePorte,
  1446.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1447.         List<IDPortaDelegata> list = null;
  1448.         if(deletePorte) {
  1449.             list = getIDPorteDelegateAssociate(idServizio, idFruitore, con, tipoDB);
  1450.         }
  1451.         deleteMappingFruizione(idServizio, idFruitore, null, con, tipoDB, tabellaSoggetti);
  1452.         if(list!=null && list.size()>0) {
  1453.             for (IDPortaDelegata idPortaDelegata : list) {
  1454.                 PreparedStatement stmt = null;
  1455.                 try {
  1456.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1457.                     sqlQueryObject.addDeleteTable(CostantiDB.PORTE_DELEGATE);
  1458.                     sqlQueryObject.addWhereCondition("id=?");
  1459.                     sqlQueryObject.setANDLogicOperator(true);
  1460.                     String queryString = sqlQueryObject.createSQLDelete();
  1461.                     stmt = con.prepareStatement(queryString);
  1462.                     stmt.setLong(1, DBUtils.getIdPortaDelegata(idPortaDelegata.getNome(), con, tipoDB));
  1463.                     stmt.executeUpdate();
  1464.                     stmt.close();
  1465.                 }catch(Exception e){
  1466.                     throw new CoreException("deletePAMappingErogazione error",e);
  1467.                 } finally {

  1469.                     //Chiudo statement and resultset
  1470.                     try{
  1471.                         if(stmt!=null) stmt.close();
  1472.                     }catch (Exception e) {
  1473.                         //ignore
  1474.                     }

  1476.                 }
  1477.             }
  1478.         }
  1479.     }
  1480.     public static void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1481.             Connection con, String tipoDB) throws CoreException{
  1482.         deleteMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, tipoDB, CostantiDB.SOGGETTI);
  1483.     }
  1484.     public static void deleteMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1485.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1486.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1487.         if(idFruizione<=0){
  1488.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1489.         }
  1490.         _deleteMappingFruizione(idFruizione, idPortaDelegata, con, tipoDB, tabellaSoggetti);
  1491.     }
  1492.     
  1493.     private static void _deleteMappingFruizione(long idFruizione, IDPortaDelegata idPortaDelegata,
  1494.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  1495.         PreparedStatement stmt = null;

  1497.         try {

  1499.             if(idFruizione<=0){
  1500.                 throw new Exception("IdFruizione non fornita");
  1501.             }
  1502.             long idPD = -1;
  1503.             if(idPortaDelegata!=null){
  1504.                 idPD = DBUtils.getIdPortaDelegata(idPortaDelegata.getNome(), con, tipoDB);
  1505.                 if(idPD<=0){
  1506.                     throw new Exception("PortaDelegata ["+idPortaDelegata+"] non esistente");
  1507.                 }
  1508.             }
  1509.             
  1510.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1511.             sqlQueryObject.addDeleteTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1512.             sqlQueryObject.addWhereCondition("id_fruizione=?");
  1513.             if(idPortaDelegata!=null){
  1514.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1515.             }
  1516.             sqlQueryObject.setANDLogicOperator(true);
  1517.             String queryString = sqlQueryObject.createSQLDelete();
  1518.             stmt = con.prepareStatement(queryString);
  1519.             stmt.setLong(1, idFruizione);
  1520.             if(idPortaDelegata!=null){
  1521.                 stmt.setLong(2, idPD);
  1522.             }
  1523.             stmt.executeUpdate();
  1524.             stmt.close();
  1525.             
  1526.         }catch(Exception e){
  1527.             throw new CoreException("deleteMappingFruizione error",e);
  1528.         } finally {

  1530.             //Chiudo statement and resultset
  1531.             try{
  1532.                 if(stmt!=null) stmt.close();
  1533.             }catch (Exception e) {
  1534.                 //ignore
  1535.             }

  1537.         }
  1538.     }

  1540.     public static IDPortaDelegata getIDPortaDelegataAssociataDefault(IDServizio idServizio, IDSoggetto idFruitore,
  1541.             Connection con, String tipoDB) throws CoreException {
  1542.         return getIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1543.     }
  1544.     public static IDPortaDelegata getIDPortaDelegataAssociataDefault(IDServizio idServizio, IDSoggetto idFruitore,
  1545.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1546.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1547.         if(idFruizione<=0){
  1548.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1549.         }
  1550.         List<IDPortaDelegata> l = _getIDPorteDelegateAssociate(idFruizione, true, null, con, tipoDB, tabellaSoggetti,
  1551.                 idFruitore, idServizio);
  1552.         if(l!=null && l.size()>0) {
  1553.             if(l.size()>1) {
  1554.                 throw new CoreException("Esiste più di un mapping di default per la fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"]");
  1555.             }
  1556.             return l.get(0);
  1557.         }
  1558.         return null;
  1559.     }
  1560.     
  1561.     public static IDPortaDelegata getIDPortaDelegataAssociataAzione(IDServizio idServizio, IDSoggetto idFruitore,
  1562.             Connection con, String tipoDB) throws CoreException {
  1563.         return getIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1564.     }
  1565.     public static IDPortaDelegata getIDPortaDelegataAssociataAzione(IDServizio idServizio, IDSoggetto idFruitore,
  1566.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1567.         if(idServizio.getAzione()==null) {
  1568.             throw new CoreException("Azione non indicata nel parametro 'idServizio'");
  1569.         }
  1570.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1571.         if(idFruizione<=0){
  1572.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1573.         }
  1574.         List<IDPortaDelegata> l = _getIDPorteDelegateAssociate(idFruizione, false, idServizio.getAzione(), con, tipoDB, tabellaSoggetti,
  1575.                 idFruitore, idServizio);
  1576.         if(l!=null && l.size()>0) {
  1577.             if(l.size()>1) {
  1578.                 throw new CoreException("Esiste più di un mapping per l'azione '"+idServizio.getAzione()+"' per la fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"]");
  1579.             }
  1580.             return l.get(0);
  1581.         }
  1582.         return null;
  1583.     }
  1584.     
  1585.     public static List<IDPortaDelegata> getIDPorteDelegateAssociate(IDServizio idServizio, IDSoggetto idFruitore,
  1586.             Connection con, String tipoDB) throws CoreException {
  1587.         return getIDPorteDelegateAssociate(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1588.     }
  1589.     public static List<IDPortaDelegata> getIDPorteDelegateAssociate(IDServizio idServizio, IDSoggetto idFruitore,
  1590.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1591.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1592.         if(idFruizione<=0){
  1593.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1594.         }
  1595.         return _getIDPorteDelegateAssociate(idFruizione, false, null, con, tipoDB, tabellaSoggetti,
  1596.                 idFruitore, idServizio);
  1597.     }
  1598.     
  1599.     private static List<IDPortaDelegata> _getIDPorteDelegateAssociate(long idFruizione, boolean defaultMapping, String azioneMapping,
  1600.             Connection con, String tipoDB,String tabellaSoggetti,
  1601.             IDSoggetto idFruitore, IDServizio idServizio) throws CoreException {
  1602.         PreparedStatement stm = null;
  1603.         ResultSet rs = null;

  1605.         try {

  1607.             if(idFruizione<=0){
  1608.                 throw new Exception("IdFruizione non fornita");
  1609.             }

  1611.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1612.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1613.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1614.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  1615.             sqlQueryObject.addWhereCondition("id_fruizione = ?");
  1616.             if(defaultMapping) {
  1617.                 sqlQueryObject.addWhereCondition("is_default = ?");
  1618.             }
  1619.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  1620.             if(azioneMapping!=null) {
  1621.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  1622.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.PORTE_DELEGATE_AZIONI+".id_porta");
  1623.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".azione = ?");
  1624.             }
  1625.             sqlQueryObject.setANDLogicOperator(true);
  1626.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1627.             stm = con.prepareStatement(sqlQuery);
  1628.             int indexStmt = 1;
  1629.             stm.setLong(indexStmt++,idFruizione);
  1630.             if(defaultMapping) {
  1631.                 stm.setInt(indexStmt++,1);
  1632.             }
  1633.             if(azioneMapping!=null) {
  1634.                 stm.setString(indexStmt++,azioneMapping);
  1635.             }
  1636.         
  1637.             rs = stm.executeQuery();
  1638.             
  1639.             List<IDPortaDelegata> list = new ArrayList<>();
  1640.             
  1641.             while (rs.next()) {
  1642.                 IDPortaDelegata idPD = new IDPortaDelegata();
  1643.                 String nome = rs.getString("nome_porta");
  1644.                 idPD.setNome(nome);
  1645.                 
  1646.                 IdentificativiFruizione identificativiFruizione = new IdentificativiFruizione();
  1647.                 identificativiFruizione.setSoggettoFruitore(idFruitore);
  1648.                 identificativiFruizione.setIdServizio(idServizio);
  1649.                 idPD.setIdentificativiFruizione(identificativiFruizione);
  1650.                 
  1651.                 list.add(idPD);
  1652.             }
  1653.             if(list.size()<=0){
  1654.                 //throw new CoreException("Mapping tra PD e Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1655.                 return null;
  1656.             }
  1657.             else {
  1658.                 return list;
  1659.             }
  1660.         }catch(CoreException de){
  1661.             throw de;
  1662.         }
  1663.         catch(Exception e){
  1664.             throw new CoreException("getIDPortaDelegataAssociata error",e);
  1665.         } finally {

  1667.             //Chiudo statement and resultset
  1668.             try{
  1669.                 if(rs!=null) rs.close();
  1670.             }catch (Exception e) {
  1671.                 //ignore
  1672.             }
  1673.             try{
  1674.                 if(stm!=null) stm.close();
  1675.             }catch (Exception e) {
  1676.                 //ignore
  1677.             }

  1679.         }
  1680.     }
  1681.     
  1682.     
  1683.     
  1684.     public static boolean existsIDPortaDelegataAssociataDefault(IDServizio idServizio, IDSoggetto idFruitore,
  1685.             Connection con, String tipoDB) throws CoreException {
  1686.         return existsIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1687.     }
  1688.     public static boolean existsIDPortaDelegataAssociataDefault(IDServizio idServizio, IDSoggetto idFruitore,
  1689.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1690.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1691.         if(idFruizione<=0){
  1692.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1693.         }
  1694.         int c = _countIDPorteDelegateAssociate(idFruizione, true, null, con, tipoDB, tabellaSoggetti);
  1695.         if(c<=0) {
  1696.             return false;
  1697.         }
  1698.         else {
  1699.             if(c>1) {
  1700.                 throw new CoreException("Esiste più di un mapping di default per la fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"]");
  1701.             }
  1702.             return true;
  1703.         }
  1704.     }
  1705.     
  1706.     public static boolean existsIDPortaDelegataAssociataAzione(IDServizio idServizio, IDSoggetto idFruitore,
  1707.             Connection con, String tipoDB) throws CoreException {
  1708.         return existsIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1709.     }
  1710.     public static boolean existsIDPortaDelegataAssociataAzione(IDServizio idServizio, IDSoggetto idFruitore,
  1711.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1712.         if(idServizio.getAzione()==null) {
  1713.             throw new CoreException("Azione non indicata nel parametro 'idServizio'");
  1714.         }
  1715.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1716.         if(idFruizione<=0){
  1717.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1718.         }
  1719.         int c = _countIDPorteDelegateAssociate(idFruizione, false, idServizio.getAzione(), con, tipoDB, tabellaSoggetti);
  1720.         if(c<=0) {
  1721.             return false;
  1722.         }
  1723.         else {
  1724.             if(c>1) {
  1725.                 throw new CoreException("Esiste più di un mapping per la fruizione dell'azione '"+idServizio.getAzione()+"' da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"]");
  1726.             }
  1727.             return true;
  1728.         }
  1729.     }

  1731.     public static boolean existsIDPorteDelegateAssociate(IDServizio idServizio, IDSoggetto idFruitore,
  1732.             Connection con, String tipoDB) throws CoreException {
  1733.         return existsIDPorteDelegateAssociate(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1734.     }
  1735.     public static boolean existsIDPorteDelegateAssociate(IDServizio idServizio, IDSoggetto idFruitore,
  1736.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1737.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1738.         if(idFruizione<=0){
  1739.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1740.         }
  1741.         return _countIDPorteDelegateAssociate(idFruizione, false, null, con, tipoDB, tabellaSoggetti)>0;
  1742.     }
  1743.     
  1744.     private static int _countIDPorteDelegateAssociate(long idFruizione, boolean defaultMapping, String azioneMapping, 
  1745.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1746.         PreparedStatement stm = null;
  1747.         ResultSet rs = null;

  1749.         try {

  1751.             if(idFruizione<=0){
  1752.                 throw new Exception("IdFruizione non fornita");
  1753.             }

  1755.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1756.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1757.             sqlQueryObject.addWhereCondition("id_fruizione = ?");
  1758.             if(defaultMapping) {
  1759.                 sqlQueryObject.addWhereCondition("is_default = ?");
  1760.             }
  1761.             if(azioneMapping!=null) {
  1762.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1763.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  1764.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  1765.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.PORTE_DELEGATE_AZIONI+".id_porta");
  1766.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".azione = ?");
  1767.             }
  1768.             sqlQueryObject.setANDLogicOperator(true);
  1769.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1770.             stm = con.prepareStatement(sqlQuery);
  1771.             int indexStmt = 1;
  1772.             stm.setLong(indexStmt++,idFruizione);
  1773.             if(defaultMapping) {
  1774.                 stm.setInt(indexStmt++,1);
  1775.             }
  1776.             if(azioneMapping!=null) {
  1777.                 stm.setString(indexStmt++,azioneMapping);
  1778.             }
  1779.         
  1780.             rs = stm.executeQuery();
  1781.             int c = 0;
  1782.             while(rs.next()) {
  1783.                 c++;
  1784.             }
  1785.             return c;
  1786.         }catch(CoreException de){
  1787.             throw de;
  1788.         }
  1789.         catch(Exception e){
  1790.             throw new CoreException("existsIDPortaDelegataAssociata error",e);
  1791.         } finally {

  1793.             //Chiudo statement and resultset
  1794.             try{
  1795.                 if(rs!=null) rs.close();
  1796.             }catch (Exception e) {
  1797.                 //ignore
  1798.             }
  1799.             try{
  1800.                 if(stm!=null) stm.close();
  1801.             }catch (Exception e) {
  1802.                 //ignore
  1803.             }

  1805.         }
  1806.     }

  1808.     
  1809.     
  1810.     
  1811.     


  1814.     
  1815.     
  1816.     public static boolean existsMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1817.             Connection con, String tipoDB) throws CoreException {
  1818.         return existsMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, tipoDB, CostantiDB.SOGGETTI);
  1819.     }
  1820.     public static boolean existsMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1821.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1822.         try {
  1823.             long id = getTableIdMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, tipoDB);
  1824.             return id>0;
  1825.         }catch(Exception e) {
  1826.             return false;
  1827.         }
  1828.     }
  1829.     
  1830.     
  1831.     
  1832.     
  1833.     
  1834.     

  1836.     public static long getTableIdMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1837.             Connection con, String tipoDB) throws CoreException {
  1838.         return getTableIdMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, tipoDB, CostantiDB.SOGGETTI);
  1839.     }
  1840.     public static long getTableIdMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1841.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1842.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1843.         if(idFruizione<=0){
  1844.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1845.         }
  1846.         return _getTableIdMappingFruizione(idFruizione, idPortaDelegata, con, tipoDB, tabellaSoggetti);
  1847.     }
  1848.     
  1849.     private static long _getTableIdMappingFruizione(long idFruizione, IDPortaDelegata idPortaDelegata,
  1850.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1851.         PreparedStatement stm = null;
  1852.         ResultSet rs = null;

  1854.         try {

  1856.             if(idFruizione<=0){
  1857.                 throw new Exception("IdFruizione non fornita");
  1858.             }
  1859.             long idPD = DBUtils.getIdPortaDelegata(idPortaDelegata.getNome(), con, tipoDB);
  1860.             if(idPD<=0){
  1861.                 throw new Exception("PortaDelegata ["+idPortaDelegata+"] non esistente");
  1862.             }
  1863.             
  1864.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1865.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1866.             sqlQueryObject.addWhereCondition("id_fruizione=?");
  1867.             sqlQueryObject.addWhereCondition("id_porta=?");
  1868.             sqlQueryObject.setANDLogicOperator(true);
  1869.             String queryString = sqlQueryObject.createSQLQuery();
  1870.             stm = con.prepareStatement(queryString);
  1871.             stm.setLong(1, idFruizione);
  1872.             stm.setLong(2, idPD);
  1873.             rs = stm.executeQuery();
  1874.             if (rs.next()) {
  1875.                 return rs.getLong("id");
  1876.             }
  1877.             else{
  1878.                 throw new CoreException("Mapping tra PD (id:"+idPD+") e Fruizione (id:"+idFruizione+") non esistente");
  1879.             }
  1880.         }catch(CoreException de){
  1881.             throw de;
  1882.         }
  1883.         catch(Exception e){
  1884.             throw new CoreException("_getTableIdMappingFruizione error",e);
  1885.         } finally {

  1887.             //Chiudo statement and resultset
  1888.             try{
  1889.                 if(rs!=null) rs.close();
  1890.             }catch (Exception e) {
  1891.                 //ignore
  1892.             }
  1893.             try{
  1894.                 if(stm!=null) stm.close();
  1895.             }catch (Exception e) {
  1896.                 //ignore
  1897.             }

  1899.         }
  1900.     } 
  1901.     
  1902.     public static boolean checkMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,boolean isDefault,
  1903.             Connection con, String tipoDB) throws CoreException {
  1904.         return checkMappingFruizione(idServizio, idFruitore, idPortaDelegata, isDefault, con, tipoDB, CostantiDB.SOGGETTI);
  1905.     }
  1906.     public static boolean checkMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,boolean isDefault,
  1907.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1908.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1909.         if(idFruizione<=0){
  1910.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1911.         }
  1912.         return checkMappingFruizione(idFruizione, idPortaDelegata, isDefault, con, tipoDB, tabellaSoggetti);
  1913.     }
  1914.     
  1915.     private static boolean checkMappingFruizione(long idFruizione, IDPortaDelegata idPortaDelegata, boolean isDefault,
  1916.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1917.         PreparedStatement stm = null;
  1918.         ResultSet rs = null;

  1920.         try {

  1922.             if(idFruizione<=0){
  1923.                 throw new Exception("IdFruizione non fornita");
  1924.             }
  1925.             long idPD = DBUtils.getIdPortaDelegata(idPortaDelegata.getNome(), con, tipoDB);
  1926.             if(idPD<=0){
  1927.                 throw new Exception("PortaDelegata ["+idPortaDelegata+"] non esistente");
  1928.             }
  1929.             
  1930.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1931.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1932.             sqlQueryObject.addSelectCountField("id","mapping_count");
  1933.             sqlQueryObject.addWhereCondition("id_fruizione=?");
  1934.             sqlQueryObject.addWhereCondition("id_porta=?");
  1935.             sqlQueryObject.addWhereCondition("is_default = ?");
  1936.             sqlQueryObject.setANDLogicOperator(true);
  1937.             String queryString = sqlQueryObject.createSQLQuery();
  1938.             stm = con.prepareStatement(queryString);
  1939.             stm.setLong(1, idFruizione);
  1940.             stm.setLong(2, idPD);
  1941.             stm.setLong(3, (isDefault ? 1 : 0));
  1942.             rs = stm.executeQuery();
  1943.             int found = 0;
  1944.             if (rs.next()) {
  1945.                 found = rs.getInt("mapping_count");
  1946.             }
  1947.             
  1948.             return found > 0;
  1949.         }catch(CoreException de){
  1950.             throw de;
  1951.         }
  1952.         catch(Exception e){
  1953.             throw new CoreException("getIDPortaApplicativaAssociata error",e);
  1954.         } finally {

  1956.             //Chiudo statement and resultset
  1957.             try{
  1958.                 if(rs!=null) rs.close();
  1959.             }catch (Exception e) {
  1960.                 //ignore
  1961.             }
  1962.             try{
  1963.                 if(stm!=null) stm.close();
  1964.             }catch (Exception e) {
  1965.                 //ignore
  1966.             }

  1968.         }
  1969.     } 
  1970.     
  1971.     
  1972.     
  1973.     public static MappingFruizionePortaDelegata getMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1974.             Connection con, String tipoDB) throws CoreException {
  1975.         return getMappingFruizione(idServizio, idFruitore, idPortaDelegata, con, tipoDB, CostantiDB.SOGGETTI);
  1976.     }
  1977.     public static MappingFruizionePortaDelegata getMappingFruizione(IDServizio idServizio, IDSoggetto idFruitore, IDPortaDelegata idPortaDelegata,
  1978.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1979.         long idFruizione = DBUtils.getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, tabellaSoggetti);
  1980.         if(idFruizione<=0){
  1981.             throw new CoreException("Fruizione da parte del soggetto ["+idFruitore.toString()+"] del servizio ["+idServizio.toString()+"] non esistente");
  1982.         }
  1983.         
  1984.         long idPD = DBUtils.getIdPortaDelegata(idPortaDelegata.getNome(), con, tipoDB);
  1985.         if(idPD<=0){
  1986.             throw new CoreException("PortaDelegata ["+idPortaDelegata+"] non esistente");
  1987.         }
  1988.         
  1989.         MappingFruizionePortaDelegata mapping = _getMappingFruizione(idFruizione, idPD, con, tipoDB, tabellaSoggetti);
  1990.         mapping.setIdPortaDelegata(idPortaDelegata);
  1991.         mapping.setIdServizio(idServizio);
  1992.         mapping.setIdFruitore(idFruitore);
  1993.         return mapping;
  1994.     }
  1995.     private static MappingFruizionePortaDelegata _getMappingFruizione(long idFruizione, long idPD,
  1996.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException {
  1997.         PreparedStatement stm = null;
  1998.         ResultSet rs = null;

  2000.         try {

  2002.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2003.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  2004.             sqlQueryObject.addWhereCondition("id_fruizione=?");
  2005.             sqlQueryObject.addWhereCondition("id_porta=?");
  2006.             sqlQueryObject.setANDLogicOperator(true);
  2007.             String queryString = sqlQueryObject.createSQLQuery();
  2008.             stm = con.prepareStatement(queryString);
  2009.             stm.setLong(1, idFruizione);
  2010.             stm.setLong(2, idPD);
  2011.             rs = stm.executeQuery();
  2012.             if (rs.next()) {
  2013.                 MappingFruizionePortaDelegata mapping = new MappingFruizionePortaDelegata();
  2014.                 int isDefault = rs.getInt("is_default");
  2015.                 mapping.setDefault(isDefault == 1);
  2016.                 
  2017.                 mapping.setTableId(rs.getLong("id"));
  2018.                 
  2019.                 mapping.setNome(rs.getString("nome"));          
  2020.                 mapping.setDescrizione(rs.getString("descrizione"));
  2021.                 
  2022.                 return mapping;
  2023.             }
  2024.             else{
  2025.                 throw new CoreException("Mapping tra PD (id:"+idPD+") e Fruizione (id:"+idFruizione+") non esistente");
  2026.             }
  2027.         }catch(CoreException de){
  2028.             throw de;
  2029.         }
  2030.         catch(Exception e){
  2031.             throw new CoreException("getMappingFruizione error",e);
  2032.         } finally {

  2034.             //Chiudo statement and resultset
  2035.             try{
  2036.                 if(rs!=null) rs.close();
  2037.             }catch (Exception e) {
  2038.                 //ignore
  2039.             }
  2040.             try{
  2041.                 if(stm!=null) stm.close();
  2042.             }catch (Exception e) {
  2043.                 //ignore
  2044.             }

  2046.         }
  2047.     }
  2048. }
Created with JaCoCo 0.8.8.202204050719