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


  22. package org.openspcoop2.web.ctrlstat.servlet.archivi;

  24. import java.util.ArrayList;
  25. import java.util.List;

  27. import javax.servlet.http.HttpServletRequest;
  28. import javax.servlet.http.HttpServletResponse;
  29. import javax.servlet.http.HttpSession;

  31. import org.apache.struts.action.Action;
  32. import org.apache.struts.action.ActionForm;
  33. import org.apache.struts.action.ActionForward;
  34. import org.apache.struts.action.ActionMapping;
  35. import org.openspcoop2.core.id.IDAccordo;
  36. import org.openspcoop2.core.id.IDAccordoCooperazione;
  37. import org.openspcoop2.core.id.IDFruizione;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.id.IDServizioApplicativo;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.protocol.sdk.archive.ArchiveCascadeConfiguration;
  42. import org.openspcoop2.protocol.sdk.archive.ExportMode;
  43. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  44. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  45. import org.openspcoop2.web.ctrlstat.servlet.GeneralHelper;
  46. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCostanti;
  47. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  48. import org.openspcoop2.web.ctrlstat.servlet.apc.api.ApiCostanti;
  49. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  50. import org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni.ErogazioniCostanti;
  51. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  52. import org.openspcoop2.web.ctrlstat.servlet.gruppi.GruppiCostanti;
  53. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCostanti;
  54. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  55. import org.openspcoop2.web.ctrlstat.servlet.scope.ScopeCostanti;
  56. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  57. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  58. import org.openspcoop2.web.lib.mvc.Costanti;
  59. import org.openspcoop2.web.lib.mvc.DataElement;
  60. import org.openspcoop2.web.lib.mvc.GeneralData;
  61. import org.openspcoop2.web.lib.mvc.PageData;
  62. import org.openspcoop2.web.lib.mvc.Parameter;
  63. import org.openspcoop2.web.lib.mvc.ServletUtils;

  65. /**
  66.  * Exporter
  67.  * 
  68.  * @author Andrea Poli (apoli@link.it)
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  * 
  72.  */
  73. public final class Exporter extends Action {

  75.     @Override
  76.     public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

  78.         HttpSession session = request.getSession(true);

  80.         // Inizializzo PageData
  81.         PageData pd = new PageData();

  83.         GeneralHelper generalHelper = new GeneralHelper(session);

  85.         // Inizializzo GeneralData
  86.         GeneralData gd = generalHelper.initGeneralData(request);

  88.         try {
  89.             
  90.             //String userLogin = ServletUtils.getUserLoginFromSession(session);
  91.             
  92.             ArchiviHelper archiviHelper = new ArchiviHelper(request, pd, session);
  93.             ArchiviCore archiviCore = new ArchiviCore();
  94.             SoggettiCore soggettiCore = new SoggettiCore(archiviCore);
  95.         
  96.             ExporterUtils exporterUtils = new ExporterUtils(archiviCore);
  97.             
  98.             
  99.             // Sorgente su cui e' stato invocato l'export
  100.             String servletSourceExport = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO);
  101.             ArchiveType archiveType = ArchiveType.valueOf(servletSourceExport);
  102.             
  103.             
  104.             // Elementi selezionati per l'export
  105.             String objToExport = archiviHelper.getParameter(Costanti.PARAMETER_NAME_OBJECTS_FOR_REMOVE); 
  106.             
  107.             
  108.             // Cascade
  109.             String cascadePolicyConfig = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_POLICY_CONFIG);
  110.             String cascadePluginConfig = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PLUGIN_CONFIG);
  111.             String cascade = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE);
  112.             
  113.             String cascadePdd = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PDD);
  114.             String cascadeRuoli = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_RUOLI);
  115.             String cascadeScope = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SCOPE);
  116.             String cascadeSoggetti = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SOGGETTI);
  117.             String cascadeServiziApplicativi = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SERVIZI_APPLICATIVI);
  118.             String cascadePorteDelegate = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_DELEGATE);
  119.             String cascadePorteApplicative = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_APPLICATIVE);
  120.             String cascadeAccordiCooperazione = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_COOPERAZIONE);
  121.             String cascadeAccordiServizioComposto = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_COMPOSTO);
  122.             String cascadeAccordiServizioParteComune = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_COMUNE);
  123.             String cascadeAccordiServizioParteSpecifica = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_SPECIFICA);
  124.             String cascadeFruizioni = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_FRUIZIONI);
  125.                     
  126.             // TipoConfigurazione
  127.             String tipoConfigurazione = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO_DUMP);
  128.             
  129.             
  130.             // Recuperi eventuali identificativi logici degli oggetti
  131.             Parameter provenienza = null;
  132.             String urlTitle = null;
  133.             List<?> identificativi = null;
  134.             List<String> protocolli = new ArrayList<>();
  135.             switch (archiveType) {
  136.             case SOGGETTO:
  137.                 provenienza = new Parameter(SoggettiCostanti.LABEL_SOGGETTI, SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST);
  138.                 identificativi = exporterUtils.getIdsSoggetti(objToExport);
  139.                 for (Object id : identificativi) {
  140.                     IDSoggetto idSoggetto = (IDSoggetto) id;
  141.                     String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(idSoggetto.getTipo());
  142.                     if(protocolli.contains(protocollo)==false){
  143.                         protocolli.add(protocollo);
  144.                     }
  145.                 }
  146.                 break;
  147.             case ACCORDO_SERVIZIO_PARTE_COMUNE:
  148.                 String servletApi = AccordiServizioParteComuneCostanti.SERVLET_NAME_APC_LIST;
  149.                 if(!archiviHelper.isModalitaCompleta()) {
  150.                     servletApi = ApiCostanti.SERVLET_NAME_APC_API_LIST;
  151.                 }
  152.                 provenienza = new Parameter(AccordiServizioParteComuneCostanti.LABEL_APC, servletApi,
  153.                         new Parameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_TIPO_ACCORDO, AccordiServizioParteComuneCostanti.PARAMETRO_VALORE_APC_TIPO_ACCORDO_PARTE_COMUNE));
  154.                 identificativi = exporterUtils.getIdsAccordiServizioParteComune(objToExport);
  155.                 for (Object id : identificativi) {
  156.                     IDAccordo idAccordo = (IDAccordo) id;
  157.                     String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(idAccordo.getSoggettoReferente().getTipo());
  158.                     if(protocolli.contains(protocollo)==false){
  159.                         protocolli.add(protocollo);
  160.                     }
  161.                 }
  162.                 break;
  163.             case ACCORDO_SERVIZIO_COMPOSTO:
  164.                 provenienza = new Parameter(AccordiServizioParteComuneCostanti.LABEL_ASC, AccordiServizioParteComuneCostanti.SERVLET_NAME_APC_LIST,
  165.                         new Parameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_TIPO_ACCORDO, AccordiServizioParteComuneCostanti.PARAMETRO_VALORE_APC_TIPO_ACCORDO_SERVIZIO_COMPOSTO));
  166.                 identificativi = exporterUtils.getIdsAccordiServizioComposti(objToExport);
  167.                 for (Object id : identificativi) {
  168.                     IDAccordo idAccordo = (IDAccordo) id;
  169.                     String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(idAccordo.getSoggettoReferente().getTipo());
  170.                     if(protocolli.contains(protocollo)==false){
  171.                         protocolli.add(protocollo);
  172.                     }
  173.                 }
  174.                 break;
  175.             case ACCORDO_SERVIZIO_PARTE_SPECIFICA:
  176.             case EROGAZIONE:
  177.             case FRUIZIONE:
  178.                 
  179.                 String tipologia = ServletUtils.getObjectFromSession(request, session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  180.                 boolean gestioneFruitori = false;
  181.                 if(tipologia!=null) {
  182.                     if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  183.                         gestioneFruitori = true;
  184.                     }
  185.                 }
  186.                 
  187.                 Boolean vistaErogazioni = ServletUtils.getBooleanAttributeFromSession(ErogazioniCostanti.ASPS_EROGAZIONI_ATTRIBUTO_VISTA_EROGAZIONI, session, request).getValue();
  188.                 if(vistaErogazioni != null && vistaErogazioni.booleanValue()) {
  189.                     if(gestioneFruitori) {
  190.                         provenienza = new Parameter(ErogazioniCostanti.LABEL_ASPS_FRUIZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST);
  191.                     }
  192.                     else {
  193.                         provenienza = new Parameter(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST);
  194.                     }
  195.                 }
  196.                 else {
  197.                     if(gestioneFruitori) {
  198.                         provenienza = new Parameter(AccordiServizioParteSpecificaCostanti.LABEL_APS_FRUITORI, AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_LIST);
  199.                     }
  200.                     else {
  201.                         provenienza = new Parameter(AccordiServizioParteSpecificaCostanti.LABEL_APS, AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_LIST);
  202.                     }
  203.                 }
  204.                 identificativi = exporterUtils.getIdsAccordiServizioParteSpecifica(objToExport, gestioneFruitori);
  205.                 for (Object id : identificativi) {
  206.                     IDServizio idServizio = null;
  207.                     if(gestioneFruitori) {
  208.                         idServizio = ((IDFruizione) id).getIdServizio();
  209.                     }
  210.                     else {
  211.                         idServizio = (IDServizio) id;
  212.                     }
  213.                     String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(idServizio.getSoggettoErogatore().getTipo());
  214.                     if(protocolli.contains(protocollo)==false){
  215.                         protocolli.add(protocollo);
  216.                     }
  217.                 }
  218.                 break;
  219.             case ACCORDO_COOPERAZIONE:
  220.                 provenienza = new Parameter(AccordiCooperazioneCostanti.LABEL_ACCORDI_COOPERAZIONE, AccordiCooperazioneCostanti.SERVLET_NAME_ACCORDI_COOPERAZIONE_LIST);
  221.                 identificativi = exporterUtils.getIdsAccordiCooperazione(objToExport);
  222.                 for (Object id : identificativi) {
  223.                     IDAccordoCooperazione idAccordo = (IDAccordoCooperazione) id;
  224.                     String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(idAccordo.getSoggettoReferente().getTipo());
  225.                     if(protocolli.contains(protocollo)==false){
  226.                         protocolli.add(protocollo);
  227.                     }
  228.                 }
  229.                 break;
  230.             case SERVIZIO_APPLICATIVO:
  231.                 provenienza = new Parameter(ServiziApplicativiCostanti.LABEL_APPLICATIVI, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST);
  232.                 identificativi = exporterUtils.getIdsServiziApplicativi(objToExport);
  233.                 for (Object id : identificativi) {
  234.                     IDServizioApplicativo idServizioApplicativo = (IDServizioApplicativo) id;
  235.                     String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  236.                     if(protocolli.contains(protocollo)==false){
  237.                         protocolli.add(protocollo);
  238.                     }
  239.                 }
  240.                 break;
  241.             case GRUPPO:
  242.                 provenienza = new Parameter(GruppiCostanti.LABEL_GRUPPI, GruppiCostanti.SERVLET_NAME_GRUPPI_LIST);
  243.                 identificativi = exporterUtils.getIdsGruppi(objToExport);
  244.                 protocolli = archiviCore.getProtocolli(request, session);
  245.                 break;
  246.             case RUOLO:
  247.                 provenienza = new Parameter(RuoliCostanti.LABEL_RUOLI, RuoliCostanti.SERVLET_NAME_RUOLI_LIST);
  248.                 identificativi = exporterUtils.getIdsRuoli(objToExport);
  249.                 protocolli = archiviCore.getProtocolli(request, session);
  250.                 break;
  251.             case SCOPE:
  252.                 provenienza = new Parameter(ScopeCostanti.LABEL_SCOPE, ScopeCostanti.SERVLET_NAME_SCOPE_LIST);
  253.                 identificativi = exporterUtils.getIdsScope(objToExport);
  254.                 protocolli = archiviCore.getProtocolli(request, session);
  255.                 break;
  256.             case CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIG_POLICY:
  257.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_POLICY, 
  258.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIGURAZIONE_POLICY_LIST);
  259.                 identificativi = exporterUtils.getIdsControlloTrafficoConfigPolicy(objToExport);
  260.                 protocolli = archiviCore.getProtocolli(request, session);
  261.                 break;
  262.             case CONFIGURAZIONE_CONTROLLO_TRAFFICO_ACTIVE_POLICY:
  263.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK, 
  264.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_LIST);
  265.                 identificativi = exporterUtils.getIdsControlloTrafficoActivePolicy(objToExport);
  266.                 protocolli = archiviCore.getProtocolli(request, session);
  267.                 break;
  268.             case ALLARME:
  269.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI, 
  270.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_LIST);
  271.                 identificativi = exporterUtils.getIdsAllarmi(objToExport);
  272.                 protocolli = archiviCore.getProtocolli(request, session);
  273.                 break;
  274.             case CONFIGURAZIONE_TOKEN_POLICY:
  275.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN, 
  276.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_LIST+"?"+
  277.                                 ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE+"="+ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE_VALORE_TOKEN);
  278.                 identificativi = exporterUtils.getIdsTokenPolicy(objToExport);
  279.                 protocolli = archiviCore.getProtocolli(request, session);
  280.                 break;
  281.             case CONFIGURAZIONE_ATTRIBUTE_AUTHORITY:
  282.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY, 
  283.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_LIST+"?"+
  284.                                 ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE+"="+ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE_VALORE_ATTRIBUTE_AUTHORITY);
  285.                 identificativi = exporterUtils.getIdsTokenPolicy(objToExport);
  286.                 protocolli = archiviCore.getProtocolli(request, session);
  287.                 break;
  288.             case CONFIGURAZIONE_PLUGIN_CLASSE:
  289.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_CLASSI, 
  290.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_CLASSI_LIST);
  291.                 identificativi = exporterUtils.getIdsPluginClassi(objToExport);
  292.                 protocolli = archiviCore.getProtocolli(request, session);
  293.                 break;
  294.             case CONFIGURAZIONE_PLUGIN_ARCHVIO:
  295.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_REGISTRO_ARCHIVI, 
  296.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_LIST);
  297.                 identificativi = exporterUtils.getIdsPluginArchivi(objToExport);
  298.                 protocolli = archiviCore.getProtocolli(request, session);
  299.                 break;
  300.             case CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA:
  301.                 provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROXY_PASS_REGOLE,
  302.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_LIST);
  303.                 identificativi = exporterUtils.getIdsUrlInvocazioneRegole(objToExport);
  304.                 protocolli = archiviCore.getProtocolli(request, session);
  305.                 break;
  306.             case CONFIGURAZIONE:
  307.                 //provenienza = new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE, null); e' al primo livello
  308.                 protocolli = archiviCore.getProtocolli(request, session);
  309.                 if(tipoConfigurazione==null){
  310.                     tipoConfigurazione = ArchiveType.ALL.toString();
  311.                 }
  312.                 // al primo livello il link non ci vuole
  313.                 //urlTitle = ArchiviCostanti.SERVLET_NAME_ARCHIVI_EXPORT+"?"+ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+ArchiveType.CONFIGURAZIONE.name();
  314.                 break;
  315.             default:
  316.                 throw new Exception("Archive type ["+servletSourceExport+"] non supportato");
  317.             }
  318.             
  319.             
  320.             
  321.             // Eventuale PostBack element name che ha scaturito l'evento
  322.             String postBackElementName = archiviHelper.getPostBackElementName();
  323.             

  325.                     
  326.             // protocolli disponibili compatibili con la sorgente degli oggetti selezionati
  327. //          if(protocolli.size()>1){
  328. //              protocolli = new ArrayList<>();
  329. //              protocolli.add(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED);
  330. //              protocolli.addAll(archiviCore.getProtocolli());
  331. //          }
  332. //          this.protocollo = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO);
  333. //          if("".equals(this.protocollo) || ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(this.protocollo)){
  334. //              this.protocollo = null;
  335. //          }
  336.             // Volutamente per default si vogliono tutti!
  337. //          if(this.protocollo==null){
  338. //              this.protocollo = archiviCore.getProtocolloDefault();
  339. //          }
  340.             String protocollo = protocolli.get(0); // tanto poi selezionero' un export modes compatibile con tutti i protocolli presenti.
  341.             
  342.             
  343.             // export modes (compatibile con tutti i protocolli degli oggetti selezionati)
  344.             List<ExportMode> exportModes = exporterUtils.getExportModesCompatibleWithAllProtocol(protocolli, archiveType);
  345.             boolean errore = false;
  346.             String motivoErrore = null;
  347.             if(exportModes.size()<1){
  348.                 errore = true;
  349.                 if(protocolli.size() > 1)
  350.                     motivoErrore = "&Egrave; stata richiesta una export di oggetti appartenenti a protocolli ("+protocolli.toString()+") che non prevedono il medesimo formato di esportazione";
  351.                 else 
  352.                     motivoErrore = "&Egrave; stata richiesta una export di oggetti appartenenti a protocolli ("+protocolli.toString()+") che non prevedono un formato di esportazione";
  353.             }
  354.             String exportMode = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  355.             if(exportMode!=null){
  356.                 // verifico che esista nei modes disponibili per i protocolli selezionati
  357.                 if(exportModes.contains(new ExportMode(exportMode))==false){
  358.                     exportMode = null;
  359.                 }
  360.             }
  361.             if(exportMode==null && !errore){
  362.                 if(exportModes.contains(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE)){
  363.                     exportMode = org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE.toString();
  364.                 }else{
  365.                     exportMode = exportModes.get(0).toString();
  366.                 }
  367.             }
  368.             
  369.             
  370.         

  372.             
  373.             
  374.             
  375.             // Controllo se ho terminato di impostare le proprieta' e devo procedere con l'esportazione.
  376.             boolean fineSceltaOpzioniEsportazione = !archiviHelper.isEditModeInProgress()  &&
  377.                     (postBackElementName==null || "".equals(postBackElementName));
  378.             boolean configurationEnabled = ArchiveType.CONFIGURAZIONE.equals(archiveType) && !archiviCore.isExportArchive_configurazione_soloDumpCompleto();
  379.             boolean cascadeEnabled = !ArchiveType.CONFIGURAZIONE.equals(archiveType) && archiviCore.isCascadeEnabled(exportModes, exportMode);
  380.             boolean nonSonoPresentiScelteEsportazione = (exportModes.size()==1) && !cascadeEnabled && !configurationEnabled;
  381.             if( !errore && 
  382.                     ( fineSceltaOpzioniEsportazione ||  nonSonoPresentiScelteEsportazione ) 
  383.                 ) {
  384.                 
  385.                 String send = ArchiviCostanti.SERVLET_NAME_PACKAGE_EXPORT+"?"+
  386.                         ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+servletSourceExport;
  387.                 // Identificativo TAB
  388.                 send = send + "&" + Costanti.PARAMETER_TAB_KEY +"=" + archiviHelper.getParameter(Costanti.PARAMETER_PREV_TAB_KEY);
  389.                 if(objToExport!=null && !"".equals(objToExport)){
  390.                     send = send + "&" + Costanti.PARAMETER_NAME_OBJECTS_FOR_REMOVE+"="+ objToExport;
  391.                 }
  392.                 if(protocollo!=null && !"".equals(protocollo)){
  393.                     send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO+"="+ protocollo;
  394.                 }
  395.                 if(exportMode!=null && !"".equals(exportMode)){
  396.                     send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO+"="+ exportMode;
  397.                 }
  398.                 if(tipoConfigurazione!=null && !"".equals(tipoConfigurazione)){
  399.                     send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO_DUMP+"="+ tipoConfigurazione;
  400.                 }
  401.                 if(cascadeEnabled){
  402.                     send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_POLICY_CONFIG+"="+ (ServletUtils.isCheckBoxEnabled(cascadePolicyConfig)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  403.                     send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PLUGIN_CONFIG+"="+ (ServletUtils.isCheckBoxEnabled(cascadePluginConfig)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  404.                     send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE+"="+ (ServletUtils.isCheckBoxEnabled(cascade)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  405.                     ArchiveCascadeConfiguration cascadeConfig = archiviCore.getCascadeConfig(exportModes, exportMode);
  406.                     if(cascadeConfig.isCascadePdd()){
  407.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PDD+"="+ (ServletUtils.isCheckBoxEnabled(cascadePdd)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  408.                     }
  409.                     if(cascadeConfig.isCascadeRuoli()){
  410.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_RUOLI+"="+ (ServletUtils.isCheckBoxEnabled(cascadeRuoli)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  411.                     }
  412.                     if(cascadeConfig.isCascadeScope()){
  413.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SCOPE+"="+ (ServletUtils.isCheckBoxEnabled(cascadeScope)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  414.                     }
  415.                     if(cascadeConfig.isCascadeSoggetti()){
  416.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SOGGETTI+"="+ (ServletUtils.isCheckBoxEnabled(cascadeSoggetti)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  417.                     }
  418.                     if(cascadeConfig.isCascadeServiziApplicativi()){
  419.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SERVIZI_APPLICATIVI+"="+ (ServletUtils.isCheckBoxEnabled(cascadeServiziApplicativi)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  420.                     }
  421.                     if(cascadeConfig.isCascadePorteDelegate()){
  422.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_DELEGATE+"="+ (ServletUtils.isCheckBoxEnabled(cascadePorteDelegate)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  423.                     }
  424.                     if(cascadeConfig.isCascadePorteApplicative()){
  425.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_APPLICATIVE+"="+ (ServletUtils.isCheckBoxEnabled(cascadePorteApplicative)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  426.                     }
  427.                     if(cascadeConfig.isCascadeAccordoCooperazione()){
  428.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_COOPERAZIONE+"="+ (ServletUtils.isCheckBoxEnabled(cascadeAccordiCooperazione)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  429.                     }
  430.                     if(cascadeConfig.isCascadeAccordoServizioParteComune()){
  431.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_COMUNE+"="+ (ServletUtils.isCheckBoxEnabled(cascadeAccordiServizioParteComune)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  432.                     }
  433.                     if(cascadeConfig.isCascadeAccordoServizioComposto()){
  434.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_COMPOSTO+"="+ (ServletUtils.isCheckBoxEnabled(cascadeAccordiServizioComposto)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  435.                     }
  436.                     if(cascadeConfig.isCascadeAccordoServizioParteSpecifica()){
  437.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_SPECIFICA+"="+ (ServletUtils.isCheckBoxEnabled(cascadeAccordiServizioParteSpecifica)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  438.                     }
  439.                     if(cascadeConfig.isCascadeFruizioni()){
  440.                         send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_FRUIZIONI+"="+ (ServletUtils.isCheckBoxEnabled(cascadeFruizioni)?Costanti.CHECK_BOX_ENABLED:Costanti.CHECK_BOX_DISABLED);
  441.                     }
  442.                 }
  443.                 //System.out.println("invoke EXPORT ["+send+"]....");
  444.                 response.sendRedirect(send);
  445.                 
  446.             }
  447.             
  448.             
  449.             
  450.             // Visualizzo form delle opzioni    
  451.                 
  452.             archiviHelper.makeMenu();
  453.             
  454.             
  455.             // setto la barra del titolo    
  456.             if(provenienza!=null) {
  457.                 ServletUtils.setPageDataTitle(pd, 
  458.                         provenienza,
  459.                         new Parameter(ArchiviCostanti.LABEL_ARCHIVI_EXPORT,urlTitle));
  460.             }
  461.             else {
  462.                 ServletUtils.setPageDataTitle(pd, 
  463.                         new Parameter(ArchiviCostanti.LABEL_ARCHIVI_EXPORT,urlTitle));
  464.             }
  465.         
  466.             List<DataElement> dati = new ArrayList<>();
  467.             
  468.             // imposto grafica
  469.             dati.add(ServletUtils.getDataElementForEditModeFinished());

  471.             // init cascade
  472.             if(ServletUtils.isCheckBoxEnabled(cascade) 
  473.                     &&
  474.                     (ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE.equals(postBackElementName) || ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO.equals(postBackElementName)) ){
  475.                 cascadePdd = Costanti.CHECK_BOX_ENABLED;
  476.                 cascadeRuoli = Costanti.CHECK_BOX_ENABLED;
  477.                 cascadeScope = Costanti.CHECK_BOX_ENABLED;
  478.                 cascadeSoggetti = Costanti.CHECK_BOX_ENABLED;
  479.                 cascadeServiziApplicativi = Costanti.CHECK_BOX_ENABLED;
  480.                 cascadePorteDelegate = Costanti.CHECK_BOX_ENABLED;
  481.                 cascadePorteApplicative = Costanti.CHECK_BOX_ENABLED;
  482.                 cascadeAccordiCooperazione = Costanti.CHECK_BOX_ENABLED;
  483.                 cascadeAccordiServizioComposto = Costanti.CHECK_BOX_ENABLED;
  484.                 cascadeAccordiServizioParteComune = Costanti.CHECK_BOX_ENABLED;
  485.                 cascadeAccordiServizioParteSpecifica = Costanti.CHECK_BOX_ENABLED;
  486.                 cascadeFruizioni = Costanti.CHECK_BOX_ENABLED;
  487.             }
  488.             
  489.             archiviHelper.addExportToDati(dati, protocolli, protocollo, 
  490.                     exportModes, exportMode, 
  491.                     archiveType, objToExport,
  492.                     cascadePolicyConfig, cascadePluginConfig, cascade,tipoConfigurazione,
  493.                     cascadePdd,cascadeRuoli,cascadeScope,cascadeSoggetti,
  494.                     cascadeServiziApplicativi, cascadePorteDelegate, cascadePorteApplicative,
  495.                     cascadeAccordiCooperazione, cascadeAccordiServizioParteComune, 
  496.                     cascadeAccordiServizioComposto, 
  497.                     cascadeAccordiServizioParteSpecifica, cascadeFruizioni);
  498.                             
  499.             
  500.             pd.setDati(dati);

  502.             pd.setLabelBottoneInvia(ArchiviCostanti.LABEL_ARCHIVI_EXPORT);
  503.             pd.setDisabilitaAjaxStatusBottoneInvia();
  504.             
  505.             if(errore){
  506.                 pd.setMessage(motivoErrore);
  507.                 
  508.                 pd.setMode(Costanti.DATA_ELEMENT_EDIT_MODE_DISABLE_NAME);
  509.                 
  510.             }
  511.             
  512.             ServletUtils.setGeneralAndPageDataIntoSession(request, session, gd, pd);
  513.         
  514.             return ServletUtils.getStrutsForwardEditModeFinished(mapping, ArchiviCostanti.OBJECT_NAME_ARCHIVI_EXPORT, 
  515.                     ArchiviCostanti.TIPO_OPERAZIONE_EXPORT);
  516.             
  517.         } catch (Exception e) {
  518.             return ServletUtils.getStrutsForwardError(ControlStationCore.getLog(), e, pd, request, session, gd, mapping, 
  519.                     ArchiviCostanti.OBJECT_NAME_ARCHIVI_EXPORT,
  520.                     ArchiviCostanti.TIPO_OPERAZIONE_EXPORT);
  521.         }
  522.     }
  523.         

  525. }
Created with JaCoCo 0.8.8.202204050719