RegistroCore.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.  */
  20. package org.openspcoop2.core.commons.search.utils;

  22. import java.sql.Connection;
  23. import java.util.ArrayList;
  24. import java.util.Collections;
  25. import java.util.Comparator;
  26. import java.util.HashMap;
  27. import java.util.LinkedHashMap;
  28. import java.util.LinkedList;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.Map.Entry;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.commons.ProtocolFactoryReflectionUtils;
  35. import org.openspcoop2.core.commons.search.AccordoServizioParteComune;
  36. import org.openspcoop2.core.commons.search.AccordoServizioParteComuneAzione;
  37. import org.openspcoop2.core.commons.search.AccordoServizioParteComuneGruppo;
  38. import org.openspcoop2.core.commons.search.AccordoServizioParteSpecifica;
  39. import org.openspcoop2.core.commons.search.Fruitore;
  40. import org.openspcoop2.core.commons.search.IdAccordoServizioParteComune;
  41. import org.openspcoop2.core.commons.search.IdAccordoServizioParteComuneGruppo;
  42. import org.openspcoop2.core.commons.search.IdPortType;
  43. import org.openspcoop2.core.commons.search.IdSoggetto;
  44. import org.openspcoop2.core.commons.search.Operation;
  45. import org.openspcoop2.core.commons.search.PortType;
  46. import org.openspcoop2.core.commons.search.PortaApplicativa;
  47. import org.openspcoop2.core.commons.search.PortaDelegata;
  48. import org.openspcoop2.core.commons.search.Resource;
  49. import org.openspcoop2.core.commons.search.ServizioApplicativo;
  50. import org.openspcoop2.core.commons.search.Soggetto;
  51. import org.openspcoop2.core.commons.search.dao.IAccordoServizioParteComuneAzioneServiceSearch;
  52. import org.openspcoop2.core.commons.search.dao.IAccordoServizioParteComuneGruppoServiceSearch;
  53. import org.openspcoop2.core.commons.search.dao.IAccordoServizioParteComuneServiceSearch;
  54. import org.openspcoop2.core.commons.search.dao.IAccordoServizioParteSpecificaServiceSearch;
  55. import org.openspcoop2.core.commons.search.dao.IFruitoreServiceSearch;
  56. import org.openspcoop2.core.commons.search.dao.IOperationServiceSearch;
  57. import org.openspcoop2.core.commons.search.dao.IPortaApplicativaServiceSearch;
  58. import org.openspcoop2.core.commons.search.dao.IPortaDelegataServiceSearch;
  59. import org.openspcoop2.core.commons.search.dao.IResourceServiceSearch;
  60. import org.openspcoop2.core.commons.search.dao.IServizioApplicativoServiceSearch;
  61. import org.openspcoop2.core.commons.search.dao.ISoggettoServiceSearch;
  62. import org.openspcoop2.core.commons.search.dao.jdbc.JDBCAccordoServizioParteComuneServiceSearch;
  63. import org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager;
  64. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  65. import org.openspcoop2.core.constants.CostantiDB;
  66. import org.openspcoop2.core.id.IDFruizione;
  67. import org.openspcoop2.core.id.IDServizio;
  68. import org.openspcoop2.core.id.IDServizioApplicativo;
  69. import org.openspcoop2.core.id.IDSoggetto;
  70. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  71. import org.openspcoop2.generic_project.beans.CustomField;
  72. import org.openspcoop2.generic_project.exception.ExpressionException;
  73. import org.openspcoop2.generic_project.exception.ExpressionNotImplementedException;
  74. import org.openspcoop2.generic_project.exception.MultipleResultException;
  75. import org.openspcoop2.generic_project.exception.NotFoundException;
  76. import org.openspcoop2.generic_project.exception.NotImplementedException;
  77. import org.openspcoop2.generic_project.exception.ServiceException;
  78. import org.openspcoop2.generic_project.expression.IExpression;
  79. import org.openspcoop2.generic_project.expression.IPaginatedExpression;
  80. import org.openspcoop2.generic_project.expression.LikeMode;
  81. import org.openspcoop2.generic_project.expression.SortOrder;
  82. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  83. import org.openspcoop2.message.constants.ServiceBinding;
  84. import org.slf4j.Logger;

  86. /**     
  87.  * RegistroCore
  88.  *
  89.  * @author Pintori Giuliano (pintori@link.it)
  90.  * @author $Author$
  91.  * @version $Rev$, $Date$
  92.  */
  93. public class RegistroCore {
  94.     
  95.     public static JDBCServiceManager getServiceManager(Logger log, String tipoDB, Connection con) throws Exception {
  96.         return getServiceManager(log, tipoDB, true, con);
  97.     }
  98.     
  99.     public static JDBCServiceManager getServiceManager(Logger log, String tipoDB, boolean showSql, Connection con) throws Exception {
  100.         ServiceManagerProperties properties = new ServiceManagerProperties();
  101.         properties.setDatabaseType(tipoDB);
  102.         properties.setShowSql(showSql);
  103.         JDBCServiceManager manager = new JDBCServiceManager(con, properties);
  104.         
  105.         return manager;
  106.     }

  108. //  public static List<String> getProtocolli() throws Exception{
  109. //      return ProtocolFactoryReflectionUtils.getProtocolli();
  110. //  }
  111. //  
  112.     
  113.     public static List<IDSoggetto> getSoggetti(JDBCServiceManager manager, String protocollo) throws Exception{
  114.         List<String> protocolli = null;
  115.         if(protocollo!=null) {
  116.             protocolli = new ArrayList<>();
  117.             protocolli.add(protocollo);
  118.         }
  119.         return getSoggetti(manager, protocolli);
  120.     }
  121.     public static List<IDSoggetto> getSoggetti(JDBCServiceManager manager, List<String> protocolli) throws Exception{
  122.         
  123.         List<IDSoggetto> list = new ArrayList<IDSoggetto>();
  124.         
  125.         ISoggettoServiceSearch soggettoServiceSearch = manager.getSoggettoServiceSearch();
  126.         IPaginatedExpression pag = soggettoServiceSearch.newPaginatedExpression();
  127.         pag.and();
  128.         
  129.         if(protocolli!=null && protocolli.size()>0){
  130.             List<String> types = new ArrayList<>();
  131.             for (String protocollo : protocolli) {
  132.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  133.             }
  134.             pag.in(Soggetto.model().TIPO_SOGGETTO, types);
  135.         }
  136.         
  137.         pag.addOrder(Soggetto.model().NOME_SOGGETTO,SortOrder.ASC);
  138.         pag.addOrder(Soggetto.model().TIPO_SOGGETTO,SortOrder.ASC);
  139.         
  140.         List<Map<String, Object>> result = null;
  141.         try{
  142.             result = soggettoServiceSearch.select(pag, true, Soggetto.model().TIPO_SOGGETTO, Soggetto.model().NOME_SOGGETTO);
  143.         }catch(NotFoundException notFound){}
  144.         if(result!=null && result.size()>0){
  145.             for (Map<String, Object> map : result) {
  146.                 String tipo = (String) map.get(Soggetto.model().TIPO_SOGGETTO.getFieldName());
  147.                 String nome = (String) map.get(Soggetto.model().NOME_SOGGETTO.getFieldName());
  148.                 list.add(new IDSoggetto(tipo, nome));
  149.             }
  150.         }
  151.         
  152.         return list;
  153.     }
  154.     
  155.     public static List<IDSoggetto> getSoggettiFruitori(JDBCServiceManager manager, String protocollo,
  156.             String tipoSoggettoErogatore,String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws Exception{
  157.         List<String> protocolli = null;
  158.         if(protocollo!=null) {
  159.             protocolli = new ArrayList<>();
  160.             protocolli.add(protocollo);
  161.         }
  162.         return getSoggettiFruitori(manager, protocolli, tipoSoggettoErogatore, nomeSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio);
  163.     }
  164.     public static List<IDSoggetto> getSoggettiFruitori(JDBCServiceManager manager, List<String> protocolli,
  165.             String tipoSoggettoErogatore,String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws Exception{
  166.         
  167.         List<IDSoggetto> list = new ArrayList<IDSoggetto>();
  168.         
  169.         IFruitoreServiceSearch fruitoreServiceSearch = manager.getFruitoreServiceSearch();
  170.         IPaginatedExpression pag = fruitoreServiceSearch.newPaginatedExpression();
  171.         pag.and();
  172.         
  173.         if(protocolli!=null && protocolli.size()>0){
  174.             List<String> types = new ArrayList<>();
  175.             for (String protocollo : protocolli) {
  176.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  177.             }
  178.             pag.in(Fruitore.model().ID_FRUITORE.TIPO, types);
  179.         }
  180.         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  181.             pag.equals(Fruitore.model().ID_ACCORDO_SERVIZIO_PARTE_SPECIFICA.ID_EROGATORE.TIPO, tipoSoggettoErogatore);
  182.             pag.equals(Fruitore.model().ID_ACCORDO_SERVIZIO_PARTE_SPECIFICA.ID_EROGATORE.NOME, nomeSoggettoErogatore);
  183.         }
  184.         if(tipoServizio!=null && nomeServizio!=null && versioneServizio!=null){
  185.             pag.equals(Fruitore.model().ID_ACCORDO_SERVIZIO_PARTE_SPECIFICA.TIPO, tipoServizio);
  186.             pag.equals(Fruitore.model().ID_ACCORDO_SERVIZIO_PARTE_SPECIFICA.NOME, nomeServizio);
  187.             pag.equals(Fruitore.model().ID_ACCORDO_SERVIZIO_PARTE_SPECIFICA.VERSIONE, versioneServizio);
  188.         }
  189.         
  190.         pag.addOrder(Fruitore.model().ID_FRUITORE.NOME,SortOrder.ASC);
  191.         pag.addOrder(Fruitore.model().ID_FRUITORE.TIPO,SortOrder.ASC);
  192.         
  193.         List<Map<String, Object>> result = null;
  194.         try{
  195.             result = fruitoreServiceSearch.select(pag, true, Fruitore.model().ID_FRUITORE.TIPO, Fruitore.model().ID_FRUITORE.NOME);
  196.         }catch(NotFoundException notFound){}
  197.         if(result!=null && result.size()>0){
  198.             for (Map<String, Object> map : result) {
  199.                 String tipo = (String) map.get(Fruitore.model().ID_FRUITORE.getBaseField().getFieldName()+"."+Fruitore.model().ID_FRUITORE.TIPO.getFieldName());
  200.                 String nome = (String) map.get(Fruitore.model().ID_FRUITORE.getBaseField().getFieldName()+"."+Fruitore.model().ID_FRUITORE.NOME.getFieldName());
  201.                 list.add(new IDSoggetto(tipo, nome));
  202.             }
  203.         }
  204.         
  205.         return list;
  206.     }
  207.     
  208.     public static List<IDSoggetto> getSoggettiErogatori(JDBCServiceManager manager, String protocollo) throws Exception{
  209.         List<String> protocolli = null;
  210.         if(protocollo!=null) {
  211.             protocolli = new ArrayList<>();
  212.             protocolli.add(protocollo);
  213.         }
  214.         return getSoggettiErogatori(manager, protocolli);
  215.     }
  216.     public static List<IDSoggetto> getSoggettiErogatori(JDBCServiceManager manager, List<String> protocolli) throws Exception{
  217.         List<IDSoggetto> list = new ArrayList<IDSoggetto>();
  218.         
  219.         IAccordoServizioParteSpecificaServiceSearch aspsServiceSearch = manager.getAccordoServizioParteSpecificaServiceSearch();
  220.         IPaginatedExpression pag = aspsServiceSearch.newPaginatedExpression();
  221.         pag.and();
  222.         
  223.         if(protocolli!=null && protocolli.size()>0){
  224.             List<String> types = new ArrayList<>();
  225.             for (String protocollo : protocolli) {
  226.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  227.             }
  228.             pag.in(AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO, types);
  229.         }

  231.         pag.addOrder(AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME,SortOrder.ASC);
  232.         pag.addOrder(AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO,SortOrder.ASC);
  233.         
  234.         List<Map<String, Object>> result = null;
  235.         try{
  236.             result = aspsServiceSearch.select(pag, true, AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO, AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME);
  237.         }catch(NotFoundException notFound){}
  238.         if(result!=null && result.size()>0){
  239.             for (Map<String, Object> map : result) {
  240.                 String tipo = (String) map.get(AccordoServizioParteSpecifica.model().ID_EROGATORE.getBaseField().getFieldName()+"."+AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO.getFieldName());
  241.                 String nome = (String) map.get(AccordoServizioParteSpecifica.model().ID_EROGATORE.getBaseField().getFieldName()+"."+AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME.getFieldName());
  242.                 list.add(new IDSoggetto(tipo, nome));
  243.             }
  244.         }
  245.         
  246.         return list;
  247.     }
  248.     
  249.     public static List<IDServizio> getServizi(JDBCServiceManager manager, String protocollo, String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tag) throws Exception{
  250.         List<String> protocolli = null;
  251.         if(protocollo!=null) {
  252.             protocolli = new ArrayList<>();
  253.             protocolli.add(protocollo);
  254.         }
  255.         return getServizi(manager, protocolli, tipoSoggettoErogatore, nomeSoggettoErogatore, tag);
  256.     }
  257.     public static List<IDServizio> getServizi(JDBCServiceManager manager,  List<String> protocolli, String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tag) throws Exception{
  258.         return getServizi(manager, protocolli, tipoSoggettoErogatore, nomeSoggettoErogatore, tag,
  259.                 null, null, null);
  260.     }
  261.     
  262.     public static List<IDServizio> getServizi(JDBCServiceManager manager, String protocollo, String tipoServizio, String nomeServizio, Integer versioneServizio, String tag) throws Exception{
  263.         List<String> protocolli = null;
  264.         if(protocollo!=null) {
  265.             protocolli = new ArrayList<>();
  266.             protocolli.add(protocollo);
  267.         }
  268.         return getServizi(manager, protocolli, tipoServizio, nomeServizio, versioneServizio, tag);
  269.     }
  270.     public static List<IDServizio> getServizi(JDBCServiceManager manager,  List<String> protocolli, String tipoServizio, String nomeServizio, Integer versioneServizio, String tag) throws Exception{
  271.         return getServizi(manager, protocolli, null, null, tag,
  272.                 tipoServizio, nomeServizio, versioneServizio);
  273.     }
  274.     
  275.     private static List<IDServizio> getServizi(JDBCServiceManager manager,  List<String> protocolli, String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tag,
  276.             String tipoServizio, String nomeServizio, Integer versioneServizio) throws Exception{
  277.         List<IDServizio> list = new ArrayList<IDServizio>();
  278.         
  279.         IAccordoServizioParteSpecificaServiceSearch aspsServiceSearch = manager.getAccordoServizioParteSpecificaServiceSearch();
  280.         IPaginatedExpression pag = aspsServiceSearch.newPaginatedExpression();
  281.         pag.and();
  282.         
  283.         if(protocolli!=null && protocolli.size()>0){
  284.             List<String> types = new ArrayList<>();
  285.             for (String protocollo : protocolli) {
  286.                 types.addAll(ProtocolFactoryReflectionUtils.getServiceTypes(protocollo));
  287.             }
  288.             pag.in(AccordoServizioParteSpecifica.model().TIPO, types);
  289.         }

  291.         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  292.             pag.equals(AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO, tipoSoggettoErogatore);
  293.             pag.equals(AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME, nomeSoggettoErogatore);
  294.         }
  295.         
  296.         if(tipoServizio!=null && nomeServizio!=null && versioneServizio!=null){
  297.             pag.equals(AccordoServizioParteSpecifica.model().TIPO, tipoServizio);
  298.             pag.equals(AccordoServizioParteSpecifica.model().NOME, nomeServizio);
  299.             pag.equals(AccordoServizioParteSpecifica.model().VERSIONE, versioneServizio);
  300.         }
  301.         
  302.         if(tag!=null) {
  303.             IAccordoServizioParteComuneGruppoServiceSearch gruppiServiceSearch = manager.getAccordoServizioParteComuneGruppoServiceSearch();
  304.             IPaginatedExpression pagGruppi = gruppiServiceSearch.newPaginatedExpression();
  305.             pagGruppi.and();
  306.             pagGruppi.equals(AccordoServizioParteComuneGruppo.model().ID_GRUPPO.NOME, tag);
  307.             List<AccordoServizioParteComuneGruppo> listGruppi = gruppiServiceSearch.findAll(pagGruppi);
  308.             List<Long> idAccordo = new ArrayList<Long>();
  309.             if(listGruppi!=null && !listGruppi.isEmpty()) {
  310.                 for (AccordoServizioParteComuneGruppo aspcGruppo : listGruppi) {
  311.                     idAccordo.add(aspcGruppo.getIdAccordoServizioParteComune().getId());
  312.                 }
  313.             }
  314.             else {
  315.                 idAccordo.add(-4l); // volutamente per non trovare alcun servizio
  316.             }
  317.             
  318.             CustomField cf = new CustomField("idAccordo", Long.class, "id_accordo", CostantiDB.SERVIZI);
  319.             pag.in(cf, idAccordo);
  320.         }
  321.         
  322.         pag.addOrder(AccordoServizioParteSpecifica.model().NOME,SortOrder.ASC);
  323.         pag.addOrder(AccordoServizioParteSpecifica.model().VERSIONE,SortOrder.ASC);
  324.         pag.addOrder(AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME,SortOrder.ASC);
  325.         pag.addOrder(AccordoServizioParteSpecifica.model().TIPO,SortOrder.ASC);
  326.         pag.addOrder(AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO,SortOrder.ASC);
  327.         
  328.         List<Map<String, Object>> result = null;
  329.         try{
  330.             result = aspsServiceSearch.select(pag, true, 
  331.                     AccordoServizioParteSpecifica.model().TIPO, 
  332.                     AccordoServizioParteSpecifica.model().NOME,
  333.                     AccordoServizioParteSpecifica.model().VERSIONE,
  334.                     AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO,
  335.                     AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME);
  336.         }catch(NotFoundException notFound){}
  337.         if(result!=null && result.size()>0){
  338.             for (Map<String, Object> map : result) {
  339.                 String tipo = (String) map.get(AccordoServizioParteSpecifica.model().TIPO.getFieldName());
  340.                 String nome = (String) map.get(AccordoServizioParteSpecifica.model().NOME.getFieldName());
  341.                 Integer versione = (Integer) map.get(AccordoServizioParteSpecifica.model().VERSIONE.getFieldName());
  342.                 String tipoSoggetto = (String) map.get(AccordoServizioParteSpecifica.model().ID_EROGATORE.getBaseField().getFieldName()+
  343.                         "."+
  344.                         AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO.getFieldName());
  345.                 String nomeSoggetto = (String) map.get(AccordoServizioParteSpecifica.model().ID_EROGATORE.getBaseField().getFieldName()+
  346.                         "."+
  347.                         AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME.getFieldName());
  348.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipo, nome, tipoSoggetto, nomeSoggetto, versione);
  349.                 list.add(idServizio);
  350.             }
  351.         }
  352.         
  353.         return list;
  354.     }
  355.     
  356.     public static List<String> getAzioni(JDBCServiceManager manager, String protocollo, 
  357.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws Exception{
  358.         List<String> protocolli = null;
  359.         if(protocollo!=null) {
  360.             protocolli = new ArrayList<>();
  361.             protocolli.add(protocollo);
  362.         }
  363.         return getAzioni(manager, protocolli, tipoSoggettoErogatore, nomeSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio);
  364.     }
  365.     public static List<String> getAzioni(JDBCServiceManager manager, List<String> protocolli, 
  366.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws Exception{
  367.         List<String> list = new ArrayList<>();
  368.         list.addAll(getEngineAzioni(manager, protocolli, tipoSoggettoErogatore, nomeSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio,null).keySet());
  369.          
  370.         if(list!=null && !list.isEmpty()){
  371.             Collections.sort(list);
  372.         }
  373.          
  374.         return list;
  375.     }
  376.     
  377.     public static Map<String,String> getAzioniConLabel(JDBCServiceManager manager, String protocollo, String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio, String input) throws Exception{
  378.         List<String> protocolli = null;
  379.         if(protocollo!=null) {
  380.             protocolli = new ArrayList<>();
  381.             protocolli.add(protocollo);
  382.         }
  383.         Map<String,String> mapAzioni = getEngineAzioni(manager, protocolli, tipoSoggettoErogatore, nomeSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio,input);
  384.         
  385.         //convert map to a List
  386.         List<Entry<String, String>> list = new LinkedList<Map.Entry<String, String>>(mapAzioni.entrySet());

  388.         //sorting the list with a comparator
  389.         Collections.sort(list, new Comparator<Entry<String, String>>() {
  390.             @Override
  391.             public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
  392.                 return (o1.getValue()).compareTo(o2.getValue());
  393.             }
  394.         });

  396.         //convert sortedMap back to Map
  397.         Map<String, String> sortedMap = new LinkedHashMap<String, String>();
  398.         for (Entry<String, String> entry : list) {
  399.             sortedMap.put(entry.getKey(), entry.getValue());
  400.         }
  401.         
  402.         return sortedMap;
  403.     }
  404.     
  405.     public static Map<String,String> getEngineAzioni(JDBCServiceManager manager, List<String> protocolli, String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio, String input) throws Exception{
  406.         
  407.         
  408.             
  409.         // Localizzo Accordi di Servizio Parte Comune dalle Parti Specifiche
  410.         List<IdPortType> idPortTypes = new ArrayList<>();
  411.         IAccordoServizioParteSpecificaServiceSearch aspsServiceSearch = manager.getAccordoServizioParteSpecificaServiceSearch();
  412.         IPaginatedExpression pag = aspsServiceSearch.newPaginatedExpression();
  413.         pag.and();
  414.         
  415.         if(protocolli!=null && !protocolli.isEmpty()){
  416.             List<String> types = new ArrayList<>();
  417.             for (String protocollo : protocolli) {
  418.                 types.addAll(ProtocolFactoryReflectionUtils.getServiceTypes(protocollo));
  419.             }
  420.             pag.in(AccordoServizioParteSpecifica.model().TIPO, types);
  421.         }
  422.         
  423.         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  424.             pag.equals(AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO, tipoSoggettoErogatore);
  425.             pag.equals(AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME, nomeSoggettoErogatore);
  426.         }
  427.         if(tipoServizio!=null && nomeServizio!=null && versioneServizio!=null){
  428.             pag.equals(AccordoServizioParteSpecifica.model().TIPO, tipoServizio);
  429.             pag.equals(AccordoServizioParteSpecifica.model().NOME, nomeServizio);
  430.             pag.equals(AccordoServizioParteSpecifica.model().VERSIONE, versioneServizio);
  431.         }       
  432.         List<Map<String, Object>> result = null;
  433.         try{
  434.             result = aspsServiceSearch.select(pag, true, AccordoServizioParteSpecifica.model().PORT_TYPE, 
  435.                     AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME,
  436.                     AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO,
  437.                     AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME,
  438.                     AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE,
  439.                     AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.SERVICE_BINDING);
  440.         }catch(NotFoundException notFound){
  441.             //donothing
  442.         }
  443.         if(result!=null && !result.isEmpty()){
  444.             for (Map<String, Object> map : result) {
  445.                 
  446.                 IdPortType idPortType = new IdPortType();
  447.                 
  448.                 Object portType = map.get(AccordoServizioParteSpecifica.model().PORT_TYPE.getFieldName());
  449.                 if(portType!=null && (portType instanceof String)){
  450.                     idPortType.setNome((String)portType); // Può essere null
  451.                 }
  452.                 
  453.                 String nomeAccordo = (String) map.get(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.getBaseField().getFieldName()+
  454.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME.getFieldName());
  455.                 
  456.                 Object tipoSoggettoReferenteAccordo = map.get(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.getBaseField().getFieldName()+
  457.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.getBaseField().getFieldName()+
  458.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO.getFieldName());
  459.                 Object nomeSoggettoReferenteAccordo = map.get(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.getBaseField().getFieldName()+
  460.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.getBaseField().getFieldName()+
  461.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME.getFieldName());
  462.                 
  463.                 Object versioneAccordo = map.get(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.getBaseField().getFieldName()+
  464.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE.getFieldName());
  465.                 
  466.                 IdSoggetto idSoggettoReferente = null;
  467.                 if(tipoSoggettoReferenteAccordo!=null && (tipoSoggettoReferenteAccordo instanceof String) &&
  468.                         nomeSoggettoReferenteAccordo!=null && (nomeSoggettoReferenteAccordo instanceof String)){
  469.                     idSoggettoReferente = new IdSoggetto();
  470.                     idSoggettoReferente.setTipo((String)tipoSoggettoReferenteAccordo);
  471.                     idSoggettoReferente.setNome((String)nomeSoggettoReferenteAccordo);
  472.                 }
  473.                 Integer versione = null;
  474.                 if(versioneAccordo!=null && (versioneAccordo instanceof Integer)){
  475.                     versione = (Integer) versioneAccordo;
  476.                 } 
  477.                 
  478.                 String serviceBindingAccordo = (String) map.get(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.getBaseField().getFieldName()+
  479.                         "."+AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.SERVICE_BINDING.getFieldName());
  480.                 
  481.                 IdAccordoServizioParteComune idAccordo = new IdAccordoServizioParteComune();
  482.                 idAccordo.setNome(nomeAccordo);
  483.                 idAccordo.setVersione(versione);
  484.                 idAccordo.setIdSoggetto(idSoggettoReferente);
  485.                 idAccordo.setServiceBinding(serviceBindingAccordo);
  486.                 idPortType.setIdAccordoServizioParteComune(idAccordo);
  487.                 
  488.                 idPortTypes.add(idPortType);
  489.             }
  490.         }
  491.         
  492.         return getEngineAzioni(manager, input, idPortTypes);
  493.     }

  495.     private static Map<String, String> getEngineAzioni(JDBCServiceManager manager, String input, List<IdPortType> idPortTypes)
  496.             throws ServiceException, NotImplementedException, ExpressionNotImplementedException, ExpressionException {
  497.         List<String> list = new ArrayList<>();
  498.         Map<String,String> mapAzioni = new HashMap<>();
  499.         
  500.         // Localizzo Azioni dagli Accordi Implementati
  501.         if(idPortTypes!=null && !idPortTypes.isEmpty()){
  502.             for (IdPortType idPortType : idPortTypes) {
  503.                 
  504.                 ServiceBinding serviceBinding = ServiceBinding.valueOf(idPortType.getIdAccordoServizioParteComune().getServiceBinding().toUpperCase());
  505.                 
  506.                 if(ServiceBinding.REST.equals(serviceBinding)) { 
  507.                     IResourceServiceSearch aspcResourceServiceSearch = manager.getResourceServiceSearch();
  508.                     IPaginatedExpression pagResources = aspcResourceServiceSearch.newPaginatedExpression();
  509.                     pagResources.and();
  510.                     pagResources.equals(Resource.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME, idPortType.getIdAccordoServizioParteComune().getNome());
  511.                     if(idPortType.getIdAccordoServizioParteComune().getVersione()!=null){
  512.                         pagResources.equals(Resource.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE, idPortType.getIdAccordoServizioParteComune().getVersione());
  513.                     }
  514.                     if(idPortType.getIdAccordoServizioParteComune().getIdSoggetto()!=null){
  515.                         pagResources.equals(Resource.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO, 
  516.                                 idPortType.getIdAccordoServizioParteComune().getIdSoggetto().getTipo());
  517.                         pagResources.equals(Resource.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME, 
  518.                                 idPortType.getIdAccordoServizioParteComune().getIdSoggetto().getNome());
  519.                     }
  520.                     
  521.                     if(StringUtils.isNotEmpty(input)){
  522.                         IExpression exprOrMethod = aspcResourceServiceSearch.newExpression();
  523.                         exprOrMethod.ilike(Resource.model().HTTP_METHOD, input , LikeMode.ANYWHERE);
  524.                         IExpression exprOrPath = aspcResourceServiceSearch.newExpression();
  525.                         exprOrPath.ilike(Resource.model().PATH, input , LikeMode.ANYWHERE);
  526.                         pagResources.or(exprOrMethod,exprOrPath);
  527.                     }
  528.                     List<Map<String, Object>> resultAzioni = null;
  529.                     try{
  530.                         resultAzioni = aspcResourceServiceSearch.select(pagResources, true, Resource.model().NOME, Resource.model().HTTP_METHOD, Resource.model().PATH);
  531.                     }catch(NotFoundException notFound){
  532.                         //donothing
  533.                     }
  534.                     if(resultAzioni!=null && !resultAzioni.isEmpty()){
  535.                         for (Map<String, Object> azione : resultAzioni) {
  536.                             String az = (String) azione.get(Resource.model().NOME.getFieldName());
  537.                             String httpmethod = (String) azione.get(Resource.model().HTTP_METHOD.getFieldName());
  538.                             String path = (String) azione.get(Resource.model().PATH.getFieldName());
  539.                             String label = httpmethod + " " + path;
  540.                             if(!list.contains(az)){
  541.                                 list.add(az);
  542.                                 mapAzioni.put(az,label); 
  543.                             }
  544.                         }
  545.                     }
  546.                     
  547.                 }
  548.                 else {
  549.                     if(idPortType.getNome()!=null){
  550.                         
  551.                         IOperationServiceSearch portTypeAzioneServiceSearch = manager.getOperationServiceSearch();
  552.                         IPaginatedExpression pagAzioni = portTypeAzioneServiceSearch.newPaginatedExpression();
  553.                         pagAzioni.and();
  554.                         pagAzioni.equals(Operation.model().ID_PORT_TYPE.NOME, idPortType.getNome());
  555.                         pagAzioni.equals(Operation.model().ID_PORT_TYPE.ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME, idPortType.getIdAccordoServizioParteComune().getNome());
  556.                         if(idPortType.getIdAccordoServizioParteComune().getVersione()!=null){
  557.                             pagAzioni.equals(Operation.model().ID_PORT_TYPE.ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE, idPortType.getIdAccordoServizioParteComune().getVersione());
  558.                         }
  559.                         if(idPortType.getIdAccordoServizioParteComune().getIdSoggetto()!=null){
  560.                             pagAzioni.equals(Operation.model().ID_PORT_TYPE.ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO, 
  561.                                     idPortType.getIdAccordoServizioParteComune().getIdSoggetto().getTipo());
  562.                             pagAzioni.equals(Operation.model().ID_PORT_TYPE.ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME, 
  563.                                     idPortType.getIdAccordoServizioParteComune().getIdSoggetto().getNome());
  564.                         }
  565.                         if(StringUtils.isNotEmpty(input)){
  566.                             pagAzioni.ilike(Operation.model().NOME,input,LikeMode.ANYWHERE);        
  567.                         }
  568.                         List<Object> resultAzioni = null;
  569.                         try{
  570.                             resultAzioni = portTypeAzioneServiceSearch.select(pagAzioni, true, Operation.model().NOME);
  571.                         }catch(NotFoundException notFound){
  572.                             //donothing
  573.                         }
  574.                         if(resultAzioni!=null && !resultAzioni.isEmpty()){
  575.                             for (Object azione : resultAzioni) {
  576.                                 String az = (String) azione;
  577.                                 if(!list.contains(az)){
  578.                                     list.add(az);
  579.                                     mapAzioni.put(az, az); 
  580.                                 }
  581.                             }
  582.                         }
  583.                         
  584.                     }
  585.                     else{
  586.                         IAccordoServizioParteComuneAzioneServiceSearch aspcAzioneServiceSearch = manager.getAccordoServizioParteComuneAzioneServiceSearch();
  587.                         IPaginatedExpression pagAzioni = aspcAzioneServiceSearch.newPaginatedExpression();
  588.                         pagAzioni.and();
  589.                         pagAzioni.equals(AccordoServizioParteComuneAzione.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME, idPortType.getIdAccordoServizioParteComune().getNome());
  590.                         if(idPortType.getIdAccordoServizioParteComune().getVersione()!=null){
  591.                             pagAzioni.equals(AccordoServizioParteComuneAzione.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE, idPortType.getIdAccordoServizioParteComune().getVersione());
  592.                         }
  593.                         if(idPortType.getIdAccordoServizioParteComune().getIdSoggetto()!=null){
  594.                             pagAzioni.equals(AccordoServizioParteComuneAzione.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO, 
  595.                                     idPortType.getIdAccordoServizioParteComune().getIdSoggetto().getTipo());
  596.                             pagAzioni.equals(AccordoServizioParteComuneAzione.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME, 
  597.                                     idPortType.getIdAccordoServizioParteComune().getIdSoggetto().getNome());
  598.                         }
  599.                         if(StringUtils.isNotEmpty(input)){
  600.                             pagAzioni.ilike(AccordoServizioParteComuneAzione.model().NOME,input,LikeMode.ANYWHERE);     
  601.                         }
  602.                         List<Object> resultAzioni = null;
  603.                         try{
  604.                             resultAzioni = aspcAzioneServiceSearch.select(pagAzioni, true, AccordoServizioParteComuneAzione.model().NOME);
  605.                         }catch(NotFoundException notFound){
  606.                             //donothing
  607.                         }
  608.                         if(resultAzioni!=null && !resultAzioni.isEmpty()){
  609.                             for (Object azione : resultAzioni) {
  610.                                 String az = (String) azione;
  611.                                 if(!list.contains(az)){
  612.                                     list.add(az);
  613.                                     mapAzioni.put(az, az); 
  614.                                 }
  615.                             }
  616.                         }
  617.                     }
  618.                 }
  619.                 
  620.             }
  621.         }
  622.         
  623.         Map<String,String> mapAzioniReturn = new HashMap<>();
  624.         
  625.         if(list!=null && !list.isEmpty()){
  626.             Collections.sort(list);
  627.             
  628.             for (String key : list) {
  629.                 mapAzioniReturn.put(key, mapAzioni.get(key));
  630.             }
  631.         }
  632.         
  633.         return mapAzioniReturn;
  634.     }
  635.     
  636.     public static Map<String,String> getAzioniFromAPIConLabel(JDBCServiceManager manager, String protocollo, String nomeAccordo, String tipoReferente, String nomeReferente, Integer versioneAccordo, String input) throws Exception{
  637.         List<String> protocolli = null;
  638.         if(protocollo!=null) {
  639.             protocolli = new ArrayList<>();
  640.             protocolli.add(protocollo);
  641.         }
  642.         List<IdPortType> idPortTypes = new ArrayList<>();
  643.         
  644.         IAccordoServizioParteComuneServiceSearch accordoServizioParteComuneServiceSearch = manager.getAccordoServizioParteComuneServiceSearch();
  645.         IPaginatedExpression pagExpr = accordoServizioParteComuneServiceSearch.newPaginatedExpression();
  646.         pagExpr.and();

  648.         pagExpr.equals(AccordoServizioParteComune.model().ID_REFERENTE.TIPO, tipoReferente).and().equals(AccordoServizioParteComune.model().ID_REFERENTE.NOME, nomeReferente);
  649.         pagExpr.equals(AccordoServizioParteComune.model().VERSIONE, versioneAccordo).and().equals(AccordoServizioParteComune.model().NOME, nomeAccordo);
  650.         
  651.         pagExpr.sortOrder(SortOrder.ASC);
  652.         pagExpr.addOrder(AccordoServizioParteComune.model().ID_REFERENTE.TIPO);
  653.         pagExpr.addOrder(AccordoServizioParteComune.model().ID_REFERENTE.NOME);
  654.         pagExpr.addOrder(AccordoServizioParteComune.model().NOME);
  655.         pagExpr.addOrder(AccordoServizioParteComune.model().VERSIONE);

  657.         List<AccordoServizioParteComune> listAccordi = accordoServizioParteComuneServiceSearch.findAll(pagExpr);
  658.         
  659.         for (AccordoServizioParteComune accordoServizioParteComune : listAccordi) {
  660.             IdSoggetto idSoggettoReferente = new IdSoggetto();
  661.             idSoggettoReferente.setTipo(accordoServizioParteComune.getIdReferente().getTipo());
  662.             idSoggettoReferente.setNome(accordoServizioParteComune.getIdReferente().getNome());

  664.             String serviceBindingAccordo = accordoServizioParteComune.getServiceBinding();

  666.             IdAccordoServizioParteComune idAccordo = new IdAccordoServizioParteComune();
  667.             idAccordo.setNome(accordoServizioParteComune.getNome());
  668.             idAccordo.setVersione(accordoServizioParteComune.getVersione());
  669.             idAccordo.setIdSoggetto(idSoggettoReferente);
  670.             idAccordo.setServiceBinding(serviceBindingAccordo);
  671.             
  672.             List<PortType> portTypes = accordoServizioParteComune.getPortType();
  673.             
  674.             if(portTypes != null && !portTypes.isEmpty()) {
  675.                 for (PortType portType : portTypes) {
  676.                     IdPortType idPortType = new IdPortType();
  677.                     idPortType.setNome(portType.getNome());
  678.                     idPortType.setIdAccordoServizioParteComune(idAccordo);
  679.                     idPortTypes.add(idPortType);
  680.                 }
  681.             } else {
  682.                 IdPortType idPortType = new IdPortType();
  683.                 idPortType.setIdAccordoServizioParteComune(idAccordo);
  684.                 idPortTypes.add(idPortType);
  685.             }
  686.         }
  687.         
  688.         Map<String,String> mapAzioni = getEngineAzioni(manager, input, idPortTypes);
  689.         
  690.         //convert map to a List
  691.         List<Entry<String, String>> list = new LinkedList<>(mapAzioni.entrySet());

  693.         //sorting the list with a comparator
  694.         Collections.sort(list, new Comparator<Entry<String, String>>() {
  695.             @Override
  696.             public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
  697.                 return (o1.getValue()).compareTo(o2.getValue());
  698.             }
  699.         });

  701.         //convert sortedMap back to Map
  702.         Map<String, String> sortedMap = new LinkedHashMap<>();
  703.         for (Entry<String, String> entry : list) {
  704.             sortedMap.put(entry.getKey(), entry.getValue());
  705.         }
  706.         
  707.         return sortedMap;
  708.     }
  709.     
  710.     
  711.     public static List<IDServizioApplicativo> getServiziApplicativiErogatori(JDBCServiceManager manager, String protocollo, 
  712.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio,
  713.             String azione) throws Exception{
  714.         List<String> protocolli = null;
  715.         if(protocollo!=null) {
  716.             protocolli = new ArrayList<>();
  717.             protocolli.add(protocollo);
  718.         }
  719.         return getServiziApplicativiErogatori(manager, protocolli, 
  720.                 tipoSoggettoErogatore, nomeSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio, 
  721.                 azione);
  722.     }
  723.     public static List<IDServizioApplicativo> getServiziApplicativiErogatori(JDBCServiceManager manager,List<String> protocolli, 
  724.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio,
  725.             String azione) throws Exception{
  726.         List<IDServizioApplicativo> list = new ArrayList<IDServizioApplicativo>();
  727.         
  728.         IPortaApplicativaServiceSearch paServiceSearch = manager.getPortaApplicativaServiceSearch();
  729.         IPaginatedExpression pag = paServiceSearch.newPaginatedExpression();
  730.         pag.and();
  731.         
  732.         if(protocolli!=null && protocolli.size()>0){
  733.             List<String> types = new ArrayList<>();
  734.             for (String protocollo : protocolli) {
  735.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  736.             }
  737.             pag.in(PortaApplicativa.model().ID_SOGGETTO.TIPO, types);
  738.         }
  739.         
  740.         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  741.             pag.equals(PortaApplicativa.model().ID_SOGGETTO.TIPO, tipoSoggettoErogatore);
  742.             pag.equals(PortaApplicativa.model().ID_SOGGETTO.NOME, nomeSoggettoErogatore);
  743.         }
  744.         
  745.         if(tipoServizio!=null && nomeServizio!=null && versioneServizio!=null){
  746.             pag.equals(PortaApplicativa.model().TIPO_SERVIZIO, tipoServizio);
  747.             pag.equals(PortaApplicativa.model().NOME_SERVIZIO, nomeServizio);
  748.             pag.equals(PortaApplicativa.model().VERSIONE_SERVIZIO, versioneServizio);
  749.         }
  750.         
  751.         if(azione!=null){
  752.             IExpression azioneExpr = paServiceSearch.newExpression();
  753.             azioneExpr.or();
  754.             azioneExpr.equals(PortaApplicativa.model().NOME_AZIONE, azione);
  755.             azioneExpr.isNull(PortaApplicativa.model().NOME_AZIONE);
  756.             azioneExpr.isEmpty(PortaApplicativa.model().NOME_AZIONE);
  757.             azioneExpr.equals(PortaApplicativa.model().PORTA_APPLICATIVA_AZIONE.NOME, azione);
  758.             pag.and(azioneExpr);
  759.         }
  760.         
  761.         pag.addOrder(PortaApplicativa.model().PORTA_APPLICATIVA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.NOME,SortOrder.ASC);
  762.         pag.addOrder(PortaApplicativa.model().ID_SOGGETTO.NOME,SortOrder.ASC);
  763.         pag.addOrder(PortaApplicativa.model().ID_SOGGETTO.TIPO,SortOrder.ASC);
  764.         
  765.         List<Map<String, Object>> result = null;
  766.         try{
  767.             result = paServiceSearch.select(pag, true, 
  768.                     PortaApplicativa.model().PORTA_APPLICATIVA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.NOME,
  769.                     PortaApplicativa.model().ID_SOGGETTO.TIPO,
  770.                     PortaApplicativa.model().ID_SOGGETTO.NOME);
  771.         }catch(NotFoundException notFound){}
  772.         if(result!=null && result.size()>0){
  773.             for (Map<String, Object> map : result) {
  774.                 
  775.                 String nomeSA = (String) map.get(PortaApplicativa.model().PORTA_APPLICATIVA_SERVIZIO_APPLICATIVO.getBaseField().getFieldName()+
  776.                         "."+
  777.                         PortaApplicativa.model().PORTA_APPLICATIVA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.getBaseField().getFieldName()+
  778.                         "."+
  779.                         PortaApplicativa.model().PORTA_APPLICATIVA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.NOME.getFieldName());
  780.                 
  781.                 String tipoSoggetto = (String) map.get(PortaApplicativa.model().ID_SOGGETTO.getBaseField().getFieldName()+
  782.                         "."+
  783.                         PortaApplicativa.model().ID_SOGGETTO.TIPO.getFieldName());
  784.                 String nomeSoggetto = (String) map.get(PortaApplicativa.model().ID_SOGGETTO.getBaseField().getFieldName()+
  785.                         "."+
  786.                         PortaApplicativa.model().ID_SOGGETTO.NOME.getFieldName());
  787.         
  788.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  789.                 IDSoggetto idSoggetto = new IDSoggetto(tipoSoggetto,nomeSoggetto);
  790.                 idSA.setIdSoggettoProprietario(idSoggetto);
  791.                 idSA.setNome(nomeSA);
  792.                 
  793.                 list.add(idSA);
  794.             }   
  795.         }
  796.         
  797.         return list;
  798.     }
  799.     
  800.     
  801.     public static List<IDServizioApplicativo> getServiziApplicativiFruitore(JDBCServiceManager manager, String protocollo, 
  802.             String tipoSoggettoFruitore, String nomeSoggettoFruitore, 
  803.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio, 
  804.             String azione) throws Exception{
  805.         List<String> protocolli = null;
  806.         if(protocollo!=null) {
  807.             protocolli = new ArrayList<>();
  808.             protocolli.add(protocollo);
  809.         }
  810.         return getServiziApplicativiFruitore(manager, protocolli, 
  811.                 tipoSoggettoFruitore, nomeSoggettoFruitore, 
  812.                 tipoSoggettoErogatore, nomeSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio, 
  813.                 azione);
  814.     }
  815.     public static List<IDServizioApplicativo> getServiziApplicativiFruitore(JDBCServiceManager manager, List<String> protocolli, 
  816.             String tipoSoggettoFruitore, String nomeSoggettoFruitore, 
  817.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio, 
  818.             String azione) throws Exception{
  819.         List<IDServizioApplicativo> list = new ArrayList<IDServizioApplicativo>();
  820.             
  821.         IPortaDelegataServiceSearch pdServiceSearch = manager.getPortaDelegataServiceSearch();
  822.         IPaginatedExpression pag = pdServiceSearch.newPaginatedExpression();
  823.         pag.and();
  824.         
  825.         if(protocolli!=null && protocolli.size()>0){
  826.             List<String> types = new ArrayList<>();
  827.             for (String protocollo : protocolli) {
  828.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  829.             }
  830.             pag.in(PortaDelegata.model().ID_SOGGETTO.TIPO, types);
  831.         }
  832.         
  833.         if(tipoSoggettoFruitore!=null && nomeSoggettoFruitore!=null){
  834.             pag.equals(PortaDelegata.model().ID_SOGGETTO.TIPO, tipoSoggettoFruitore);
  835.             pag.equals(PortaDelegata.model().ID_SOGGETTO.NOME, nomeSoggettoFruitore);
  836.         }
  837.         
  838.         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  839.             pag.equals(PortaDelegata.model().TIPO_SOGGETTO_EROGATORE, tipoSoggettoErogatore);
  840.             pag.equals(PortaDelegata.model().NOME_SOGGETTO_EROGATORE, nomeSoggettoErogatore);
  841.         }
  842.         
  843.         if(tipoServizio!=null && nomeServizio!=null && versioneServizio!=null){
  844.             pag.equals(PortaDelegata.model().TIPO_SERVIZIO, tipoServizio);
  845.             pag.equals(PortaDelegata.model().NOME_SERVIZIO, nomeServizio);
  846.             pag.equals(PortaDelegata.model().VERSIONE_SERVIZIO, versioneServizio);
  847.         }
  848.         
  849.         if(azione!=null){
  850.             // L'azione può essere null se abbiamo modalità di riconoscimento differente da static
  851.             IExpression azioneExpr = pdServiceSearch.newExpression();
  852.             azioneExpr.or();
  853.             azioneExpr.equals(PortaDelegata.model().NOME_AZIONE, azione);
  854.             azioneExpr.isNull(PortaDelegata.model().NOME_AZIONE);
  855.             azioneExpr.isEmpty(PortaDelegata.model().NOME_AZIONE);
  856.             azioneExpr.equals(PortaDelegata.model().PORTA_DELEGATA_AZIONE.NOME, azione);
  857.             pag.and(azioneExpr);
  858.         }
  859.         
  860.         pag.addOrder(PortaDelegata.model().PORTA_DELEGATA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.NOME,SortOrder.ASC);
  861.         pag.addOrder(PortaDelegata.model().ID_SOGGETTO.NOME,SortOrder.ASC);
  862.         pag.addOrder(PortaDelegata.model().ID_SOGGETTO.TIPO,SortOrder.ASC);
  863.         
  864.         List<Map<String, Object>> result = null;
  865.         try{
  866.             result = pdServiceSearch.select(pag, true, PortaDelegata.model().PORTA_DELEGATA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.NOME,
  867.                     PortaDelegata.model().ID_SOGGETTO.TIPO,
  868.                     PortaDelegata.model().ID_SOGGETTO.NOME);
  869.         }catch(NotFoundException notFound){}
  870.         if(result!=null && result.size()>0){
  871.             for (Map<String, Object> map : result) {
  872.                 
  873.                 String nomeSA = (String) map.get(PortaDelegata.model().PORTA_DELEGATA_SERVIZIO_APPLICATIVO.getBaseField().getFieldName()+
  874.                         "."+
  875.                         PortaDelegata.model().PORTA_DELEGATA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.getBaseField().getFieldName()+
  876.                         "."+
  877.                         PortaDelegata.model().PORTA_DELEGATA_SERVIZIO_APPLICATIVO.ID_SERVIZIO_APPLICATIVO.NOME.getFieldName());
  878.                 
  879.                 String tipoSoggetto = (String) map.get(PortaDelegata.model().ID_SOGGETTO.getBaseField().getFieldName()+
  880.                         "."+
  881.                         PortaDelegata.model().ID_SOGGETTO.TIPO.getFieldName());
  882.                 String nomeSoggetto = (String) map.get(PortaDelegata.model().ID_SOGGETTO.getBaseField().getFieldName()+
  883.                         "."+
  884.                         PortaDelegata.model().ID_SOGGETTO.NOME.getFieldName());
  885.         
  886.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  887.                 IDSoggetto idSoggetto = new IDSoggetto(tipoSoggetto,nomeSoggetto);
  888.                 idSA.setIdSoggettoProprietario(idSoggetto);
  889.                 idSA.setNome(nomeSA);
  890.                 
  891.                 list.add(idSA);
  892.             }   
  893.         }
  894.         
  895.         return list;
  896.     }
  897.     
  898.     
  899.     
  900.     public static List<IDServizioApplicativo> getServiziApplicativiFruitore(JDBCServiceManager manager, String protocollo, 
  901.             String tipoSoggettoFruitore, String nomeSoggettoFruitore) throws Exception{
  902.         List<String> protocolli = null;
  903.         if(protocollo!=null) {
  904.             protocolli = new ArrayList<>();
  905.             protocolli.add(protocollo);
  906.         }
  907.         return getServiziApplicativiFruitore(manager, protocolli, 
  908.                 tipoSoggettoFruitore, nomeSoggettoFruitore);
  909.     }
  910.     public static List<IDServizioApplicativo> getServiziApplicativiFruitore(JDBCServiceManager manager, List<String> protocolli, 
  911.             String tipoSoggettoFruitore, String nomeSoggettoFruitore) throws Exception{
  912.         return getEngineServiziApplicativi(manager, protocolli, 
  913.                 tipoSoggettoFruitore, nomeSoggettoFruitore, true);
  914.     }
  915.     
  916.     public static List<IDServizioApplicativo> getServiziApplicativi(JDBCServiceManager manager, String protocollo, 
  917.             String tipoSoggettoProprietario, String nomeSoggettoProprietario) throws Exception{
  918.         List<String> protocolli = null;
  919.         if(protocollo!=null) {
  920.             protocolli = new ArrayList<>();
  921.             protocolli.add(protocollo);
  922.         }
  923.         return getServiziApplicativi(manager, protocolli, 
  924.                 tipoSoggettoProprietario, nomeSoggettoProprietario);
  925.     }
  926.     public static List<IDServizioApplicativo> getServiziApplicativi(JDBCServiceManager manager, List<String> protocolli, 
  927.             String tipoSoggettoProprietario, String nomeSoggettoProprietario) throws Exception{
  928.         return getEngineServiziApplicativi(manager, protocolli, 
  929.                 tipoSoggettoProprietario, nomeSoggettoProprietario, false);
  930.     }
  931.     
  932.     private static List<IDServizioApplicativo> getEngineServiziApplicativi(JDBCServiceManager manager, List<String> protocolli, 
  933.             String tipoSoggettoProprietario, String nomeSoggettoProprietario, boolean onlyClient) throws Exception{
  934.         List<IDServizioApplicativo> list = new ArrayList<IDServizioApplicativo>();
  935.             
  936.         IServizioApplicativoServiceSearch saServiceSearch = manager.getServizioApplicativoServiceSearch();
  937.         IPaginatedExpression pag = saServiceSearch.newPaginatedExpression();
  938.         pag.and();
  939.         
  940.         if(protocolli!=null && protocolli.size()>0){
  941.             List<String> types = new ArrayList<>();
  942.             for (String protocollo : protocolli) {
  943.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  944.             }
  945.             pag.in(ServizioApplicativo.model().ID_SOGGETTO.TIPO, types);
  946.         }
  947.         
  948.         if(tipoSoggettoProprietario!=null && nomeSoggettoProprietario!=null){
  949.             pag.equals(ServizioApplicativo.model().ID_SOGGETTO.TIPO, tipoSoggettoProprietario);
  950.             pag.equals(ServizioApplicativo.model().ID_SOGGETTO.NOME, nomeSoggettoProprietario);
  951.         }
  952.         
  953.         if(onlyClient) {
  954.             // pag.notEquals(ServizioApplicativo.model().TIPOLOGIA_FRUIZIONE, TipologiaFruizione.DISABILITATO.getValue());
  955.             // pag.isNotNull(ServizioApplicativo.model().TIPOLOGIA_FRUIZIONE);
  956.             IExpression exprOr = saServiceSearch.newExpression();
  957.             exprOr.equals(ServizioApplicativo.model().TIPO, CostantiConfigurazione.CLIENT);
  958.             exprOr.or();
  959.             exprOr.equals(ServizioApplicativo.model().AS_CLIENT, CostantiDB.TRUE);
  960.             pag.and(exprOr);
  961.         }
  962.         else {
  963.             IExpression exprOr = saServiceSearch.newExpression();
  964.             exprOr.equals(ServizioApplicativo.model().TIPO, CostantiConfigurazione.CLIENT);
  965.             exprOr.or();
  966.             exprOr.equals(ServizioApplicativo.model().TIPO, CostantiConfigurazione.SERVER);
  967.             pag.and(exprOr);
  968.         }
  969.         
  970.         pag.addOrder(ServizioApplicativo.model().NOME,SortOrder.ASC);
  971.         pag.addOrder(ServizioApplicativo.model().ID_SOGGETTO.NOME,SortOrder.ASC);
  972.         pag.addOrder(ServizioApplicativo.model().ID_SOGGETTO.TIPO,SortOrder.ASC);
  973.         
  974.         List<Map<String, Object>> result = null;
  975.         try{
  976.             result = saServiceSearch.select(pag, true, ServizioApplicativo.model().NOME,
  977.                     ServizioApplicativo.model().ID_SOGGETTO.TIPO,
  978.                     ServizioApplicativo.model().ID_SOGGETTO.NOME);
  979.         }catch(NotFoundException notFound){}
  980.         if(result!=null && result.size()>0){
  981.             for (Map<String, Object> map : result) {
  982.                 
  983.                 String nomeSA = (String) map.get(ServizioApplicativo.model().NOME.getFieldName());
  984.                 
  985.                 String tipoSoggetto = (String) map.get(ServizioApplicativo.model().ID_SOGGETTO.getBaseField().getFieldName()+
  986.                         "."+
  987.                         PortaDelegata.model().ID_SOGGETTO.TIPO.getFieldName());
  988.                 String nomeSoggetto = (String) map.get(ServizioApplicativo.model().ID_SOGGETTO.getBaseField().getFieldName()+
  989.                         "."+
  990.                         PortaDelegata.model().ID_SOGGETTO.NOME.getFieldName());
  991.         
  992.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  993.                 IDSoggetto idSoggetto = new IDSoggetto(tipoSoggetto,nomeSoggetto);
  994.                 idSA.setIdSoggettoProprietario(idSoggetto);
  995.                 idSA.setNome(nomeSA);
  996.                 
  997.                 list.add(idSA);
  998.             }   
  999.         }
  1000.         
  1001.         return list;
  1002.     }
  1003.     
  1004.     
  1005.     
  1006.     // API
  1007.     
  1008.     public static AccordoServizioParteComune getAPIImplemented(JDBCServiceManager manager,
  1009.             IDSoggetto idSoggetto, String tipoServizio, String nomeServizio, Integer versioneServizio) throws Exception {
  1010.         
  1011.         IAccordoServizioParteComuneServiceSearch aspcDAO = manager.getAccordoServizioParteComuneServiceSearch();
  1012.         IAccordoServizioParteSpecificaServiceSearch aspsDAO = manager.getAccordoServizioParteSpecificaServiceSearch();
  1013.         IExpression expr = aspsDAO.newExpression();

  1015.         expr.equals(
  1016.             AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO,
  1017.                 idSoggetto.getTipo());
  1018.         expr.and()
  1019.             .equals(AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME,
  1020.                 idSoggetto.getNome());

  1022.         expr.equals(AccordoServizioParteSpecifica.model().TIPO, tipoServizio);
  1023.         expr.and();
  1024.         expr.equals(AccordoServizioParteSpecifica.model().NOME, nomeServizio);
  1025.         expr.and();
  1026.         expr.equals(AccordoServizioParteSpecifica.model().VERSIONE, versioneServizio);
  1027.                     
  1028.         IPaginatedExpression pagExpr = aspsDAO
  1029.                 .toPaginatedExpression(expr);

  1031.         CustomField cf = new CustomField("idAccordo", Long.class, "id_accordo", "servizi");

  1033.         List<Object> list = aspsDAO.select(pagExpr,true,cf);

  1035.         if(list==null || list.isEmpty()) {
  1036.             throw new NotFoundException("NonPresente");
  1037.         }
  1038.         if(list.size()>1) {
  1039.             throw new MultipleResultException("Trovati '"+list.size()+"' api ?");
  1040.         }
  1041.         
  1042.         Long idAccordoLong = (Long) list.get(0);
  1043.         return ((JDBCAccordoServizioParteComuneServiceSearch)aspcDAO).get(idAccordoLong);

  1045.     }
  1046.     
  1047.     
  1048.     
  1049.     
  1050.     // Erogazioni
  1051.     
  1052.     public static List<IDServizio> getErogazioni(JDBCServiceManager manager, List<String> protocolli, 
  1053.             String gruppo,
  1054.             String tipoSoggetto, String nomeSoggetto) throws Exception {
  1055.         return  getErogazioni(manager, protocolli, 
  1056.                 gruppo,
  1057.                 tipoSoggetto, nomeSoggetto,
  1058.                 null, null, null,
  1059.                 null);
  1060.     }
  1061.     public static List<IDServizio> getErogazioni(JDBCServiceManager manager, List<String> protocolli, 
  1062.             String gruppo,
  1063.             String tipoSoggetto, String nomeSoggetto,
  1064.             String tipoServizio, String nomeServizio, Integer versioneServizio,
  1065.             String nomeAzione) throws Exception {
  1066.         List<IDServizio> lista = new ArrayList<IDServizio>();

  1068.         IPortaApplicativaServiceSearch portaApplicativaDAO = manager.getPortaApplicativaServiceSearch();
  1069.         IAccordoServizioParteComuneGruppoServiceSearch aspcGruppiDAO = null;
  1070.         if(gruppo!=null && !"".equals(gruppo)) {
  1071.             aspcGruppiDAO = manager.getAccordoServizioParteComuneGruppoServiceSearch();
  1072.         }
  1073.         
  1074.         IExpression pAExpr = getExpressionPA(portaApplicativaDAO, protocolli, 
  1075.                 tipoSoggetto, nomeSoggetto, 
  1076.                 tipoServizio, nomeServizio, versioneServizio, 
  1077.                 nomeAzione);
  1078.              
  1079.         List<PortaApplicativa> listaPorte = new ArrayList<PortaApplicativa>();
  1080.         IPaginatedExpression pagPaExpr = portaApplicativaDAO.toPaginatedExpression(pAExpr );
  1081.         
  1082.         pagPaExpr.addOrder(PortaApplicativa.model().ID_SOGGETTO.TIPO, SortOrder.ASC);
  1083.         pagPaExpr.addOrder(PortaApplicativa.model().ID_SOGGETTO.NOME, SortOrder.ASC);
  1084.         pagPaExpr.addOrder(PortaApplicativa.model().TIPO_SERVIZIO, SortOrder.ASC);
  1085.         pagPaExpr.addOrder(PortaApplicativa.model().NOME_SERVIZIO, SortOrder.ASC);
  1086.         pagPaExpr.addOrder(PortaApplicativa.model().VERSIONE_SERVIZIO, SortOrder.ASC);
  1087.         
  1088.         ExpressionProperties.enableSoloDatiIdentificativiServizio(pagPaExpr);
  1089.         listaPorte = portaApplicativaDAO.findAll(pagPaExpr);
  1090.         
  1091.         List<String> lstTmp = new ArrayList<>();
  1092.         for (PortaApplicativa portaApplicativa : listaPorte) {
  1093.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(portaApplicativa.getTipoServizio(), portaApplicativa.getNomeServizio(),
  1094.                         portaApplicativa.getIdSoggetto().getTipo(), portaApplicativa.getIdSoggetto().getNome(), portaApplicativa.getVersioneServizio());
  1095.             String uriFromIDServizio = IDServizioFactory.getInstance().getUriFromIDServizio(idServizio);
  1096.             
  1097.             if(gruppo!=null && !"".equals(gruppo)) {
  1098.                 
  1099.                 AccordoServizioParteComune aspc =  getAPIImplemented(manager, idServizio.getSoggettoErogatore(), idServizio.getTipo(), idServizio.getNome(), idServizio.getVersione());

  1101.                 IPaginatedExpression gruppiExpr = aspcGruppiDAO.newPaginatedExpression();
  1102.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME, aspc.getNome());
  1103.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE, aspc.getVersione());
  1104.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME, aspc.getIdReferente().getNome());
  1105.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO, aspc.getIdReferente().getTipo());
  1106.                 List<IdAccordoServizioParteComuneGruppo> lGruppi = aspcGruppiDAO.findAllIds(gruppiExpr);
  1107.                 boolean found = false;
  1108.                 if(lGruppi!=null && !lGruppi.isEmpty()) {
  1109.                     for (IdAccordoServizioParteComuneGruppo gruppoCheck : lGruppi) {
  1110.                         if(gruppoCheck.getIdGruppo().getNome().equals(gruppo)) {
  1111.                             found = true;
  1112.                             break;
  1113.                         }
  1114.                     }
  1115.                 }
  1116.                 if(!found) {
  1117.                     continue;
  1118.                 }
  1119.             }
  1120.             
  1121.             // elimino duplicati
  1122.             if(!lstTmp.contains(uriFromIDServizio)) {
  1123.                 lstTmp.add(uriFromIDServizio);
  1124.                 lista.add(idServizio);
  1125.             }
  1126.         }

  1128.         return lista;
  1129.     }
  1130.     
  1131.     private static IExpression getExpressionPA(IPortaApplicativaServiceSearch portaApplicativaDAO, List<String> protocolli, 
  1132.             String tipoSoggetto, String nomeSoggetto, 
  1133.             String tipoServizio, String nomeServizio, Integer versioneServizio,
  1134.             String nomeAzione) throws Exception {
  1135.         
  1136.         IExpression paExpr = portaApplicativaDAO.newExpression();
  1137.         

  1139.         if(StringUtils.isNotEmpty(tipoSoggetto ))
  1140.             paExpr.equals(PortaApplicativa.model().ID_SOGGETTO.TIPO, tipoSoggetto);
  1141.         if(StringUtils.isNotEmpty(nomeSoggetto ))
  1142.             paExpr.and().equals(PortaApplicativa.model().ID_SOGGETTO.NOME, nomeSoggetto);
  1143.         
  1144.         // Se ho selezionato un servizio, oppure se non ho selezionato niente 
  1145.         if(StringUtils.isNotEmpty(nomeServizio ))
  1146.             paExpr.equals(PortaApplicativa.model().NOME_SERVIZIO, nomeServizio).and();
  1147.         if(StringUtils.isNotEmpty(tipoServizio ))
  1148.             paExpr.equals(PortaApplicativa.model().TIPO_SERVIZIO, tipoServizio).and();
  1149.         if(versioneServizio != null)
  1150.             paExpr.equals(PortaApplicativa.model().VERSIONE_SERVIZIO, versioneServizio).and();

  1152.         if(StringUtils.isNotEmpty(nomeAzione )){
  1153.             IExpression azioneExpr =  portaApplicativaDAO.newExpression();
  1154.             azioneExpr.equals(PortaApplicativa.model().NOME_AZIONE, nomeAzione).or().isNull(PortaApplicativa.model().NOME_AZIONE); 
  1155.             paExpr.and(azioneExpr);
  1156.         }

  1158.         if(protocolli!=null && protocolli.size()>0){
  1159.             List<String> types = new ArrayList<>();
  1160.             for (String protocollo : protocolli) {
  1161.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  1162.             }
  1163.             paExpr.in(PortaApplicativa.model().ID_SOGGETTO.TIPO, types);
  1164.         }
  1165.     
  1166.         paExpr.notEquals(PortaApplicativa.model().MODE_AZIONE, org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione.DELEGATED_BY);
  1167.         return paExpr;
  1168.     }
  1169.     
  1170.     
  1171.     
  1172.     
  1173.     // Fruizioni
  1174.     
  1175.     public static List<IDFruizione> getFruizioni(JDBCServiceManager manager, List<String> protocolli, 
  1176.             String gruppo,
  1177.             String tipoSoggetto, String nomeSoggetto) throws Exception {
  1178.         return getFruizioni(manager, protocolli, 
  1179.                 gruppo,
  1180.                 tipoSoggetto, nomeSoggetto, 
  1181.                 null, null,
  1182.                 null ,null, null, 
  1183.                 null);
  1184.     }
  1185.     public static List<IDFruizione> getFruizioni(JDBCServiceManager manager, List<String> protocolli, 
  1186.             String gruppo,
  1187.             String tipoSoggetto, String nomeSoggetto, 
  1188.             String tipoErogatore, String nomeErogatore,
  1189.             String tipoServizio ,String nomeServizio, Integer versioneServizio, 
  1190.             String nomeAzione) throws Exception {
  1191.         List<IDFruizione> lista = new ArrayList<IDFruizione>();

  1193.         IPortaDelegataServiceSearch portaDelegataDAO = manager.getPortaDelegataServiceSearch();
  1194.         IAccordoServizioParteComuneGruppoServiceSearch aspcGruppiDAO = null;
  1195.         if(gruppo!=null && !"".equals(gruppo)) {
  1196.             aspcGruppiDAO = manager.getAccordoServizioParteComuneGruppoServiceSearch();
  1197.         }
  1198.         
  1199.         IExpression pdExpr = getExpressionPD(portaDelegataDAO, protocolli, 
  1200.                 tipoSoggetto, nomeSoggetto, 
  1201.                 tipoErogatore, nomeErogatore,   
  1202.                 tipoServizio, nomeServizio, versioneServizio, nomeAzione);
  1203.         
  1204.         List<PortaDelegata> listaPorte = new ArrayList<PortaDelegata>();
  1205.         IPaginatedExpression pagPdExpr = portaDelegataDAO.toPaginatedExpression(pdExpr );
  1206.         
  1207.         pagPdExpr.addOrder(PortaDelegata.model().ID_SOGGETTO.TIPO, SortOrder.ASC);
  1208.         pagPdExpr.addOrder(PortaDelegata.model().ID_SOGGETTO.NOME, SortOrder.ASC);
  1209.         pagPdExpr.addOrder(PortaDelegata.model().TIPO_SOGGETTO_EROGATORE, SortOrder.ASC);
  1210.         pagPdExpr.addOrder(PortaDelegata.model().NOME_SOGGETTO_EROGATORE, SortOrder.ASC);
  1211.         pagPdExpr.addOrder(PortaDelegata.model().TIPO_SERVIZIO, SortOrder.ASC);
  1212.         pagPdExpr.addOrder(PortaDelegata.model().NOME_SERVIZIO, SortOrder.ASC);
  1213.         pagPdExpr.addOrder(PortaDelegata.model().VERSIONE_SERVIZIO, SortOrder.ASC);
  1214.         
  1215.         ExpressionProperties.enableSoloDatiIdentificativiServizio(pagPdExpr);
  1216.         
  1217.         listaPorte = portaDelegataDAO.findAll(pagPdExpr);
  1218.         
  1219.         List<String> lstTmp = new ArrayList<>();
  1220.         for (PortaDelegata portaDelegata : listaPorte) {
  1221.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(portaDelegata.getTipoServizio(), portaDelegata.getNomeServizio(), portaDelegata.getTipoSoggettoErogatore(), portaDelegata.getNomeSoggettoErogatore(), portaDelegata.getVersioneServizio());
  1222.             IDSoggetto idFruitore = new IDSoggetto(portaDelegata.getIdSoggetto().getTipo(), portaDelegata.getIdSoggetto().getNome());
  1223.             IDFruizione idFruizione = new IDFruizione();
  1224.             idFruizione.setIdServizio(idServizio);
  1225.             idFruizione.setIdFruitore(idFruitore);
  1226.             String uriFromIDServizio = IDServizioFactory.getInstance().getUriFromIDServizio(idServizio);
  1227.             String uriFruizione = idFruitore.toString()+"_"+uriFromIDServizio;
  1228.             
  1229.             if(gruppo!=null && !"".equals(gruppo)) {
  1230.                 
  1231.                 AccordoServizioParteComune aspc =  getAPIImplemented(manager, idServizio.getSoggettoErogatore(), idServizio.getTipo(), idServizio.getNome(), idServizio.getVersione());

  1233.                 IPaginatedExpression gruppiExpr = aspcGruppiDAO.newPaginatedExpression();
  1234.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME, aspc.getNome());
  1235.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE, aspc.getVersione());
  1236.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME, aspc.getIdReferente().getNome());
  1237.                 gruppiExpr.equals(AccordoServizioParteComuneGruppo.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO, aspc.getIdReferente().getTipo());
  1238.                 List<IdAccordoServizioParteComuneGruppo> lGruppi = aspcGruppiDAO.findAllIds(gruppiExpr);
  1239.                 boolean found = false;
  1240.                 if(lGruppi!=null && !lGruppi.isEmpty()) {
  1241.                     for (IdAccordoServizioParteComuneGruppo gruppoCheck : lGruppi) {
  1242.                         if(gruppoCheck.getIdGruppo().getNome().equals(gruppo)) {
  1243.                             found = true;
  1244.                             break;
  1245.                         }
  1246.                     }
  1247.                 }
  1248.                 if(!found) {
  1249.                     continue;
  1250.                 }
  1251.             }
  1252.             
  1253.             // elimino duplicati
  1254.             if(!lstTmp.contains(uriFruizione)) {
  1255.                 lstTmp.add(uriFruizione);
  1256.                 lista.add(idFruizione);
  1257.             }
  1258.         }

  1260.         return lista;
  1261.     }
  1262.     
  1263.     private static IExpression getExpressionPD(IPortaDelegataServiceSearch portaDelegataDAO, List<String> protocolli, 
  1264.             String tipoSoggetto, String nomeSoggetto, 
  1265.             String tipoErogatore, String nomeErogatore, 
  1266.             String tipoServizio, String nomeServizio, Integer versioneServizio,
  1267.             String nomeAzione) throws Exception {
  1268.         
  1269.         IExpression pdExpr = portaDelegataDAO.newExpression();

  1271.         // Se ho selezionato un servizio, oppure se non ho selezionato niente 
  1272.         if(StringUtils.isNotEmpty(tipoSoggetto ))
  1273.             pdExpr.equals(PortaDelegata.model().ID_SOGGETTO.TIPO, tipoSoggetto);
  1274.         if(StringUtils.isNotEmpty(nomeSoggetto ))
  1275.             pdExpr.and().equals(PortaDelegata.model().ID_SOGGETTO.NOME, nomeSoggetto);
  1276.         
  1277.         if(StringUtils.isNotEmpty(nomeErogatore ))
  1278.             pdExpr.equals(PortaDelegata.model().NOME_SOGGETTO_EROGATORE, nomeErogatore).and();
  1279.         if(StringUtils.isNotEmpty(tipoErogatore ))
  1280.             pdExpr.equals(PortaDelegata.model().TIPO_SOGGETTO_EROGATORE, tipoErogatore).and();

  1282.         if(StringUtils.isNotEmpty(tipoServizio ))
  1283.             pdExpr.equals(PortaDelegata.model().TIPO_SERVIZIO,      tipoServizio);
  1284.         if(StringUtils.isNotEmpty(nomeServizio ))
  1285.             pdExpr.and().equals(PortaDelegata.model().NOME_SERVIZIO, nomeServizio);
  1286.         if(versioneServizio != null)
  1287.             pdExpr.equals(PortaDelegata.model().VERSIONE_SERVIZIO, versioneServizio).and();
  1288.         
  1289.         if(StringUtils.isNotEmpty(nomeAzione )){
  1290.             IExpression azioneExpr =  portaDelegataDAO.newExpression();
  1291.             azioneExpr.equals(PortaDelegata.model().NOME_AZIONE, nomeAzione).or().isNull(PortaDelegata.model().NOME_AZIONE); 
  1292.             pdExpr.and(azioneExpr);
  1293.         }
  1294.         
  1295.         if(protocolli!=null && protocolli.size()>0){
  1296.             List<String> types = new ArrayList<>();
  1297.             for (String protocollo : protocolli) {
  1298.                 types.addAll(ProtocolFactoryReflectionUtils.getOrganizationTypes(protocollo));
  1299.             }
  1300.             pdExpr.in(PortaDelegata.model().ID_SOGGETTO.TIPO, types);
  1301.         }
  1302.         
  1303.         pdExpr.notEquals(PortaDelegata.model().MODE_AZIONE, org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione.DELEGATED_BY);
  1304.         return pdExpr;
  1305.     }
  1306.     
  1307. }
Created with JaCoCo 0.8.8.202204050719