ArchiviHelper.java

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

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

  23. import java.io.File;
  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.Iterator;
  27. import java.util.List;

  29. import javax.servlet.http.HttpServletRequest;
  30. import javax.servlet.http.HttpSession;

  32. import org.apache.commons.lang.StringUtils;
  33. import org.apache.struts.upload.FormFile;
  34. import org.openspcoop2.core.config.Connettore;
  35. import org.openspcoop2.core.config.Credenziali;
  36. import org.openspcoop2.core.config.InvocazioneServizio;
  37. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  38. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  39. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  40. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  41. import org.openspcoop2.core.constants.CostantiConnettori;
  42. import org.openspcoop2.core.constants.TipiConnettore;
  43. import org.openspcoop2.core.id.IDAccordo;
  44. import org.openspcoop2.core.id.IDAccordoCooperazione;
  45. import org.openspcoop2.core.id.IDSoggetto;
  46. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  47. import org.openspcoop2.core.registry.Documento;
  48. import org.openspcoop2.core.registry.Operation;
  49. import org.openspcoop2.core.registry.PortType;
  50. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  51. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  52. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  53. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  54. import org.openspcoop2.core.registry.constants.TipiDocumentoCoordinamento;
  55. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  56. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  57. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  58. import org.openspcoop2.message.constants.ServiceBinding;
  59. import org.openspcoop2.protocol.basic.archive.BasicArchive;
  60. import org.openspcoop2.protocol.engine.BasicProtocolFactory;
  61. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  62. import org.openspcoop2.protocol.engine.archive.ImportInformationMissing;
  63. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingCollection;
  64. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingException;
  65. import org.openspcoop2.protocol.engine.archive.ImporterInformationMissingUtils;
  66. import org.openspcoop2.protocol.information_missing.Default;
  67. import org.openspcoop2.protocol.information_missing.Description;
  68. import org.openspcoop2.protocol.information_missing.DescriptionType;
  69. import org.openspcoop2.protocol.information_missing.Input;
  70. import org.openspcoop2.protocol.information_missing.Proprieta;
  71. import org.openspcoop2.protocol.information_missing.ProprietaDefault;
  72. import org.openspcoop2.protocol.information_missing.ProprietaRequisitoInput;
  73. import org.openspcoop2.protocol.information_missing.RequisitoInput;
  74. import org.openspcoop2.protocol.information_missing.Wizard;
  75. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  76. import org.openspcoop2.protocol.sdk.archive.ArchiveCascadeConfiguration;
  77. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  78. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  79. import org.openspcoop2.protocol.sdk.archive.ExportMode;
  80. import org.openspcoop2.protocol.sdk.archive.ImportMode;
  81. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  82. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  83. import org.openspcoop2.protocol.sdk.validator.ValidazioneResult;
  84. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  85. import org.openspcoop2.web.ctrlstat.core.Utilities;
  86. import org.openspcoop2.web.ctrlstat.costanti.ConnettoreServletType;
  87. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  88. import org.openspcoop2.web.ctrlstat.costanti.TipologiaConnettori;
  89. import org.openspcoop2.web.ctrlstat.plugins.ExtendedConnettore;
  90. import org.openspcoop2.web.ctrlstat.plugins.servlet.ServletExtendedConnettoreUtils;
  91. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  92. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoreStatusParams;
  93. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  94. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriHelper;
  95. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  96. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiHelper;
  97. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  98. import org.openspcoop2.web.ctrlstat.servlet.utenti.UtentiCostanti;
  99. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  100. import org.openspcoop2.web.lib.mvc.Costanti;
  101. import org.openspcoop2.web.lib.mvc.DataElement;
  102. import org.openspcoop2.web.lib.mvc.DataElementType;
  103. import org.openspcoop2.web.lib.mvc.PageData;
  104. import org.openspcoop2.web.lib.mvc.Parameter;
  105. import org.openspcoop2.web.lib.mvc.ServletUtils;
  106. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  107. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  108. import org.openspcoop2.web.lib.users.dao.User;

  110. /**
  111.  * ArchiviHelper
  112.  * 
  113.  * @author Andrea Poli (apoli@link.it)
  114.  * @author $Author$
  115.  * @version $Rev$, $Date$
  116.  */
  117. public class ArchiviHelper extends ServiziApplicativiHelper {

  119.     public ArchiviHelper(HttpServletRequest request, PageData pd, 
  120.             HttpSession session) throws Exception {
  121.         super(request, pd,  session);
  122.     }
  123.     public ArchiviHelper(ControlStationCore core, HttpServletRequest request, PageData pd, 
  124.             HttpSession session) throws Exception {
  125.         super(core, request, pd,  session);
  126.     }


  129.     public void addExportToDati(List<DataElement> dati,
  130.             List<String> protocolliSelectList,String protocollo,
  131.             List<ExportMode> exportModes,String exportMode,
  132.             ArchiveType servletSourceExport, String objToExport, 
  133.             String cascadePolicyConfig, String cascadePluginConfig, String cascade,String configurazioneType,
  134.             String cascadePdd,String cascadeRuoli,String cascadeScope, String cascadeSoggetti,
  135.             String cascadeServiziApplicativi, String cascadePorteDelegate, String cascadePorteApplicative,
  136.             String cascadeAc, String cascadeAspc, String cascadeAsc, String cascadeAsps, String cascadeFruizioni) throws Exception{
  137.         
  138.         DataElement dataElement = new DataElement();
  139.         dataElement.setLabel(ArchiviCostanti.LABEL_ARCHIVI_EXPORT);
  140.         dataElement.setType(DataElementType.TITLE);
  141.         dati.add(dataElement);
  142.         
  143.         DataElement de = new DataElement();
  144.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_PROTOCOLLO);
  145.         // Non sembra necessario far vedere la lista dei protocolli anche se sono maggiore di uno.
  146.         // Tanto poi gli export modes sono sempre tutti quelli SOLO compatibilit con TUTTI i protocolli degli oggetti selezionati.
  147. //      if(protocolliSelectList.size()>=2){
  148. //          de.setType(DataElementType.SELECT);
  149. //          de.setValues(protocolliSelectList.toArray(new String[1]));
  150. //          de.setLabels(protocolliSelectList.toArray(new String[1]));
  151. //          de.setSelected(protocollo);
  152. //      }else{
  153.         de.setType(DataElementType.HIDDEN);
  154.         de.setValue(protocollo);
  155. //      }
  156.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO);
  157.         de.setSize(this.getSize());
  158.         de.setPostBack(true);
  159.         dati.add(de);
  160.         
  161.         de = new DataElement();
  162.         de.setType(DataElementType.TEXT);
  163.         de.setLabel(org.openspcoop2.core.constants.Costanti.LABEL_PARAMETRO_PROTOCOLLO);
  164.         boolean tutti_protocolli = false;
  165.         if(protocolliSelectList.size()<=1){
  166.             de.setValue(this.getLabelProtocollo(protocollo));
  167.         }
  168.         else {
  169.             de.setValue(UtentiCostanti.LABEL_PARAMETRO_MODALITA_ALL);
  170.             tutti_protocolli = true;
  171.         }
  172.         dati.add(de);
  173.         
  174.         if(!tutti_protocolli && this.archiviCore.isMultitenant()) {
  175.             de = new DataElement();
  176.             de.setType(DataElementType.TEXT);
  177.             de.setLabel(SoggettiCostanti.LABEL_SOGGETTO);
  178.             if(this.isSoggettoMultitenantSelezionato()){
  179.                 IDSoggetto idSoggettoSelezionato = this.soggettiCore.convertSoggettoSelezionatoToID(this.getSoggettoMultitenantSelezionato());
  180.                 de.setValue(this.getLabelNomeSoggetto(idSoggettoSelezionato));
  181.             }
  182.             else {
  183.                 de.setValue(UtentiCostanti.LABEL_PARAMETRO_MODALITA_ALL);
  184.             }
  185.             if(!ArchiveType.ALL.equals(servletSourceExport) && 
  186.                     !ArchiveType.ALL_WITHOUT_CONFIGURAZIONE.equals(servletSourceExport) &&
  187.                     !ArchiveType.CONFIGURAZIONE.equals(servletSourceExport)) {
  188.                 de.setType(DataElementType.HIDDEN);
  189.             }
  190.             dati.add(de);
  191.         }

  193.         de = new DataElement();
  194.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  195.         if(exportModes.size()>1){
  196.             List<String> exportMode_tmp = new ArrayList<>();
  197.             for (ExportMode exp : exportModes) {
  198.                 exportMode_tmp.add(exp.toString());
  199.             }
  200.             de.setType(DataElementType.SELECT);
  201.             de.setValues(exportMode_tmp.toArray(new String[1]));
  202.             de.setLabels(exportMode_tmp.toArray(new String[1]));
  203.             de.setSelected(exportMode);
  204.         }else{
  205.             de.setType(DataElementType.HIDDEN);
  206.             de.setValue(exportMode);
  207.         }
  208.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  209.         de.setSize(this.getSize());
  210.         de.setPostBack(true);
  211.         dati.add(de);
  212.                     
  213.         if(ArchiveType.CONFIGURAZIONE.equals(servletSourceExport)){
  214.             de = new DataElement();
  215.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_TIPO_DUMP);
  216.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO_DUMP);
  217.             if(this.archiviCore.isExportArchive_configurazione_soloDumpCompleto() || 
  218.                     !org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_ARCHIVE_MODE_TYPE.getType().equals(exportMode)){
  219.                 // opzioni standard
  220.                 de.setType(DataElementType.HIDDEN);
  221.                 de.setValue(configurazioneType);
  222.             }
  223.             else{
  224.                 // opzioni di export avanzate
  225.                 de.setType(DataElementType.SELECT);
  226.                 de.setLabels(ArchiviCostanti.getParametroLabelArchiviExportTipoDump());
  227.                 de.setValues(ArchiviCostanti.getParametroValoriArchiviExportTipoDump());
  228.                 de.setSelected(configurazioneType);
  229.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  230.             }
  231.             dati.add(de);
  232.         }
  233.         
  234.         boolean cascadeEnabled = false;
  235.         ArchiveCascadeConfiguration cascadeConfig = null;
  236.         if(!ArchiveType.CONFIGURAZIONE.equals(servletSourceExport)){
  237.             cascadeEnabled = this.archiviCore.isCascadeEnabled(exportModes, exportMode);
  238.             cascadeConfig = this.archiviCore.getCascadeConfig(exportModes, exportMode);
  239.             if(cascadeEnabled){
  240.                 if(configurazioneType!=null && ArchiveType.CONFIGURAZIONE.equals(ArchiveType.valueOf(configurazioneType))){
  241.                     cascadeEnabled = false; // nella configurazione non ha senso usare il cascade   
  242.                 }
  243.             }
  244.         }
  245.         
  246.         
  247.         boolean showPolicyConfigOption = true;
  248.         if(ArchiveType.CONFIGURAZIONE_CONTROLLO_TRAFFICO_ACTIVE_POLICY.equals(servletSourceExport)
  249.                 ||
  250.                 ArchiveType.CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIG_POLICY.equals(servletSourceExport)
  251.                 ||
  252.                 ArchiveType.CONFIGURAZIONE_TOKEN_POLICY.equals(servletSourceExport)
  253.                 ||
  254.                 ArchiveType.CONFIGURAZIONE_ATTRIBUTE_AUTHORITY.equals(servletSourceExport)
  255.                 ||
  256.                 ArchiveType.CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA.equals(servletSourceExport)
  257.                 ||
  258.                 ArchiveType.CONFIGURAZIONE_PLUGIN_CLASSE.equals(servletSourceExport)
  259.                 ||
  260.                 ArchiveType.CONFIGURAZIONE_PLUGIN_ARCHVIO.equals(servletSourceExport)){
  261.             showPolicyConfigOption = false;
  262.         }
  263.         de = new DataElement();
  264.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_POLICY_CONFIG);
  265.         if(cascadeEnabled && showPolicyConfigOption){
  266.             de.setType(DataElementType.CHECKBOX);
  267.             de.setPostBack(true);
  268.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_POLICY_CONFIG_LEFT);
  269.             if(this.archiviCore.isConfigurazioneAllarmiEnabled()) {
  270.                 de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_POLICY_CONFIG_CON_ALLARMI_RIGHT);
  271.             }
  272.             else {
  273.                 de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_POLICY_CONFIG_RIGHT);
  274.             }
  275.             de.setSelected(ServletUtils.isCheckBoxEnabled(cascadePolicyConfig));
  276.         }
  277.         else {
  278.             de.setType(DataElementType.HIDDEN);
  279.         }
  280.         if(showPolicyConfigOption) {
  281.             de.setValue(cascadePolicyConfig);
  282.         }
  283.         else {
  284.             de.setValue(Costanti.CHECK_BOX_DISABLED);
  285.         }
  286.         dati.add(de);
  287.         
  288.         
  289.         boolean showPluginConfigOption = this.archiviCore.isConfigurazionePluginsEnabled();
  290.         if(ArchiveType.CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIG_POLICY.equals(servletSourceExport)
  291.                 ||
  292.                 ArchiveType.CONFIGURAZIONE_TOKEN_POLICY.equals(servletSourceExport)
  293.                 ||
  294.                 ArchiveType.CONFIGURAZIONE_ATTRIBUTE_AUTHORITY.equals(servletSourceExport)
  295.                 ||
  296.                 ArchiveType.CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA.equals(servletSourceExport)
  297.                 ||
  298.                 ArchiveType.CONFIGURAZIONE_PLUGIN_CLASSE.equals(servletSourceExport)
  299.                 ||
  300.                 ArchiveType.CONFIGURAZIONE_PLUGIN_ARCHVIO.equals(servletSourceExport)){
  301.             showPluginConfigOption = false;
  302.         }
  303.         de = new DataElement();
  304.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PLUGIN_CONFIG);
  305.         if(cascadeEnabled && showPluginConfigOption){
  306.             de.setType(DataElementType.CHECKBOX);
  307.             de.setPostBack(true);
  308.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_PLUGIN_CONFIG_LEFT);
  309.             de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_PLUGIN_CONFIG_RIGHT);
  310.             de.setSelected(ServletUtils.isCheckBoxEnabled(cascadePluginConfig));
  311.         }
  312.         else {
  313.             de.setType(DataElementType.HIDDEN);
  314.         }
  315.         if(showPluginConfigOption) {
  316.             de.setValue(cascadePluginConfig);
  317.         }
  318.         else {
  319.             de.setValue(Costanti.CHECK_BOX_DISABLED);
  320.         }
  321.         dati.add(de);
  322.         
  323.         
  324.         boolean showIncludiElementiRiferitiOption = true;
  325.         if(ArchiveType.CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIG_POLICY.equals(servletSourceExport)
  326.                 ||
  327.                 ArchiveType.CONFIGURAZIONE_TOKEN_POLICY.equals(servletSourceExport)
  328.                 ||
  329.                 ArchiveType.CONFIGURAZIONE_ATTRIBUTE_AUTHORITY.equals(servletSourceExport)
  330.                 ||
  331.                 ArchiveType.CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA.equals(servletSourceExport)
  332.                 ||
  333.                 ArchiveType.CONFIGURAZIONE_PLUGIN_CLASSE.equals(servletSourceExport)
  334.                 ||
  335.                 ArchiveType.CONFIGURAZIONE_PLUGIN_ARCHVIO.equals(servletSourceExport)){
  336.             showIncludiElementiRiferitiOption = false;
  337.         }
  338.         de = new DataElement();
  339.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE);
  340.         if(cascadeEnabled && showIncludiElementiRiferitiOption){
  341.             de.setType(DataElementType.CHECKBOX);
  342.             de.setPostBack(true);
  343.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_LEFT);
  344.             de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_RIGHT);
  345.             de.setSelected(ServletUtils.isCheckBoxEnabled(cascade));
  346.         }
  347.         else {
  348.             de.setType(DataElementType.HIDDEN);
  349.         }
  350.         if(showIncludiElementiRiferitiOption) {
  351.             de.setValue(cascade);
  352.         }
  353.         else {
  354.             de.setValue(Costanti.CHECK_BOX_DISABLED);
  355.         }
  356.         dati.add(de);
  357.         
  358.         if(!this.archiviCore.isExportArchive_servizi_standard() && 
  359.                 ServletUtils.isCheckBoxEnabled(cascade) &&
  360.                 cascadeEnabled){
  361.             
  362.             de = new DataElement();
  363.             de.setType(DataElementType.TITLE);
  364.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_SEZIONE);
  365.             dati.add(de);
  366.             
  367.             if(cascadeConfig.isCascadePdd()){
  368.                 de = new DataElement();
  369.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_PDD);
  370.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PDD);
  371.                 de.setType(DataElementType.CHECKBOX);
  372.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  373.                 de.setSelected(cascadePdd);
  374.                 dati.add(de);
  375.             }
  376.             
  377.             if(cascadeConfig.isCascadeRuoli()){
  378.                 de = new DataElement();
  379.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_RUOLI);
  380.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_RUOLI);
  381.                 de.setType(DataElementType.CHECKBOX);
  382.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  383.                 de.setSelected(cascadeRuoli);
  384.                 dati.add(de);
  385.             }
  386.             
  387.             if(cascadeConfig.isCascadeScope()){
  388.                 de = new DataElement();
  389.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_SCOPE);
  390.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SCOPE);
  391.                 de.setType(DataElementType.CHECKBOX);
  392.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  393.                 de.setSelected(cascadeScope);
  394.                 dati.add(de);
  395.             }
  396.             
  397.             if(cascadeConfig.isCascadeSoggetti()){
  398.                 de = new DataElement();
  399.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_SOGGETTI);
  400.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SOGGETTI);
  401.                 de.setType(DataElementType.CHECKBOX);
  402.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  403.                 de.setSelected(cascadeSoggetti);
  404.                 dati.add(de);
  405.             }
  406.             
  407.             if(cascadeConfig.isCascadeServiziApplicativi()){
  408.                 de = new DataElement();
  409.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_SERVIZI_APPLICATIVI);
  410.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_SERVIZI_APPLICATIVI);
  411.                 de.setType(DataElementType.CHECKBOX);
  412.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  413.                 de.setSelected(cascadeServiziApplicativi);
  414.                 dati.add(de);
  415.             }
  416.             if(cascadeConfig.isCascadePorteDelegate()){
  417.                 de = new DataElement();
  418.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_DELEGATE);
  419.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_DELEGATE);
  420.                 de.setType(DataElementType.CHECKBOX);
  421.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  422.                 de.setSelected(cascadePorteDelegate);
  423.                 dati.add(de);
  424.             }
  425.             if(cascadeConfig.isCascadePorteApplicative()){
  426.                 de = new DataElement();
  427.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_APPLICATIVE);
  428.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_PORTE_APPLICATIVE);
  429.                 de.setType(DataElementType.CHECKBOX);
  430.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  431.                 de.setSelected(cascadePorteApplicative);
  432.                 dati.add(de);
  433.             }
  434.             
  435.             if(cascadeConfig.isCascadeAccordoCooperazione()){
  436.                 de = new DataElement();
  437.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_COOPERAZIONE);
  438.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_COOPERAZIONE);
  439.                 de.setType(DataElementType.CHECKBOX);
  440.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  441.                 de.setSelected(cascadeAc);
  442.                 dati.add(de);
  443.             }
  444.             if(cascadeConfig.isCascadeAccordoServizioParteComune()){
  445.                 de = new DataElement();
  446.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_COMUNE);
  447.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_COMUNE);
  448.                 de.setType(DataElementType.CHECKBOX);
  449.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  450.                 de.setSelected(cascadeAspc);
  451.                 dati.add(de);
  452.             }
  453.             if(cascadeConfig.isCascadeAccordoServizioComposto()){
  454.                 de = new DataElement();
  455.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_COMPOSTO);
  456.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_COMPOSTO);
  457.                 de.setType(DataElementType.CHECKBOX);
  458.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  459.                 de.setSelected(cascadeAsc);
  460.                 dati.add(de);
  461.             }
  462.             if(cascadeConfig.isCascadeAccordoServizioParteSpecifica()){
  463.                 de = new DataElement();
  464.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_SPECIFICA);
  465.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_ACCORDI_SERVIZIO_PARTE_SPECIFICA);
  466.                 de.setType(DataElementType.CHECKBOX);
  467.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  468.                 de.setSelected(cascadeAsps);
  469.                 dati.add(de);
  470.             }
  471.             if(cascadeConfig.isCascadeFruizioni()){
  472.                 de = new DataElement();
  473.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_EXPORT_CASCADE_FRUIZIONI);
  474.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_CASCADE_FRUIZIONI);
  475.                 de.setType(DataElementType.CHECKBOX);
  476.                 de.setPostBack(true); // serve solo a poter riesportare senza dover rientrare nella sezione configurazione una volta esportato
  477.                 de.setSelected(cascadeFruizioni);
  478.                 dati.add(de);
  479.             }
  480.         }   
  481.         
  482.         
  483.         de = new DataElement();
  484.         de.setType(DataElementType.HIDDEN);
  485.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO);
  486.         de.setValue(servletSourceExport.toString());
  487.         dati.add(de);
  488.         
  489.         de = new DataElement();
  490.         de.setType(DataElementType.HIDDEN);
  491.         de.setName(Costanti.PARAMETER_NAME_OBJECTS_FOR_REMOVE);
  492.         de.setValue(objToExport);
  493.         dati.add(de);
  494.     }
  495.     

  497.     public boolean importCheckData(FormFile ff,ImporterUtils importerUtils,String protocollo,ArchiveMode importMode,ArchiveModeType importType) throws Exception {

  499.         if(ff==null || ff.getFileName()==null || "".equals(ff.getFileName()) || ff.getFileData()==null || ff.getFileData().length<=0) {
  500.             this.pd.setMessage("Non è stato selezionato alcun file");
  501.             return false;
  502.         }
  503.         
  504.         // check estensione
  505.         if(ff.getFileName().contains(".")==false){
  506.             this.pd.setMessage("Estensione di file non valida");
  507.             return false;
  508.         }
  509.         String ext = ff.getFileName().substring(ff.getFileName().lastIndexOf('.')+1, ff.getFileName().length());
  510.         List<String> validExts = importerUtils.getValidExtensions(importType, importMode, protocollo);
  511.         if(validExts.contains(ext)==false){
  512.             this.pd.setMessage("Estensione di file ["+ext+"] non supportata (tipologia-archivio:"+importMode+" ,tipo:"+importType+"). Sono supportati i seguenti formati: "+validExts.toString());
  513.             return false;
  514.         }

  516.         return true;

  518.     }
  519.     
  520.     public boolean checkRequiisitiWizard(Wizard wizard){
  521.         
  522.         if(wizard.getRequisiti()==null){
  523.             return true;
  524.         }
  525.         
  526.         StringBuilder bf = new StringBuilder();
  527.         for (int i = 0; i < wizard.getRequisiti().sizeProtocolloList(); i++) {
  528.             String protocollo = wizard.getRequisiti().getProtocollo(i).getNome();
  529.             try{
  530.                 IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  531.                 pf.toString();
  532.             }catch(Exception e){
  533.                 this.log.error("Requisito["+i+"] protocollo ["+protocollo+"] non trovato: "+e.getMessage(),e);
  534.                 if(bf.length()>0){
  535.                     bf.append(",");
  536.                 }
  537.                 bf.append(protocollo);
  538.             }
  539.         }
  540.         if(bf.length()>0){
  541.             this.pd.setMessage("I seguenti plugin di protocollo, richiesti dall'archivio selezionato, non risultano essere installati: "+bf.toString());
  542.             return false;
  543.         }
  544.         
  545.         
  546.         return true;
  547.         
  548.     }
  549.     
  550.     public boolean importInformationMissingCheckData(String importInformationMissing_soggettoInput,String importInformationMissing_versioneInput,
  551.             String importInformationMissing_modalitaAcquisizioneInformazioniProtocollo, String postBackElementName,
  552.             String importInformationMissing_portTypeImplementedInput,
  553.             String importInformationMissing_accordoServizioParteComuneInput,
  554.             String importInformationMissing_accordoCooperazioneInput) throws Exception{
  555.                 
  556.         // check input
  557.         int index = 0;
  558.         String pRequisitoHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  559.         while(pRequisitoHidden!=null || "".equals(pRequisitoHidden)){
  560.             String pValue = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_VALUE+index);
  561.             if(pValue==null || "".equals(pValue)){
  562.                 if("true".equalsIgnoreCase(pRequisitoHidden)) {
  563.                     this.pd.setMessage("Deve essere indicato un valore in tutti i campi obbligatori");
  564.                     return false;
  565.                 }
  566.             }
  567.                 
  568.             index++;
  569.             pRequisitoHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  570.         }
  571.         
  572.         // importInformationMissing: soggetto
  573.         if(importInformationMissing_soggettoInput!=null && 
  574.                 !"".equals(importInformationMissing_soggettoInput)) {
  575.             
  576.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED.equals(importInformationMissing_soggettoInput)){
  577.                 this.pd.setMessage("Deve essere selezionato un soggetto tra quelli indicati");
  578.                 return false;
  579.             }
  580.             
  581.             String[]splitSoggetto = importInformationMissing_soggettoInput.split("/");
  582.             if(splitSoggetto==null || splitSoggetto.length!=2){
  583.                 this.pd.setMessage("Il soggetto indicato ["+importInformationMissing_soggettoInput+"] non risulta valido");
  584.                 return false;
  585.             }
  586.         }
  587.         
  588.         
  589.         // importInformationMissing: versione
  590.         if(importInformationMissing_versioneInput!=null){
  591.             try{
  592.                 Integer.parseInt(importInformationMissing_versioneInput);
  593.             }catch(Exception e){
  594.                 this.pd.setMessage("Versione indicata ["+importInformationMissing_versioneInput+"] non valida: "+e.getMessage());
  595.                 return false;
  596.             }
  597.         }
  598.         
  599.         // check input
  600.         index = 0;
  601.         String pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  602.         while(pHidden!=null || "".equals(pHidden)){
  603.             String pValue = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_VALUE+index);
  604.             if(pValue==null || "".equals(pValue)){
  605.                 this.pd.setMessage("Deve essere indicato un valore in tutti i campi");
  606.                 return false;
  607.             }
  608.                 
  609.             index++;
  610.             pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  611.         }
  612.         
  613.         // check Informazioni configurazione profilo servizi
  614.         if(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PROTOCOLLO_MANCANTI_RICONOSCIMENTO_USER_INPUT.equals(importInformationMissing_modalitaAcquisizioneInformazioniProtocollo)){
  615.             
  616.             int contatoreServizio = 1;
  617.             String servizioParam = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_IS_DEFINED+contatoreServizio;
  618.             String serviziTmpInput = this.getParameter(servizioParam);
  619.             while(serviziTmpInput!=null && !"".equals(serviziTmpInput)){
  620.             
  621.                 servizioParam = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE+contatoreServizio;
  622.                 String nomeServizio = this.getParameter(servizioParam);
  623.                 if(nomeServizio==null || "".equals(nomeServizio)){
  624.                     this.pd.setMessage("Deve essere indicato il nome del servizio da associare ad ogni port-type esistente");
  625.                     return false;
  626.                 }
  627.                 
  628.                 int contatoreAzione = 1;
  629.                 String azioniTmpInput = this.getParameter(servizioParam+
  630.                         ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_IS_DEFINED+contatoreAzione);
  631.                 while(azioniTmpInput!=null && !"".equals(azioniTmpInput)){
  632.                     
  633.                     String nomeAzione = this.getParameter(servizioParam+
  634.                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION+contatoreAzione);
  635.                     if(nomeAzione==null || "".equals(nomeAzione)){
  636.                         this.pd.setMessage("Deve essere indicato il nome di ogni azione da associare alle operations dei port-types");
  637.                         return false;
  638.                     }
  639.                     
  640.                     String nomeProfilo = this.getParameter(servizioParam+
  641.                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_PROFILO+contatoreAzione);
  642.                     if(nomeProfilo==null || "".equals(nomeProfilo)){
  643.                         this.pd.setMessage("Deve essere indicato un profilo di collaborazione per ogni operation dei port-types");
  644.                         return false;
  645.                     }
  646.                     if(!CostantiRegistroServizi.ONEWAY.equals(nomeProfilo) &&
  647.                             !CostantiRegistroServizi.SINCRONO.equals(nomeProfilo) &&
  648.                             !CostantiRegistroServizi.ASINCRONO_ASIMMETRICO.equals(nomeProfilo) &&
  649.                             !CostantiRegistroServizi.ASINCRONO_SIMMETRICO.equals(nomeProfilo)){
  650.                         this.pd.setMessage("Deve essere indicato un profilo di collaborazione valido per ogni operation dei port-types. Trovato un profilo non valido: "+nomeProfilo);
  651.                         return false;
  652.                         
  653.                     }
  654.                     
  655.                     // NextAzione
  656.                     contatoreAzione++;
  657.                     azioniTmpInput = this.getParameter(servizioParam+
  658.                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_IS_DEFINED+contatoreAzione);
  659.                 }
  660.                 
  661.                 contatoreServizio++;
  662.                 servizioParam = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_IS_DEFINED+contatoreServizio;
  663.                 serviziTmpInput = this.getParameter(servizioParam);
  664.                 
  665.             }
  666.             
  667.         }
  668.         
  669.         if(postBackElementName!=null){
  670.             if(postBackElementName.startsWith(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE) && 
  671.                     postBackElementName.contains(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_PROFILO)){
  672.                 // cambiato il profilo di collaborazione di una azione
  673.                 // Devo solo rigenerare le informazioni senza pero' fornire alcun messaggio
  674.                 return false;
  675.             }
  676.             else if(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT.equals(postBackElementName)){
  677.                 // cambiata la modalita' di acquisizione delle informazioni
  678.                 // Devo solo rigenerare le informazioni senza pero' fornire alcun messaggio
  679.                 return false;
  680.             }
  681.         }
  682.         
  683.         
  684.         // Check portType implemented
  685.         if(importInformationMissing_portTypeImplementedInput!=null && 
  686.                 !"".equals(importInformationMissing_portTypeImplementedInput)) {
  687.             
  688.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED.equals(importInformationMissing_portTypeImplementedInput)){
  689.                 this.pd.setMessage("Deve essere selezionato un servizio, da implementare, tra quelli indicati");
  690.                 return false;
  691.             }
  692.             
  693.         }
  694.         
  695.         
  696.         // importInformationMissing: accordoServizioParteComune
  697.         if(importInformationMissing_accordoServizioParteComuneInput!=null && 
  698.                 !"".equals(importInformationMissing_accordoServizioParteComuneInput)) {
  699.             
  700.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED.equals(importInformationMissing_accordoServizioParteComuneInput)){
  701.                 this.pd.setMessage("Deve essere selezionato un'accordo tra quelli indicati");
  702.                 return false;
  703.             }
  704.             
  705.             try{
  706.                 IDAccordoFactory.getInstance().getIDAccordoFromUri(importInformationMissing_accordoServizioParteComuneInput);
  707.             }catch(Exception e){
  708.                 this.pd.setMessage("L'accordo indicato ["+importInformationMissing_accordoServizioParteComuneInput+"] non risulta valido");
  709.                 return false;   
  710.             }
  711.         }
  712.         
  713.         // importInformationMissing: accordoCooperazione
  714.         if(importInformationMissing_accordoCooperazioneInput!=null && 
  715.                 !"".equals(importInformationMissing_accordoCooperazioneInput)) {
  716.             
  717.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED.equals(importInformationMissing_accordoCooperazioneInput)){
  718.                 this.pd.setMessage("Deve essere selezionato un'accordo tra quelli indicati");
  719.                 return false;
  720.             }
  721.             
  722.             try{
  723.                 IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromUri(importInformationMissing_accordoCooperazioneInput);
  724.             }catch(Exception e){
  725.                 this.pd.setMessage("L'accordo indicato ["+importInformationMissing_accordoCooperazioneInput+"] non risulta valido");
  726.                 return false;   
  727.             }
  728.         }
  729.         
  730.         // ImportInformationMissingInvocazioneServizio
  731.         if(!this.isEditModeInProgress()){
  732.             try{
  733.                 InvocazioneServizio is = this.readInvocazioneServizio();
  734.                 if(is!=null){
  735.                     ServiziApplicativiHelper saHelper = new ServiziApplicativiHelper(this.request, this.pd, this.session);
  736.                     
  737.                     String endpointtype = this.readEndPointType();
  738.                     List<ExtendedConnettore> listExtendedConnettore = 
  739.                             ServletExtendedConnettoreUtils.getExtendedConnettore(is.getConnettore(), ConnettoreServletType.WIZARD_CONFIG, this, false, endpointtype);
  740.                     
  741.                     boolean isOk = saHelper.servizioApplicativoEndPointCheckData(null, listExtendedConnettore, null);
  742.                     if (!isOk) {
  743.                         return false;
  744.                     }
  745.                     
  746.                     if(StatoFunzionalita.ABILITATO.equals(is.getGetMessage())){
  747.                         isOk = this.credenzialiCheckData(TipoOperazione.ADD, false, this.saCore.isApplicativiPasswordEncryptEnabled(), this.saCore.getApplicativiPasswordVerifier());
  748.                         if (!isOk) {
  749.                             return false;
  750.                         }
  751.                     }
  752.                 }
  753.             }catch(Exception e){
  754.                 String message = "Rilevato ErroreGenerico durante la lettura dei dati di invocazione servizio relativo al servizio applicativo: "+e.getMessage();
  755.                 this.log.error(message,e);
  756.                 this.pd.setMessage(message);
  757.                 return false;   
  758.             }
  759.         }
  760.         
  761.         // ImportInformationMissingConnettore
  762.         if(!this.isEditModeInProgress()){
  763.             try{
  764.                 org.openspcoop2.core.registry.Connettore connettore = this.readConnettore();
  765.                 if(connettore!=null){
  766.                     
  767.                     String endpointtype = this.readEndPointType();
  768.                     List<ExtendedConnettore> listExtendedConnettore = 
  769.                             ServletExtendedConnettoreUtils.getExtendedConnettore(connettore, ConnettoreServletType.WIZARD_REGISTRY, this, false, endpointtype);
  770.                     
  771.                     boolean isOk = this.endPointCheckData(null, null, false, listExtendedConnettore);
  772.                     if (!isOk) {
  773.                         return false;
  774.                     }
  775.                 }
  776.             }catch(Exception e){
  777.                 String message = "Rilevato ErroreGenerico durante la lettura dei dati del connettore: "+e.getMessage();
  778.                 this.log.error(message,e);
  779.                 this.pd.setMessage(message);
  780.                 return false;   
  781.             }
  782.         }
  783.         
  784.         // ImportInformationMissingCredenziali
  785.         if(!this.isEditModeInProgress()){
  786.             try{
  787.                 Credenziali credenziali = this.readCredenzialiSA();
  788.                 if(credenziali!=null){
  789.                     ConnettoriHelper connettoriHelper = new ConnettoriHelper(this.request, this.pd, this.session);
  790.                     boolean isOk = connettoriHelper.credenzialiCheckData(TipoOperazione.ADD, false, this.saCore.isApplicativiPasswordEncryptEnabled(), this.saCore.getApplicativiPasswordVerifier());
  791.                     if (!isOk) {
  792.                         return false;
  793.                     }
  794.                 }
  795.             }catch(Exception e){
  796.                 String message = "Rilevato ErroreGenerico durante la lettura dei dati delle credenziali di accesso alla PdD del servizio applicativo: "+e.getMessage();
  797.                 this.log.error(message,e);
  798.                 this.pd.setMessage(message);
  799.                 return false;   
  800.             }
  801.         }
  802.         
  803.         return true;
  804.     }

  806.     public void addImportToDati(List<DataElement> dati,
  807.             boolean validazioneDocumenti,boolean updateEnabled,
  808.             boolean importDeletePolicyConfig, 
  809.             boolean importDeletePluginConfig,
  810.             boolean importConfig,
  811.             boolean showProtocols, List<String> protocolliSelectList,String protocollo,
  812.             List<ImportMode> importModes,String importMode,
  813.             List<ArchiveModeType> importTypes,String importType,
  814.             boolean deleter) throws Exception{

  816.         DataElement dataElement = new DataElement();
  817.         if(deleter){
  818.             dataElement.setLabel(ArchiviCostanti.LABEL_ARCHIVI_ELIMINA);
  819.         }
  820.         else{
  821.             dataElement.setLabel(ArchiviCostanti.LABEL_ARCHIVI_IMPORT);
  822.         }
  823.         dataElement.setType(DataElementType.TITLE);
  824.         dati.add(dataElement);
  825.         
  826.         DataElement de = new DataElement();
  827.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_PROTOCOLLO);
  828.         if(showProtocols && protocolliSelectList.size()>2){
  829.             de.setType(DataElementType.SELECT);
  830.             de.setValues(protocolliSelectList.toArray(new String[1]));
  831.             List<String> protocolliSelectListLabels = new ArrayList<>();
  832.             for (String p : protocolliSelectList) {
  833.                 if(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(p)) {
  834.                     protocolliSelectListLabels.add(UtentiCostanti.LABEL_PARAMETRO_MODALITA_ALL);
  835.                 }
  836.                 else {
  837.                     protocolliSelectListLabels.add(this.getLabelProtocollo(p));
  838.                 }
  839.             }
  840.             de.setLabels(protocolliSelectListLabels);
  841.             de.setSelected(protocollo);
  842.         }else{
  843.             de.setType(DataElementType.HIDDEN);
  844.             de.setValue(protocollo);
  845.         }
  846.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO);
  847.         de.setSize(this.getSize());
  848.         de.setPostBack(true);
  849.         dati.add(de);

  851.         de = new DataElement();
  852.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  853.         if(importModes.size()>1){
  854.             // Lo vediamo sempre anche se solo con un valore, poiche' vogliamo vedere govlet e fuori dalla select list non e' bello graficamente.
  855.             List<String> tmpArchivi = new ArrayList<>();
  856.             for (ImportMode imp : importModes) {
  857.                 tmpArchivi.add(imp.toString());
  858.             }
  859.             de.setType(DataElementType.SELECT);
  860.             de.setValues(tmpArchivi.toArray(new String[1]));
  861.             de.setLabels(tmpArchivi.toArray(new String[1]));
  862.             de.setSelected(importMode);
  863.         }else{
  864.             de.setType(DataElementType.HIDDEN);
  865.             //de.setType(DataElementType.TEXT);
  866.             de.setValue(importMode);
  867.         }
  868.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  869.         de.setSize(this.getSize());
  870.         if(importModes.size()>1){
  871.             de.setPostBack(true);
  872.         }
  873.         dati.add(de);

  875.         de = new DataElement();
  876.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_TIPO);
  877.         if(importTypes.size()>1){
  878.             List<String> tmp = new ArrayList<>();
  879.             for (ArchiveModeType type : importTypes) {
  880.                 tmp.add(type.toString());
  881.             }
  882.             de.setType(DataElementType.SELECT);
  883.             de.setValues(tmp.toArray(new String[1]));
  884.             de.setLabels(tmp.toArray(new String[1]));
  885.             de.setSelected(importType);
  886.         }else{
  887.             de.setType(DataElementType.HIDDEN);
  888.             de.setValue(importType);
  889.         }
  890.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPO);
  891.         de.setSize(this.getSize());
  892.         dati.add(de);

  894.         de = new DataElement();
  895.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_VALIDAZIONE_DOCUMENTI_LEFT);
  896.         de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_VALIDAZIONE_DOCUMENTI_RIGHT);
  897.         de.setValue(""+validazioneDocumenti);
  898.         if (this.isModalitaAvanzata()) {
  899.             de.setType(DataElementType.CHECKBOX);
  900.             de.setSelected(validazioneDocumenti);
  901.         }
  902.         else{
  903.             de.setType(DataElementType.HIDDEN);
  904.         }
  905.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_VALIDAZIONE_DOCUMENTI);
  906.         de.setSize(this.getSize());
  907.         dati.add(de);
  908.         
  909.         de = new DataElement();
  910.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_UPDATE_ENABLED_LEFT);
  911.         de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_UPDATE_ENABLED_RIGHT);
  912.         de.setValue(""+updateEnabled);
  913.         //if (!InterfaceType.STANDARD.equals(user.getInterfaceType())) {
  914.         if(deleter){
  915.             de.setType(DataElementType.HIDDEN);
  916.         }else{
  917.             de.setType(DataElementType.CHECKBOX);
  918.             de.setSelected(updateEnabled);
  919.         }
  920.         //}
  921.         //else{
  922.         //  de.setType("hidden");
  923.         //}
  924.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_UPDATE_ENABLED);
  925.         de.setSize(this.getSize());
  926.         dati.add(de);
  927.         
  928.         de = new DataElement();
  929.         de.setLabel(deleter ? ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_DELETE_POLICY_CONFIG_LEFT : ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_POLICY_CONFIG_LEFT);
  930.         if(this.archiviCore.isConfigurazioneAllarmiEnabled()) {
  931.             de.setLabelRight(deleter ? ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_DELETE_POLICY_CON_ALLARMI_CONFIG_RIGHT : ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_POLICY_CON_ALLARMI_CONFIG_RIGHT);
  932.         }
  933.         else {
  934.             de.setLabelRight(deleter ? ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_DELETE_POLICY_CONFIG_RIGHT : ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_POLICY_CONFIG_RIGHT);
  935.         }
  936.         de.setValue(""+importDeletePolicyConfig);
  937.         //if (!InterfaceType.STANDARD.equals(user.getInterfaceType())) {
  938. //      if(deleter){
  939. //          de.setType(DataElementType.HIDDEN);
  940. //      }else{
  941.             de.setType(DataElementType.CHECKBOX);
  942.             de.setSelected(importDeletePolicyConfig);
  943. //      }
  944.         //}
  945.         //else{
  946.         //  de.setType("hidden");
  947.         //}
  948.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_DELETE_POLICY_CONFIG_ENABLED);
  949.         de.setSize(this.getSize());
  950.         dati.add(de);
  951.         
  952.         de = new DataElement();
  953.         de.setLabel(deleter ? ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_DELETE_PLUGIN_CONFIG_LEFT : ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_PLUGIN_CONFIG_LEFT);
  954.         de.setLabelRight(deleter ? ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_DELETE_PLUGIN_CONFIG_RIGHT : ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_PLUGIN_CONFIG_RIGHT);
  955.         de.setValue(""+importDeletePluginConfig);
  956.         //if (!InterfaceType.STANDARD.equals(user.getInterfaceType())) {
  957. //      if(deleter){
  958. //          de.setType(DataElementType.HIDDEN);
  959. //      }else{
  960.             de.setType(DataElementType.CHECKBOX);
  961.             de.setSelected(importDeletePluginConfig);
  962. //      }
  963.         //}
  964.         //else{
  965.         //  de.setType("hidden");
  966.         //}
  967.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_DELETE_PLUGIN_CONFIG_ENABLED);
  968.         de.setSize(this.getSize());
  969.         dati.add(de);
  970.         
  971.         de = new DataElement();
  972.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_CONFIG_LEFT);
  973.         de.setLabelRight(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_CONFIG_RIGHT);
  974.         de.setValue(""+importConfig);
  975.         //if (!InterfaceType.STANDARD.equals(user.getInterfaceType())) {
  976.         if(deleter){
  977.             de.setType(DataElementType.HIDDEN);
  978.         }else{
  979.             de.setType(DataElementType.CHECKBOX);
  980.             de.setSelected(importConfig);
  981.         }
  982.         //}
  983.         //else{
  984.         //  de.setType("hidden");
  985.         //}
  986.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_CONFIG_ENABLED);
  987.         de.setSize(this.getSize());
  988.         dati.add(de);

  990.         de = new DataElement();
  991.         de.setValue("");
  992.         de.setType(DataElementType.FILE);
  993.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_PACKAGE_FILE);
  994.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_PACKAGE_FILE);
  995.         de.setSize(this.getSize());
  996.         dati.add(de);

  998.     }

  1000.     public List<PortType> readInformazioniProtocolloServiziAzioni(String modalitaAcquisizione,String protocollo,Object object) throws Exception{
  1001.         
  1002.         AccordoServizioParteComune aspc = null;
  1003.         if(object==null){
  1004.             throw new Exception("Accordo non fornito come parametro 'object'");
  1005.         }
  1006.         if(!(object instanceof AccordoServizioParteComune)){
  1007.             throw new Exception("Accordo fornito come parametro 'object' non e' di tipo "+AccordoServizioParteComune.class.getName());
  1008.         }
  1009.         aspc = (AccordoServizioParteComune) object;
  1010.     
  1011.         // rimuovo eventuali port types (sara' il protocollo a inserirli)
  1012.         while(aspc.sizePortTypeList()>0){
  1013.             aspc.removePortType(0);
  1014.         }
  1015.         
  1016.         // Uso il protocollo per riempire il package
  1017.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1018.         protocolFactory.createArchive().setProtocolInfo(aspc);
  1019.         // NOTA il codice sopra lo devo eseguire sempre e comunque per validare il WSDL.
  1020.         // Se il WSDL e' corrotto (es. wsdl senza port type viene sollevata una eccezione)
  1021.         
  1022.         if(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PROTOCOLLO_MANCANTI_RICONOSCIMENTO_WSDL_MODE.equals(modalitaAcquisizione)){
  1023.         
  1024.             return aspc.getPortTypeList();
  1025.         }
  1026.         else{
  1027.             int contatoreServizio = 1;
  1028.             String servizioParam = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE+contatoreServizio;
  1029.             String serviziTmpInput = this.getParameter(servizioParam);
  1030.             List<PortType> portTypes = new ArrayList<>();
  1031.             while(serviziTmpInput!=null && !"".equals(serviziTmpInput)){
  1032.                 //System.out.println("TROVATO SERVIZIO ["+contatoreServizio+"] = "+serviziTmpInput);
  1033.                 
  1034.                 PortType ptOpenSPCoop = new PortType();
  1035.                 ptOpenSPCoop.setNome(serviziTmpInput);
  1036.                 ptOpenSPCoop.setProfiloCollaborazione(ProfiloCollaborazione.toEnumConstant(AccordiServizioParteComuneCostanti.TIPO_PROFILO_COLLABORAZIONE_SINCRONO));
  1037.                 ptOpenSPCoop.setProfiloPT(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  1038.                 ptOpenSPCoop.setFiltroDuplicati(CostantiRegistroServizi.ABILITATO);     
  1039.                 
  1040.                 // Azioni
  1041.                 int contatoreAzione = 1;
  1042.                 String azioniTmpInput = this.getParameter(servizioParam+
  1043.                         ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION+contatoreAzione);
  1044.                 while(azioniTmpInput!=null && !"".equals(azioniTmpInput)){
  1045.                     //System.out.println("TROVATO AZIONE["+contatoreAzione+"] PER SERVIZIO ["+contatoreServizio+"] = "+azioniTmpInput);
  1046.                     Operation operationOpenSPCoop = new Operation();
  1047.                     operationOpenSPCoop.setNome(azioniTmpInput);
  1048.                     operationOpenSPCoop.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  1049.                     operationOpenSPCoop.setFiltroDuplicati(CostantiRegistroServizi.ABILITATO);
  1050.                     
  1051.                     // profiloCollaborazione
  1052.                     String profiliCollaborazioneTmpInput = this.getParameter(servizioParam+
  1053.                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_PROFILO+contatoreAzione);
  1054.                     operationOpenSPCoop.setProfiloCollaborazione(ProfiloCollaborazione.toEnumConstant(profiliCollaborazioneTmpInput));
  1055.                     
  1056.                     // correlazione
  1057.                     if(AccordiServizioParteComuneCostanti.TIPO_PROFILO_COLLABORAZIONE_ASINCRONO_ASIMMETRICO.equals(profiliCollaborazioneTmpInput) || 
  1058.                             AccordiServizioParteComuneCostanti.TIPO_PROFILO_COLLABORAZIONE_ASINCRONO_SIMMETRICO.equals(profiliCollaborazioneTmpInput)){
  1059.                         String servizioAzioneCorrelataTmpInput = this.getParameter(servizioParam+
  1060.                                 ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_SERVIZIO_CORRELATO+contatoreAzione);
  1061.                         if(servizioAzioneCorrelataTmpInput!=null && !"".equals(servizioAzioneCorrelataTmpInput)){
  1062.                             //System.out.println("CORRELAZIONE ["+operationOpenSPCoop.getNome()+"] ["+azioniCorrelataTmpInput+"]");
  1063.                             operationOpenSPCoop.setCorrelataServizio(servizioAzioneCorrelataTmpInput);
  1064.                         }
  1065.                         String azioniCorrelataTmpInput = this.getParameter(servizioParam+
  1066.                                 ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_CORRELATA+contatoreAzione);
  1067.                         if(azioniCorrelataTmpInput!=null && !"".equals(azioniCorrelataTmpInput)){
  1068.                             //System.out.println("CORRELAZIONE ["+operationOpenSPCoop.getNome()+"] ["+azioniCorrelataTmpInput+"]");
  1069.                             operationOpenSPCoop.setCorrelata(azioniCorrelataTmpInput);
  1070.                         }
  1071.                     }
  1072.                     
  1073.                     ptOpenSPCoop.addAzione(operationOpenSPCoop);
  1074.                     
  1075.                     // NextAzione
  1076.                     contatoreAzione++;
  1077.                     azioniTmpInput = this.getParameter(servizioParam+
  1078.                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION+contatoreAzione);
  1079.                 }
  1080.                 
  1081.                 // Next service
  1082.                 contatoreServizio++;
  1083.                 servizioParam = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE+contatoreServizio;
  1084.                 serviziTmpInput = this.getParameter(servizioParam);
  1085.                 
  1086.                 portTypes.add(ptOpenSPCoop);
  1087.             }
  1088.             
  1089.             return portTypes;
  1090.         }
  1091.     }
  1092.     
  1093.     
  1094.     public MapPlaceholder readPlaceholder() throws Exception{
  1095.         
  1096.         MapPlaceholder map = new MapPlaceholder();
  1097.         
  1098.         int index = 0;
  1099.         String pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  1100.         while(pHidden!=null || "".equals(pHidden)){
  1101.             String pValue = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_VALUE+index);
  1102.             map.put(pHidden, pValue);
  1103.             
  1104.             index++;
  1105.             pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  1106.         }
  1107.         
  1108.         if(map.size()<=0){
  1109.             return null;
  1110.         }
  1111.         return map;
  1112.         
  1113.     }
  1114.     
  1115.     public HashMap<String, String> readRequisitiInput() throws Exception{
  1116.         
  1117.         HashMap<String, String> map = new HashMap<>();
  1118.         
  1119.         int index = 0;
  1120.         String pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  1121.         while(pHidden!=null || "".equals(pHidden)){
  1122.             String pName = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_NAME_HIDDEN+index);
  1123.             String pValue = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_VALUE+index);
  1124.             map.put(pName, pValue);
  1125.             
  1126.             index++;
  1127.             pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  1128.         }
  1129.         
  1130.         if(map.size()<=0){
  1131.             return null;
  1132.         }
  1133.         return map;
  1134.         
  1135.     }
  1136.     public HashMap<String, String> readRequisitiStepIncrementInput() throws Exception{
  1137.         
  1138.         HashMap<String, String> map = new HashMap<>();
  1139.         
  1140.         int index = 0;
  1141.         String pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  1142.         while(pHidden!=null || "".equals(pHidden)){
  1143.             String pName = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_NAME_HIDDEN+index);
  1144.             String pValue = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_STEP_INCREMENT_HIDDEN+index);
  1145.             map.put(pName, pValue);
  1146.             
  1147.             index++;
  1148.             pHidden = this.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+index);
  1149.         }
  1150.         
  1151.         if(map.size()<=0){
  1152.             return null;
  1153.         }
  1154.         return map;
  1155.         
  1156.     }
  1157.     
  1158.     
  1159.     public org.openspcoop2.core.config.Credenziali readCredenzialiSA() throws Exception{
  1160.         org.openspcoop2.core.config.Credenziali cis = null;

  1162.         String tipoauth = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE);
  1163.         if (tipoauth == null) {
  1164.             //tipoauth = ServiziApplicativiCostanti.DEFAULT_CREDENZIALI_TIPO_AUTENTICAZIONE;
  1165.             return null;
  1166.         }
  1167.         String utente = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1168.         String password = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1169.         String subject = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_SUBJECT);
  1170.         String issuer = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_ISSUER);
  1171.         String principal = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PRINCIPAL);
  1172.         
  1173.         if (tipoauth!=null && !tipoauth.equals(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString())) {
  1174.                             
  1175.             if (cis == null) {
  1176.                 cis = new org.openspcoop2.core.config.Credenziali();
  1177.             }
  1178.             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA.equals(tipoauth)){
  1179.                 //cis.setTipo(CredenzialeTipo.toEnumConstant(CostantiConfigurazione.AUTENTICAZIONE_NONE));
  1180.                 cis.setTipo(null);
  1181.             }else
  1182.                 cis.setTipo(CredenzialeTipo.toEnumConstant(tipoauth));
  1183.             
  1184.             cis.setUser("");
  1185.             cis.setPassword("");
  1186.             cis.setSubject("");
  1187.             
  1188.             if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC)) {
  1189.                 cis.setUser(utente);
  1190.                 cis.setPassword(password);
  1191.             }
  1192.             
  1193.             if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL)) {
  1194.                 cis.setSubject(subject);
  1195.                 if(StringUtils.isNotEmpty(issuer)) {
  1196.                     cis.setIssuer(issuer);
  1197.                 }
  1198.             }
  1199.             
  1200.             if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL)) {
  1201.                 cis.setUser(principal);
  1202.             }
  1203.         }
  1204.         
  1205.         return  cis;
  1206.     }
  1207.     
  1208.     public org.openspcoop2.core.config.InvocazioneCredenziali readCredenzialiConnettore() throws Exception{
  1209.         org.openspcoop2.core.config.InvocazioneCredenziali cis = null;

  1211.         String tipoauth = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_TIPO_AUTENTICAZIONE);
  1212.         if (tipoauth == null) {
  1213.             tipoauth = ConnettoriCostanti.DEFAULT_AUTENTICAZIONE_TIPO;
  1214.         }
  1215.         String utente = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1216.         String password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1217.         
  1218.         if (tipoauth!=null && tipoauth.equals(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString())) {
  1219.                             
  1220.             if (cis == null) {
  1221.                 cis = new org.openspcoop2.core.config.InvocazioneCredenziali();
  1222.             }
  1223.             cis.setUser(utente);
  1224.             cis.setPassword(password);
  1225.             
  1226.         }
  1227.         
  1228.         return  cis;
  1229.     }
  1230.     
  1231.     public InvocazioneServizio readInvocazioneServizio() throws Exception{
  1232.         
  1233.         InvocazioneServizio invServizio = new InvocazioneServizio();
  1234.         
  1235.         String sbustamento = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  1236.         if(sbustamento==null){
  1237.             return null; // la presenza (in disabilitato o abilitato) garantisce la presenza
  1238.         }
  1239.         String sbustamentoInformazioniProtocolloRichiesta = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RICHIESTA);
  1240.         String getmsg = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  1241.         
  1242.         invServizio.setSbustamentoSoap(StatoFunzionalita.toEnumConstant(sbustamento));
  1243.         invServizio.setSbustamentoInformazioniProtocollo(StatoFunzionalita.toEnumConstant(sbustamentoInformazioniProtocolloRichiesta));
  1244.         invServizio.setGetMessage(StatoFunzionalita.toEnumConstant(getmsg));

  1246.         org.openspcoop2.core.config.InvocazioneCredenziali invCr = this.readCredenzialiConnettore();
  1247.         invServizio.setCredenziali(invCr);
  1248.         if(invCr!=null) {
  1249.             invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  1250.         }
  1251.         
  1252.         TipologiaConnettori tipologiaConnettoriOriginale = null;
  1253.         try{
  1254.             tipologiaConnettoriOriginale = Utilities.getTipologiaConnettori(this.core);
  1255.             Utilities.setTipologiaConnettori(TipologiaConnettori.TIPOLOGIA_CONNETTORI_HTTP);
  1256.         
  1257.             String endpointtype = this.readEndPointType();
  1258.             if(endpointtype==null){
  1259.                 return null;
  1260.             }

  1262.             String tipoconn = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TIPO_PERSONALIZZATO);
  1263.             String user = null;
  1264.             String password = null;
  1265.             
  1266.             String connettoreDebug = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_DEBUG);
  1267.                     
  1268.             // token policy
  1269.             String autenticazioneTokenS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TOKEN_POLICY_STATO);
  1270.             @SuppressWarnings("unused")
  1271.             boolean autenticazioneToken = ServletUtils.isCheckBoxEnabled(autenticazioneTokenS);
  1272.             String tokenPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TOKEN_POLICY);
  1273.             
  1274.             // proxy
  1275.             String proxyEnabled = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_ENABLED);
  1276.             String proxyHostname = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_HOSTNAME);
  1277.             String proxyPort = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_PORT);
  1278.             String proxyUsername = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_USERNAME);
  1279.             String proxyPassword = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_PASSWORD);
  1280.             
  1281.             // tempi risposta
  1282.             String tempiRispostaEnabled = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_REDEFINE);
  1283.             String tempiRispostaConnectionTimeout = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_CONNECTION_TIMEOUT);
  1284.             String tempiRispostaReadTimeout = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_READ_TIMEOUT);
  1285.             String tempiRispostaTempoMedioRisposta = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_TEMPO_MEDIO_RISPOSTA);
  1286.             
  1287.             // opzioni avanzate
  1288.             String transferMode = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_TRANSFER_MODE);
  1289.             String transferModeChunkSize = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_TRANSFER_CHUNK_SIZE);
  1290.             String redirectMode = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_REDIRECT_MODE);
  1291.             String redirectMaxHop = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_REDIRECT_MAX_HOP);
  1292.             String opzioniAvanzate = ConnettoriHelper.getOpzioniAvanzate(this, transferMode, redirectMode);
  1293.             
  1294.             // http
  1295.             String url = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_URL);
  1296.             if(TipiConnettore.HTTP.toString().equals(endpointtype)){
  1297.                 user = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1298.                 password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1299.             }
  1300.             
  1301.             // api key
  1302.             @SuppressWarnings("unused")
  1303.             String autenticazioneApiKey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE_ENABLE_API_KEY);
  1304.             String apiKeyHeader = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_HEADER);
  1305.             if(apiKeyHeader==null || StringUtils.isEmpty(apiKeyHeader)) {
  1306.                 apiKeyHeader = CostantiConnettori.DEFAULT_HEADER_API_KEY;
  1307.             }
  1308.             String apiKeyValue = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_VALUE);
  1309.             String appIdHeader = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_APP_ID_HEADER);
  1310.             if(appIdHeader==null || StringUtils.isEmpty(appIdHeader)) {
  1311.                 appIdHeader = CostantiConnettori.DEFAULT_HEADER_APP_ID;
  1312.             }
  1313.             String appIdValue = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_APP_ID_VALUE);
  1314.             String useOAS3NamesTmp = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_NOMI_OAS);
  1315.             @SuppressWarnings("unused")
  1316.             boolean useOAS3Names=true;
  1317.             if(useOAS3NamesTmp!=null && StringUtils.isNotEmpty(useOAS3NamesTmp)) {
  1318.                 useOAS3Names = ServletUtils.isCheckBoxEnabled(useOAS3NamesTmp);
  1319.             }
  1320.             else {
  1321.                 useOAS3Names = this.isAutenticazioneApiKeyUseOAS3Names(apiKeyHeader, appIdHeader);
  1322.             }
  1323.             String useAppIdTmp = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_USE_APP_ID);
  1324.             @SuppressWarnings("unused")
  1325.             boolean useAppId=false;
  1326.             if(useAppIdTmp!=null && StringUtils.isNotEmpty(useAppIdTmp)) {
  1327.                 useAppId = ServletUtils.isCheckBoxEnabled(useAppIdTmp);
  1328.             }
  1329.             else {
  1330.                 useAppId = this.isAutenticazioneApiKeyUseAppId(appIdValue);
  1331.             }
  1332.             
  1333.             // jms
  1334.             String nomeCodaJMS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_NOME_CODA);
  1335.             String tipo = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_TIPO_CODA);
  1336.             String initcont = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_INIT_CTX);
  1337.             String urlpgk = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_URL_PKG);
  1338.             String provurl = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_PROVIDER_URL);
  1339.             String connfact = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_CONNECTION_FACTORY);
  1340.             String sendas = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_TIPO_OGGETTO_JMS);
  1341.             if(TipiConnettore.JMS.toString().equals(endpointtype)){
  1342.                 user = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_USERNAME);
  1343.                 password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_PASSWORD);
  1344.             }
  1345.             
  1346.             // https
  1347.             String httpsurl = url;
  1348.             String httpstipologia = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  1349.             String httpshostverifyS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  1350.             boolean httpshostverify = ServletUtils.isCheckBoxEnabled(httpshostverifyS);
  1351.             String httpsTrustVerifyCertS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS );
  1352.             boolean httpsTrustVerifyCert = ServletUtils.isCheckBoxEnabled(httpsTrustVerifyCertS);
  1353.             String httpspath = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  1354.             String httpstipo = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  1355.             String httpspwd = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  1356.             String httpsalgoritmo = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  1357.             String httpsstatoS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_STATO);
  1358.             boolean httpsstato = ServletUtils.isCheckBoxEnabled(httpsstatoS);
  1359.             String httpskeystore = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  1360.             String httpspwdprivatekeytrust = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  1361.             String httpspathkey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  1362.             String httpstipokey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  1363.             String httpspwdkey = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  1364.             String httpspwdprivatekey = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  1365.             String httpsalgoritmokey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  1366.             String httpsKeyAlias = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  1367.             String httpsTrustStoreCRLs = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  1368.             String httpsTrustStoreOCSPPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  1369.             String httpsKeyStoreBYOKPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  1370.             if(TipiConnettore.HTTPS.toString().equals(endpointtype)){
  1371.                 user = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1372.                 password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1373.             }
  1374.                     
  1375.             // file
  1376.             String requestOutputFileName = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME);
  1377.             String requestOutputFileNamePermissions = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_PERMISSIONS);
  1378.             String requestOutputFileNameHeaders = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_HEADERS);
  1379.             String requestOutputFileNameHeadersPermissions = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_HEADERS_PERMISSIONS);
  1380.             String requestOutputParentDirCreateIfNotExists = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_AUTO_CREATE_DIR);
  1381.             String requestOutputOverwriteIfExists = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_OVERWRITE_FILE_NAME);
  1382.             String responseInputMode = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_MODE);
  1383.             String responseInputFileName = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME);
  1384.             String responseInputFileNameHeaders = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME_HEADERS);
  1385.             String responseInputDeleteAfterRead = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME_DELETE_AFTER_READ);
  1386.             String responseInputWaitTime = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_WAIT_TIME);
  1387.             
  1388.             //status
  1389.             ConnettoreStatusParams connettoreStatusParams = ConnettoreStatusParams.fillFrom(this);
  1390.             
  1391.             Connettore connis = invServizio.getConnettore();
  1392.             if(connis==null){
  1393.                 connis = new Connettore();
  1394.             }
  1395.             String oldConnT = TipiConnettore.DISABILITATO.getNome();
  1396.             
  1397.             List<ExtendedConnettore> listExtendedConnettore = 
  1398.                     ServletExtendedConnettoreUtils.getExtendedConnettore(connis, ConnettoreServletType.WIZARD_CONFIG, this, false, endpointtype);
  1399.             
  1400.             this.fillConnettore(connis, connettoreDebug, endpointtype, oldConnT, tipoconn, url,
  1401.                     nomeCodaJMS, tipo, user, password,
  1402.                     initcont, urlpgk, provurl, connfact,
  1403.                     sendas, httpsurl, httpstipologia, httpshostverify, 
  1404.                     httpsTrustVerifyCert, httpspath, httpstipo,
  1405.                     httpspwd, httpsalgoritmo, httpsstato,
  1406.                     httpskeystore, httpspwdprivatekeytrust,
  1407.                     httpspathkey, httpstipokey,
  1408.                     httpspwdkey, httpspwdprivatekey,
  1409.                     httpsalgoritmokey,
  1410.                     httpsKeyAlias, httpsTrustStoreCRLs, httpsTrustStoreOCSPPolicy, httpsKeyStoreBYOKPolicy,
  1411.                     proxyEnabled, proxyHostname, proxyPort, proxyUsername, proxyPassword,
  1412.                     tempiRispostaEnabled, tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaTempoMedioRisposta,
  1413.                     opzioniAvanzate, transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  1414.                     requestOutputFileName, requestOutputFileNamePermissions, requestOutputFileNameHeaders, requestOutputFileNameHeadersPermissions,
  1415.                     requestOutputParentDirCreateIfNotExists,requestOutputOverwriteIfExists,
  1416.                     responseInputMode, responseInputFileName, responseInputFileNameHeaders, responseInputDeleteAfterRead, responseInputWaitTime,
  1417.                     tokenPolicy,
  1418.                     apiKeyHeader, apiKeyValue, appIdHeader, appIdValue,
  1419.                     connettoreStatusParams,
  1420.                     listExtendedConnettore);
  1421.             invServizio.setConnettore(connis);
  1422.         
  1423.         }finally{
  1424.             Utilities.setTipologiaConnettori(tipologiaConnettoriOriginale);
  1425.         }
  1426.             
  1427.         return invServizio;
  1428.     }
  1429.     
  1430.     public org.openspcoop2.core.registry.Connettore readConnettore() throws Exception{
  1431.         
  1432.         TipologiaConnettori tipologiaConnettoriOriginale = null;
  1433.         try{
  1434.             tipologiaConnettoriOriginale = Utilities.getTipologiaConnettori(this.core);
  1435.             Utilities.setTipologiaConnettori(TipologiaConnettori.TIPOLOGIA_CONNETTORI_HTTP);
  1436.         
  1437.             String endpointtype = this.readEndPointType();
  1438.             if(endpointtype==null){
  1439.                 return null;
  1440.             }
  1441.             String tipoconn = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TIPO_PERSONALIZZATO);
  1442.             String user = null;
  1443.             String password = null;
  1444.             
  1445.             String connettoreDebug = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_DEBUG);
  1446.                     
  1447.             // token policy
  1448.             String autenticazioneTokenS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TOKEN_POLICY_STATO);
  1449.             @SuppressWarnings("unused")
  1450.             boolean autenticazioneToken = ServletUtils.isCheckBoxEnabled(autenticazioneTokenS);
  1451.             String tokenPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TOKEN_POLICY);
  1452.             
  1453.             // proxy
  1454.             String proxyEnabled = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_ENABLED);
  1455.             String proxyHostname = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_HOSTNAME);
  1456.             String proxyPort = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_PORT);
  1457.             String proxyUsername = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_USERNAME);
  1458.             String proxyPassword = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_PASSWORD);
  1459.             
  1460.             // tempi risposta
  1461.             String tempiRispostaEnabled = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_REDEFINE);
  1462.             String tempiRispostaConnectionTimeout = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_CONNECTION_TIMEOUT);
  1463.             String tempiRispostaReadTimeout = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_READ_TIMEOUT);
  1464.             String tempiRispostaTempoMedioRisposta = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_TEMPO_MEDIO_RISPOSTA);
  1465.             
  1466.             // opzioni avanzate
  1467.             String transferMode = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_TRANSFER_MODE);
  1468.             String transferModeChunkSize = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_TRANSFER_CHUNK_SIZE);
  1469.             String redirectMode = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_REDIRECT_MODE);
  1470.             String redirectMaxHop = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_REDIRECT_MAX_HOP);
  1471.             String opzioniAvanzate = ConnettoriHelper.getOpzioniAvanzate(this, transferMode, redirectMode);
  1472.             
  1473.             // http
  1474.             String url = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_URL);
  1475.             if(TipiConnettore.HTTP.toString().equals(endpointtype)){
  1476.                 user = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1477.                 password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1478.             }
  1479.             
  1480.             // api key
  1481.             @SuppressWarnings("unused")
  1482.             String autenticazioneApiKey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE_ENABLE_API_KEY);
  1483.             String apiKeyHeader = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_HEADER);
  1484.             if(apiKeyHeader==null || StringUtils.isEmpty(apiKeyHeader)) {
  1485.                 apiKeyHeader = CostantiConnettori.DEFAULT_HEADER_API_KEY;
  1486.             }
  1487.             String apiKeyValue = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_VALUE);
  1488.             String appIdHeader = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_APP_ID_HEADER);
  1489.             if(appIdHeader==null || StringUtils.isEmpty(appIdHeader)) {
  1490.                 appIdHeader = CostantiConnettori.DEFAULT_HEADER_APP_ID;
  1491.             }
  1492.             String appIdValue = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_APP_ID_VALUE);
  1493.             String useOAS3NamesTmp = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_NOMI_OAS);
  1494.             @SuppressWarnings("unused")
  1495.             boolean useOAS3Names=true;
  1496.             if(useOAS3NamesTmp!=null && StringUtils.isNotEmpty(useOAS3NamesTmp)) {
  1497.                 useOAS3Names = ServletUtils.isCheckBoxEnabled(useOAS3NamesTmp);
  1498.             }
  1499.             else {
  1500.                 useOAS3Names = this.isAutenticazioneApiKeyUseOAS3Names(apiKeyHeader, appIdHeader);
  1501.             }
  1502.             String useAppIdTmp = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_USE_APP_ID);
  1503.             @SuppressWarnings("unused")
  1504.             boolean useAppId=false;
  1505.             if(useAppIdTmp!=null && StringUtils.isNotEmpty(useAppIdTmp)) {
  1506.                 useAppId = ServletUtils.isCheckBoxEnabled(useAppIdTmp);
  1507.             }
  1508.             else {
  1509.                 useAppId = this.isAutenticazioneApiKeyUseAppId(appIdValue);
  1510.             }
  1511.             
  1512.             // jms
  1513.             String nomeCodaJMS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_NOME_CODA);
  1514.             String tipo = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_TIPO_CODA);
  1515.             String initcont = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_INIT_CTX);
  1516.             String urlpgk = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_URL_PKG);
  1517.             String provurl = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_PROVIDER_URL);
  1518.             String connfact = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_CONNECTION_FACTORY);
  1519.             String sendas = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_TIPO_OGGETTO_JMS);
  1520.             if(TipiConnettore.JMS.toString().equals(endpointtype)){
  1521.                 user = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_USERNAME);
  1522.                 password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_PASSWORD);
  1523.             }
  1524.             
  1525.             // https
  1526.             String httpsurl = url;
  1527.             String httpstipologia = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  1528.             String httpshostverifyS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  1529.             boolean httpshostverify = ServletUtils.isCheckBoxEnabled(httpshostverifyS);
  1530.             String httpsTrustVerifyCertS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS );
  1531.             boolean httpsTrustVerifyCert = ServletUtils.isCheckBoxEnabled(httpsTrustVerifyCertS);
  1532.             String httpspath = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  1533.             String httpstipo = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  1534.             String httpspwd = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  1535.             String httpsalgoritmo = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  1536.             String httpsstatoS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_STATO);
  1537.             boolean httpsstato = ServletUtils.isCheckBoxEnabled(httpsstatoS);
  1538.             String httpskeystore = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  1539.             String httpspwdprivatekeytrust = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  1540.             String httpspathkey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  1541.             String httpstipokey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  1542.             String httpspwdkey = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  1543.             String httpspwdprivatekey = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  1544.             String httpsalgoritmokey = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  1545.             String httpsKeyAlias = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  1546.             String httpsTrustStoreCRLs = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  1547.             String httpsTrustStoreOCSPPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  1548.             String httpsKeyStoreBYOKPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  1549.             if(TipiConnettore.HTTPS.toString().equals(endpointtype)){
  1550.                 user = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1551.                 password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1552.             }
  1553.                         
  1554.             // file
  1555.             String requestOutputFileName = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME);
  1556.             String requestOutputFileNamePermissions = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_PERMISSIONS);
  1557.             String requestOutputFileNameHeaders = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_HEADERS);
  1558.             String requestOutputFileNameHeadersPermissions = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_HEADERS_PERMISSIONS);
  1559.             String requestOutputParentDirCreateIfNotExists = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_AUTO_CREATE_DIR);
  1560.             String requestOutputOverwriteIfExists = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_OVERWRITE_FILE_NAME);
  1561.             String responseInputMode = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_MODE);
  1562.             String responseInputFileName = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME);
  1563.             String responseInputFileNameHeaders = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME_HEADERS);
  1564.             String responseInputDeleteAfterRead = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME_DELETE_AFTER_READ);
  1565.             String responseInputWaitTime = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_WAIT_TIME);
  1566.             
  1567.             //status
  1568.             ConnettoreStatusParams connettoreStatusParams = ConnettoreStatusParams.fillFrom(this);
  1569.                         
  1570.             org.openspcoop2.core.registry.Connettore connettore = new org.openspcoop2.core.registry.Connettore();
  1571.             
  1572.             List<ExtendedConnettore> listExtendedConnettore = 
  1573.                     ServletExtendedConnettoreUtils.getExtendedConnettore(connettore, ConnettoreServletType.WIZARD_REGISTRY, this, false, endpointtype);
  1574.             
  1575.             String oldConnT = TipiConnettore.DISABILITATO.getNome();
  1576.             this.fillConnettore(connettore, connettoreDebug, endpointtype, oldConnT, tipoconn, url,
  1577.                     nomeCodaJMS, tipo, user, password,
  1578.                     initcont, urlpgk, provurl, connfact,
  1579.                     sendas, httpsurl, httpstipologia, httpshostverify, 
  1580.                     httpsTrustVerifyCert, httpspath, httpstipo,
  1581.                     httpspwd, httpsalgoritmo, httpsstato,
  1582.                     httpskeystore, httpspwdprivatekeytrust,
  1583.                     httpspathkey, httpstipokey,
  1584.                     httpspwdkey, httpspwdprivatekey,
  1585.                     httpsalgoritmokey,
  1586.                     httpsKeyAlias, httpsTrustStoreCRLs, httpsTrustStoreOCSPPolicy, httpsKeyStoreBYOKPolicy,
  1587.                     proxyEnabled, proxyHostname, proxyPort, proxyUsername, proxyPassword,
  1588.                     tempiRispostaEnabled, tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaTempoMedioRisposta,
  1589.                     opzioniAvanzate, transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  1590.                     requestOutputFileName, requestOutputFileNamePermissions, requestOutputFileNameHeaders, requestOutputFileNameHeadersPermissions,
  1591.                     requestOutputParentDirCreateIfNotExists,requestOutputOverwriteIfExists,
  1592.                     responseInputMode, responseInputFileName, responseInputFileNameHeaders, responseInputDeleteAfterRead, responseInputWaitTime,
  1593.                     tokenPolicy,
  1594.                     apiKeyHeader, apiKeyValue, appIdHeader, appIdValue,
  1595.                     connettoreStatusParams,
  1596.                     listExtendedConnettore);
  1597.             
  1598.             return connettore;
  1599.             
  1600.         }finally{
  1601.             Utilities.setTipologiaConnettori(tipologiaConnettoriOriginale);
  1602.         }
  1603.     }
  1604.     
  1605.     public void addImportInformationMissingToDati(List<DataElement> dati,ImporterUtils importerUtils, FormFile ff,
  1606.             String protocolloSelect,String inputMode,String protocolloEffettivo,String inputType,
  1607.             boolean validazioneDocumenti,boolean updateEnabled,
  1608.             boolean importDeletePolicyConfig, 
  1609.             boolean importDeletePluginConfig,
  1610.             boolean importConfig,
  1611.             ImportInformationMissingCollection importInformationMissingCollection,
  1612.             ImportInformationMissingException importInformationMissingException,
  1613.             String modalitaAcquisizioneInformazioniProtocollo,List<PortType> portTypesOpenSPCoop,
  1614.             List<String> protocolliForModes,
  1615.             boolean readedDatiConnettori,
  1616.             Wizard wizard, int step,
  1617.             boolean delete) throws Exception{
  1618.                 
  1619.         
  1620.         String oldMessage = this.pd.getMessage();
  1621.         if(oldMessage!=null && !"".equals(oldMessage)){
  1622.             oldMessage = ArchiviCostanti.LABEL_IMPORT_ERRORE+oldMessage;
  1623.         }else{
  1624.             oldMessage = "";
  1625.         }
  1626.         boolean showIntestazioneArchivio = true;
  1627.         boolean showSection = true;
  1628.         ServiceBinding serviceBinding = null;
  1629.         if(wizard!=null){
  1630.             
  1631.             if ( importInformationMissingException!=null && importInformationMissingException.isMissingRequisitiInfoInput() ){
  1632.                 this.pd.setMessage(wizard.getDescrizione()+oldMessage,Costanti.MESSAGE_TYPE_INFO);
  1633.             }
  1634.             else {
  1635.                 int actualStep = step;
  1636.                 int stepConfigurated = -1;
  1637.                 if(wizard.getStep()>0){
  1638.                     stepConfigurated = wizard.getStep();
  1639.                 }
  1640.                 if(delete) {
  1641.                     if(wizard.getStepInDelete()>0){
  1642.                         stepConfigurated = wizard.getStepInDelete();
  1643.                     }
  1644.                 }
  1645.                 
  1646.                 // verifico se sono stati raccolti dei requisiti
  1647.                 if(importInformationMissingCollection!=null && importInformationMissingCollection.exists(org.openspcoop2.protocol.engine.constants.Costanti.REQUISITI_INPUT_RACCOLTI)) {
  1648.                     ImportInformationMissing miss = importInformationMissingCollection.get(org.openspcoop2.protocol.engine.constants.Costanti.REQUISITI_INPUT_RACCOLTI);
  1649.                     if(miss.getRequisitiInput()!=null && !miss.getRequisitiInput().isEmpty() &&
  1650.                             miss.getRequisitiInputStepIncrement()!=null && !miss.getRequisitiInputStepIncrement().isEmpty()) {
  1651.                         
  1652.                         actualStep--; // il primo step non si conta
  1653.                         
  1654.                         Iterator<String> it = miss.getRequisitiInputStepIncrement().keySet().iterator();
  1655.                         while (it.hasNext()) {
  1656.                             String inputName = (String) it.next();
  1657.                             String stepIncrementValue_incrementNumber_incrementCondition = miss.getRequisitiInputStepIncrement().get(inputName);
  1658.                             int increment = -1;
  1659.                             String stepIncrementValue = null;
  1660.                             if(stepIncrementValue_incrementNumber_incrementCondition.contains(" ")) {
  1661.                                 String [] tmp = stepIncrementValue_incrementNumber_incrementCondition.split(" ");
  1662.                                 increment = Integer.valueOf(tmp[0]);
  1663.                                 stepIncrementValue = stepIncrementValue_incrementNumber_incrementCondition.substring((tmp[0]+" ").length());
  1664.                             }
  1665.                             String value = miss.getRequisitiInput().get(inputName);
  1666.                             if(stepIncrementValue!=null && stepIncrementValue.equals(value)) {
  1667.                                 stepConfigurated = stepConfigurated + increment;
  1668.                             }
  1669.                         }
  1670.                     }
  1671.                 }
  1672.                         
  1673.                 String stepDescription = " (Fase "+actualStep;
  1674.                 if(stepConfigurated>0){
  1675.                     stepDescription+="/"+stepConfigurated;
  1676.                 }
  1677.                 stepDescription+=")";
  1678.                 this.pd.setMessage(wizard.getDescrizione()+stepDescription+oldMessage,Costanti.MESSAGE_TYPE_INFO);
  1679.             }
  1680.             
  1681.             showIntestazioneArchivio = wizard.getIntestazioneOriginale();
  1682.             
  1683.             if(importInformationMissingException!=null) {
  1684.                 DataElement de = new DataElement();
  1685.                 de.setLabel(importInformationMissingException.getIdObjectDescription());
  1686.                 de.setType(DataElementType.TITLE);
  1687.                 dati.add(de);
  1688.             }
  1689.             
  1690.             showSection = false;
  1691.             
  1692.         }else{
  1693.             this.pd.setMessage(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_MANCANTI+oldMessage);
  1694.         }
  1695.         

  1697.         
  1698.         
  1699.         
  1700.         
  1701.         
  1702.         
  1703.         
  1704.         
  1705.         
  1706.         
  1707.         
  1708.         
  1709.         
  1710.         String sessionId = this.request.getSession().getId();

  1712.         // hidden fields
  1713.         
  1714.         DataElement de = new DataElement();
  1715.         de.setValue(protocolloSelect);
  1716.         de.setType(DataElementType.HIDDEN);
  1717.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO);
  1718.         de.setSize(this.getSize());
  1719.         dati.add(de);
  1720.         
  1721.         de = new DataElement();
  1722.         de.setValue(inputMode);
  1723.         de.setType(DataElementType.HIDDEN);
  1724.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  1725.         de.setSize(this.getSize());
  1726.         dati.add(de);
  1727.         
  1728.         de = new DataElement();
  1729.         de.setValue(inputType);
  1730.         de.setType(DataElementType.HIDDEN);
  1731.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPO);
  1732.         de.setSize(this.getSize());
  1733.         dati.add(de);
  1734.         
  1735.         de = new DataElement();
  1736.         de.setValue(""+validazioneDocumenti);
  1737.         de.setType(DataElementType.HIDDEN);
  1738.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_VALIDAZIONE_DOCUMENTI);
  1739.         de.setSize(this.getSize());
  1740.         dati.add(de);
  1741.         
  1742.         de = new DataElement();
  1743.         de.setValue(""+updateEnabled);
  1744.         de.setType(DataElementType.HIDDEN);
  1745.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_UPDATE_ENABLED);
  1746.         de.setSize(this.getSize());
  1747.         dati.add(de);
  1748.         
  1749.         de = new DataElement();
  1750.         de.setValue(""+importDeletePolicyConfig);
  1751.         de.setType(DataElementType.HIDDEN);
  1752.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_DELETE_POLICY_CONFIG_ENABLED);
  1753.         de.setSize(this.getSize());
  1754.         dati.add(de);
  1755.         
  1756.         de = new DataElement();
  1757.         de.setValue(""+importDeletePluginConfig);
  1758.         de.setType(DataElementType.HIDDEN);
  1759.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_DELETE_PLUGIN_CONFIG_ENABLED);
  1760.         de.setSize(this.getSize());
  1761.         dati.add(de);
  1762.         
  1763.         de = new DataElement();
  1764.         de.setValue(""+importConfig);
  1765.         de.setType(DataElementType.HIDDEN);
  1766.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_CONFIG_ENABLED);
  1767.         de.setSize(this.getSize());
  1768.         dati.add(de);
  1769.         
  1770.         if(importInformationMissingException!=null) {
  1771.             de = new DataElement();
  1772.             de.setValue(importInformationMissingException.getIdObject());
  1773.             de.setType(DataElementType.HIDDEN);
  1774.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_ID);
  1775.             de.setSize(this.getSize());
  1776.             dati.add(de);
  1777.         }

  1779.         File fileFormFile = importerUtils.writeFormFile(sessionId, ff);
  1780.         de = new DataElement();
  1781.         de.setValue(fileFormFile.getAbsolutePath());
  1782.         de.setType(DataElementType.HIDDEN);
  1783.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_PACKAGE_FILE_PATH);
  1784.         dati.add(de);
  1785.         
  1786.         File fileImportInformationMissingCollection = null;
  1787.         if(importInformationMissingCollection!=null){
  1788.             fileImportInformationMissingCollection = importerUtils.writeImportInformationMissingCollectionFile(sessionId, importInformationMissingCollection);
  1789.             de = new DataElement();
  1790.             de.setValue(fileImportInformationMissingCollection.getAbsolutePath());
  1791.             de.setType(DataElementType.HIDDEN);
  1792.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_COLLECTION_FILE_PATH);
  1793.             dati.add(de);
  1794.         }
  1795.         
  1796.         de = new DataElement();
  1797.         if(importInformationMissingException!=null && importInformationMissingException.getClassObject()!=null){
  1798.             de.setValue(importInformationMissingException.getClassObject().getName());
  1799.         }
  1800.         else{
  1801.             de.setValue("");
  1802.         }
  1803.         de.setType(DataElementType.HIDDEN);
  1804.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_CLASS);
  1805.         dati.add(de);
  1806.     
  1807.         File fileImportInformationMissingObject = null;
  1808.         if(importInformationMissingException!=null && importInformationMissingException.getObject()!=null){
  1809.             fileImportInformationMissingObject = importerUtils.writeImportInformationMissingObjectFile(sessionId, importInformationMissingException.getObject());
  1810.         }
  1811.         de = new DataElement();
  1812.         if(fileImportInformationMissingObject!=null){
  1813.             de.setValue(fileImportInformationMissingObject.getAbsolutePath());
  1814.         }
  1815.         else{
  1816.             de.setValue("");
  1817.         }
  1818.         de.setType(DataElementType.HIDDEN);
  1819.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_FILE_PATH);
  1820.         dati.add(de);
  1821.         
  1822.         // inizio della grafica effettiva
  1823.         
  1824.         if(showIntestazioneArchivio){
  1825.             de = new DataElement();
  1826.             de.setLabel(ArchiviCostanti.LABEL_ARCHIVIO);
  1827.             de.setType(DataElementType.TITLE);
  1828.             dati.add(de);
  1829.         }
  1830.         
  1831.         de = new DataElement();
  1832.         de.setValue(ff.getFileName());
  1833.         if(showIntestazioneArchivio){
  1834.             de.setType(DataElementType.TEXT);
  1835.         }
  1836.         else{
  1837.             de.setType(DataElementType.HIDDEN);
  1838.         }
  1839.         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_PACKAGE_FILE_SIMPLE_NAME);
  1840.         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_PACKAGE_FILE_SIMPLE_NAME);
  1841.         dati.add(de);

  1843.         if(importInformationMissingException!=null) {
  1844.             de = new DataElement();
  1845.             de.setValue(importInformationMissingException.getIdObjectDescription());
  1846.             if(showIntestazioneArchivio){
  1847.                 de.setType(DataElementType.TEXT);
  1848.             }
  1849.             else{
  1850.                 de.setType(DataElementType.HIDDEN);
  1851.             }
  1852.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_ID_DESCRIPTION);
  1853.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_ID_DESCRIPTION);
  1854.             dati.add(de);
  1855.         }

  1857.         
  1858.         
  1859.         
  1860.         
  1861.         
  1862.         
  1863.         
  1864.         
  1865.         
  1866.         
  1867.         
  1868.         
  1869.         
  1870.         
  1871.         
  1872.         // requisiti
  1873.         if ( importInformationMissingException!=null && importInformationMissingException.isMissingRequisitiInfoInput() ){
  1874.         
  1875.             RequisitoInput requisitoInput = importInformationMissingException.getMissingRequisitiInfoInputObject();
  1876.             
  1877.             if(showSection){
  1878.                 de = new DataElement();
  1879.                 de.setLabel(requisitoInput.getDescrizione());
  1880.                 de.setType(DataElementType.TITLE);
  1881.                 dati.add(de);
  1882.             }
  1883.             
  1884.             HashMap<String, String> mapRequisitiInput = this.readRequisitiInput();
  1885.             if(mapRequisitiInput==null) {
  1886.                 mapRequisitiInput = new HashMap<>();
  1887.             }
  1888.             for (int i = 0; i < requisitoInput.sizeProprietaList(); i++) {
  1889.                 ProprietaRequisitoInput p = requisitoInput.getProprieta(i);
  1890.                 if(mapRequisitiInput.containsKey(p.getNome())==false) {
  1891.                     if(p.getConditions()!=null) {
  1892.                         if(ImporterInformationMissingUtils.checkConditions(p.getConditions(),mapRequisitiInput)==false) {
  1893.                             continue;
  1894.                         }
  1895.                     }
  1896.                     mapRequisitiInput.put(p.getNome(), p.getDefault());
  1897.                 }
  1898.             }
  1899.             
  1900.             int indexParam = 0;
  1901.             
  1902.             for (int k = 0; k < requisitoInput.sizeProprietaList(); k++) {
  1903.                 
  1904.                 ProprietaRequisitoInput p = requisitoInput.getProprieta(k);
  1905.                 
  1906.                 if(delete && !p.isUseInDelete()) {
  1907.                     continue;
  1908.                 }
  1909.                 
  1910.                 if(p.getConditions()!=null) {
  1911.                     if(ImporterInformationMissingUtils.checkConditions(p.getConditions(),mapRequisitiInput)==false) {
  1912.                         continue;
  1913.                     }
  1914.                 }
  1915.                                 
  1916.                 if(p.getHeader()!=null) {
  1917.                     this.addDescriptionInformationMissingToDati(dati,  p.getHeader() );
  1918.                 }
  1919.                         
  1920.                 boolean required = false;
  1921.                 
  1922.                 String valore = p.getDefault();
  1923.                 if(mapRequisitiInput!=null && mapRequisitiInput.containsKey(p.getNome())) {
  1924.                     valore = mapRequisitiInput.get(p.getNome());
  1925.                 }
  1926.                 
  1927.                 de = new DataElement();
  1928.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_VALUE+indexParam);
  1929.                 switch (p.getTipo()) {
  1930.                 case HIDDEN:
  1931.                     de.setType(DataElementType.HIDDEN);
  1932.                     de.setValue(valore);
  1933.                     break;
  1934.                 case CHECKBOX:
  1935.                     de.setType(DataElementType.CHECKBOX);
  1936.                     de.setSelected(ServletUtils.isCheckBoxEnabled(valore));
  1937.                     de.setPostBack(p.isReloadOnChange());
  1938.                     break;
  1939.                 case TEXTEDIT:
  1940.                     de.setRequired(true);
  1941.                     de.setType(DataElementType.TEXT_EDIT);
  1942.                     de.setValue(valore);
  1943.                     required = true;
  1944.                     break;
  1945.                 }
  1946.                 de.setLabel(p.getLabel());
  1947.                 de.setSize(this.getSize());
  1948.                 dati.add(de);
  1949.                 
  1950.                 de = new DataElement();
  1951.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_HIDDEN+indexParam);
  1952.                 de.setType(DataElementType.HIDDEN);
  1953.                 de.setValue(required+"");
  1954.                 dati.add(de);
  1955.                 
  1956.                 de = new DataElement();
  1957.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_NAME_HIDDEN+indexParam);
  1958.                 de.setType(DataElementType.HIDDEN);
  1959.                 de.setValue(p.getNome());
  1960.                 dati.add(de);
  1961.                 
  1962.                 de = new DataElement();
  1963.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_REQUISITO_INPUT_PROPRIETA_PREFIX_STEP_INCREMENT_HIDDEN+indexParam);
  1964.                 de.setType(DataElementType.HIDDEN);
  1965.                 de.setValue(p.getStepIncrementCondition()==null ? "1 N.D." : p.getStepIncrement() + " "+p.getStepIncrementCondition());
  1966.                 dati.add(de);
  1967.                 
  1968.                 if(p.getFooter()!=null) {
  1969.                     this.addDescriptionInformationMissingToDati(dati,  p.getFooter() );
  1970.                 }
  1971.                 
  1972.                 indexParam++;
  1973.             }
  1974.             
  1975.         }
  1976.                 
  1977.         
  1978.         
  1979.         
  1980.         
  1981.         
  1982.         
  1983.         
  1984.         
  1985.         
  1986.         

  1988.         
  1989.         
  1990.         // soggetto - versione - accordoParteComune - accordoCooperazione
  1991.         
  1992.         if ( 
  1993.                 importInformationMissingException!=null && 
  1994.                 (
  1995.                         importInformationMissingException.isMissingInfoSoggetto() ||
  1996.                         importInformationMissingException.isMissingInfoVersione() ||
  1997.                         importInformationMissingException.isMissingInfoAccordoServizioParteComune() || 
  1998.                         importInformationMissingException.isMissingInfoAccordoCooperazione()
  1999.                 )
  2000.             ) {
  2001.             
  2002.             String labelSection = ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_IDENTIFICAZIONE_MANCANTI;
  2003.             String labelSoggettoDataElement = ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT;
  2004.             
  2005.             if ( importInformationMissingException.isMissingInfoSoggetto() &&
  2006.                     !importInformationMissingException.isMissingInfoVersione() &&
  2007.                     !importInformationMissingException.isMissingInfoAccordoServizioParteComune() && 
  2008.                     !importInformationMissingException.isMissingInfoAccordoCooperazione() ) {
  2009.                 labelSection = ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT;
  2010.                 labelSoggettoDataElement = ArchiviCostanti.LABEL_NOME_SOGGETTO;
  2011.             }
  2012.             
  2013.             if(showSection){
  2014.                 de = new DataElement();
  2015.                 de.setLabel(labelSection);
  2016.                 de.setType(DataElementType.TITLE);
  2017.                 dati.add(de);
  2018.             }

  2020.             if ( importInformationMissingException.getMissingInfoHeader()!=null ){
  2021.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoHeader() );
  2022.             }
  2023.             
  2024.             if ( importInformationMissingException.isMissingInfoSoggetto() ){
  2025.             
  2026.                 List<String> soggettiLabel = null;
  2027.                 try{
  2028.                     soggettiLabel = importerUtils.getIdSoggetti(protocolliForModes,inputMode,
  2029.                             importInformationMissingException.getMissingInfoProtocollo(),
  2030.                             importInformationMissingException.getMissingInfoSoggetto_tipoPdD(),
  2031.                             wizard, this);
  2032.                 }catch(Exception e){
  2033.                     this.pd.setMessage(this.pd.getMessage()+ArchiviCostanti.LABEL_IMPORT_ERRORE+e.getMessage());
  2034.                     this.pd.disableEditMode();
  2035.                     return;
  2036.                 }
  2037.                 
  2038.                 de = new DataElement();
  2039.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT);
  2040.                 de.setType(DataElementType.SELECT);
  2041.                 de.setLabel(labelSoggettoDataElement);
  2042.                 de.setValues(soggettiLabel.toArray(new String[1]));
  2043.                 
  2044.                 List<String> labelSoggettiByProtocol = new ArrayList<>();
  2045.                 for (String soggetto : soggettiLabel) {
  2046.                     if(soggetto.contains("/")) {
  2047.                         IDSoggetto idSoggetto = new IDSoggetto(soggetto.split("/")[0], soggetto.split("/")[1]);
  2048.                         labelSoggettiByProtocol.add(this.getLabelNomeSoggetto(idSoggetto));
  2049.                     }else {
  2050.                         labelSoggettiByProtocol.add(soggetto);
  2051.                     }
  2052.                 }
  2053.                 de.setLabels(labelSoggettiByProtocol.toArray(new String[1]));
  2054.             
  2055.                 String selected = null;
  2056.                 if(importInformationMissingException.getMissingInfoDefault()!=null && importInformationMissingException.getMissingInfoDefault().getValore()!=null) {
  2057.                     if(soggettiLabel.contains(importInformationMissingException.getMissingInfoDefault().getValore())) {
  2058.                         selected = importInformationMissingException.getMissingInfoDefault().getValore();
  2059.                     }
  2060.                 }
  2061.                 if(selected==null) {
  2062.                     if(soggettiLabel.size()>1)
  2063.                         selected = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED;
  2064.                     else
  2065.                         selected = soggettiLabel.get(0);
  2066.                 }
  2067.                 de.setSelected(selected);
  2068.                 
  2069.                 de.setSize(this.getSize());
  2070.                 dati.add(de);
  2071.                 
  2072.             }
  2073.     
  2074.             if ( importInformationMissingException.isMissingInfoVersione() ){
  2075.             
  2076.                 de = new DataElement();
  2077.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_VERSIONE_INPUT);
  2078.                 de.setType(DataElementType.TEXT_EDIT);
  2079.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_VERSIONE_INPUT);
  2080.                 Integer version = null;
  2081.                 if(importInformationMissingException.getMissingInfoDefault()!=null && importInformationMissingException.getMissingInfoDefault().getValore()!=null) {
  2082.                     try {
  2083.                         version = Integer.valueOf(importInformationMissingException.getMissingInfoDefault().getValore());
  2084.                     }catch(Exception e) {}
  2085.                 }
  2086.                 if(version==null) {
  2087.                     version = 1;
  2088.                 }
  2089.                 de.setValue(version.intValue()+"");
  2090.                 de.setSize(30);
  2091.                 dati.add(de);
  2092.                 
  2093.             }
  2094.             
  2095.             if ( importInformationMissingException.isMissingInfoAccordoServizioParteComune() ){
  2096.                 
  2097.                 List<String> accordiServizioParteComuneLabel = importerUtils.getIdAccordiServizioParteComune(protocolliForModes,inputMode,
  2098.                         importInformationMissingException.getMissingInfoProtocollo(), this);
  2099.                 
  2100.                 de = new DataElement();
  2101.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_SERVIZIO_PARTE_COMUNE_INPUT);
  2102.                 de.setType(DataElementType.SELECT);
  2103.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_SERVIZIO_PARTE_COMUNE_INPUT);
  2104.                 de.setValues(accordiServizioParteComuneLabel.toArray(new String[1]));
  2105.                 
  2106.                 List<String> labelAccordiByProtocol = new ArrayList<>();
  2107.                 for (String uriAccordo : accordiServizioParteComuneLabel) {
  2108.                     IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(uriAccordo);
  2109.                     labelAccordiByProtocol.add(this.getLabelIdAccordo(idAccordo));
  2110.                 }
  2111.                 de.setLabels(labelAccordiByProtocol.toArray(new String[1]));
  2112.                 
  2113.                 String selected = null;
  2114.                 if(importInformationMissingException.getMissingInfoDefault()!=null && importInformationMissingException.getMissingInfoDefault().getValore()!=null) {
  2115.                     if(accordiServizioParteComuneLabel.contains(importInformationMissingException.getMissingInfoDefault().getValore())) {
  2116.                         selected = importInformationMissingException.getMissingInfoDefault().getValore();
  2117.                     }
  2118.                 }
  2119.                 if(selected==null) {
  2120.                     selected = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED;
  2121.                 }
  2122.                 de.setSelected(selected);

  2124.                 de.setSize(this.getSize());
  2125.                 dati.add(de);
  2126.                 
  2127.             }
  2128.             
  2129.             if ( importInformationMissingException.isMissingInfoAccordoCooperazione() ){
  2130.                 
  2131.                 List<String> accordiCooperazioneLabel = importerUtils.getIdAccordiCooperazione(protocolliForModes,inputMode,
  2132.                         importInformationMissingException.getMissingInfoProtocollo(), this);
  2133.                 
  2134.                 de = new DataElement();
  2135.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_COOPERAZIONE_INPUT);
  2136.                 de.setType(DataElementType.SELECT);
  2137.                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_COOPERAZIONE_INPUT);
  2138.                 de.setValues(accordiCooperazioneLabel.toArray(new String[1]));
  2139.                 
  2140.                 List<String> labelAccordiByProtocol = new ArrayList<>();
  2141.                 for (String uriAccordo : accordiCooperazioneLabel) {
  2142.                     IDAccordoCooperazione idAccordo = IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromUri(uriAccordo);
  2143.                     labelAccordiByProtocol.add(this.getLabelIdAccordoCooperazione(idAccordo));
  2144.                 }
  2145.                 de.setLabels(labelAccordiByProtocol.toArray(new String[1]));
  2146.                 
  2147.                 String selected = null;
  2148.                 if(importInformationMissingException.getMissingInfoDefault()!=null && importInformationMissingException.getMissingInfoDefault().getValore()!=null) {
  2149.                     if(accordiCooperazioneLabel.contains(importInformationMissingException.getMissingInfoDefault().getValore())) {
  2150.                         selected = importInformationMissingException.getMissingInfoDefault().getValore();
  2151.                     }
  2152.                 }
  2153.                 if(selected==null) {
  2154.                     selected = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED;
  2155.                 }
  2156.                 de.setSelected(selected);
  2157.                 
  2158.                 de.setSize(this.getSize());
  2159.                 dati.add(de);
  2160.                 
  2161.             }
  2162.             
  2163.             if ( importInformationMissingException.getMissingInfoFooter()!=null ){
  2164.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoFooter() );
  2165.             }
  2166.         }

  2168.         
  2169.         
  2170.         
  2171.         
  2172.         
  2173.         
  2174.         
  2175.         // input
  2176.         if ( importInformationMissingException!=null && importInformationMissingException.isMissingInfoInput() ){
  2177.         
  2178.             Input input = importInformationMissingException.getMissingInfoInputObject();
  2179.             
  2180.             if(showSection){
  2181.                 de = new DataElement();
  2182.                 de.setLabel(input.getDescrizione());
  2183.                 de.setType(DataElementType.TITLE);
  2184.                 dati.add(de);
  2185.             }
  2186.             
  2187.             for (int i = 0; i < input.sizeProprietaList(); i++) {
  2188.                 
  2189.                 Proprieta p = input.getProprieta(i);
  2190.                 
  2191.                 if(delete && !p.isUseInDelete()) {
  2192.                     continue;
  2193.                 }
  2194.                 
  2195.                 if(p.getHeader()!=null) {
  2196.                     this.addDescriptionInformationMissingToDati(dati,  p.getHeader() );
  2197.                 }
  2198.                 
  2199.                 de = new DataElement();
  2200.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_HIDDEN+i);
  2201.                 de.setType(DataElementType.HIDDEN);
  2202.                 de.setValue(p.getPlaceholder());
  2203.                 de.setSize(30);
  2204.                 dati.add(de);
  2205.                 
  2206.                 de = new DataElement();
  2207.                 de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INPUT_PROPRIETA_PREFIX_VALUE+i);
  2208.                 de.setRequired(true);
  2209.                 de.setType(DataElementType.TEXT_EDIT);
  2210.                 de.setLabel(p.getNome());
  2211.                 de.setValue(p.getDefault());
  2212.                 de.setSize(this.getSize());
  2213.                 dati.add(de);
  2214.                 
  2215.                 if(p.getFooter()!=null) {
  2216.                     this.addDescriptionInformationMissingToDati(dati,  p.getFooter() );
  2217.                 }
  2218.             }
  2219.             
  2220.         }
  2221.         
  2222.         
  2223.         
  2224.         
  2225.         
  2226.         
  2227.         // servizi parte comune
  2228.         
  2229.         if ( importInformationMissingException!=null && importInformationMissingException.isMissingInfoProfiliServizi() ){
  2230.             
  2231.             if(showSection){
  2232.                 de = new DataElement();
  2233.                 de.setLabel(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PROTOCOLLO_MANCANTI);
  2234.                 de.setType(DataElementType.TITLE);
  2235.                 dati.add(de);
  2236.             }

  2238.             if ( importInformationMissingException.getMissingInfoHeader()!=null ){
  2239.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoHeader() );
  2240.             }
  2241.             
  2242.             String[] modalitaAcquisizione = { ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PROTOCOLLO_MANCANTI_RICONOSCIMENTO_WSDL_MODE, 
  2243.                     ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PROTOCOLLO_MANCANTI_RICONOSCIMENTO_USER_INPUT };

  2245.             de = new DataElement();
  2246.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT);
  2247.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT);
  2248.             de.setType(DataElementType.SELECT);
  2249.             de.setValues(modalitaAcquisizione);
  2250.             de.setSelected(modalitaAcquisizioneInformazioniProtocollo);
  2251.             de.setPostBack(true);
  2252.             dati.add(de);
  2253.             
  2254.             if(modalitaAcquisizioneInformazioniProtocollo!=null && 
  2255.                     ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PROTOCOLLO_MANCANTI_RICONOSCIMENTO_USER_INPUT.equals(modalitaAcquisizioneInformazioniProtocollo)){
  2256.             
  2257.                 Object object = importInformationMissingException.getObject();
  2258.                 AccordoServizioParteComune aspc = (AccordoServizioParteComune) object;
  2259.                 serviceBinding = this.apcCore.toMessageServiceBinding(aspc.getServiceBinding());                        
  2260.                 
  2261.                 // Provo a comprendere il protocollo associato all'accordo di servizio parte comune se e' definito il soggetto referente
  2262.                 // Serve per visualizzare i profili di collaborazione supportati
  2263.                 String protocolloAccordo = null;
  2264.                 if(aspc.getSoggettoReferente()!=null && aspc.getSoggettoReferente().getTipo()!=null){
  2265.                     protocolloAccordo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(aspc.getSoggettoReferente().getTipo());
  2266.                 }
  2267.                 
  2268.                 // Impostazione protocollo
  2269.                 if(protocolloAccordo==null){
  2270.                     protocolloAccordo = protocolloEffettivo; // uso l'impostazione associata al tipo in package scelto.
  2271.                 }
  2272.                 
  2273.                 // read WSDL Base sfruttando il BasicArchive (non serve il protocollo)
  2274.                 BasicArchive basicArchive = new BasicArchive(new BasicProtocolFactory(this.log));
  2275.                 basicArchive.setProtocolInfo(aspc,ControlStationCore.getLog());
  2276.                                 
  2277.                 if(aspc.sizePortTypeList()>0){
  2278.                     
  2279.                     // port types
  2280.                     int contatoreServizio = 1;
  2281.                     for (PortType ptWSDL : aspc.getPortTypeList()) {
  2282.                         
  2283.                         PortType ptOpenSPCoop = null;
  2284.                         if(portTypesOpenSPCoop.size()>=contatoreServizio){
  2285.                             ptOpenSPCoop = portTypesOpenSPCoop.get((contatoreServizio-1));
  2286.                         }

  2288.                         de = new DataElement();
  2289.                         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_TITLE.
  2290.                                 replace(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_TITLE_KEY, ptWSDL.getNome()));
  2291.                         de.setType(DataElementType.TITLE);
  2292.                         dati.add(de);
  2293.                     
  2294.                         de = new DataElement();
  2295.                         de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_IS_DEFINED+contatoreServizio);
  2296.                         de.setType(DataElementType.HIDDEN);
  2297.                         de.setValue(CostantiConfigurazione.ABILITATO.toString());
  2298.                         dati.add(de);   
  2299.     
  2300.                         String nomeFieldServizio = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE+contatoreServizio;
  2301.                         de = new DataElement();
  2302.                         de.setName(nomeFieldServizio);
  2303.                         de.setType(DataElementType.TEXT_EDIT);
  2304.                         if(ptOpenSPCoop!=null)
  2305.                             de.setValue(ptOpenSPCoop.getNome());
  2306.                         else
  2307.                             de.setValue(ptWSDL.getNome());
  2308.                         de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE);
  2309.                         de.setSize(this.getSize());
  2310.                         dati.add(de);                       
  2311.                         contatoreServizio++;
  2312.     
  2313.                         //System.out.println("        PortType="+pt.getQName().toString()+" ("+pt.getOperations().size()+" operations)");
  2314.                         int contatoreAzione = 1;
  2315.                         for (Operation opWSDL : ptWSDL.getAzioneList()) {
  2316.                             
  2317.                             Operation opOpenSPCoop = null;
  2318.                             if(ptOpenSPCoop!=null){
  2319.                                 if(ptOpenSPCoop.sizeAzioneList()>=contatoreAzione){
  2320.                                     opOpenSPCoop = ptOpenSPCoop.getAzione((contatoreAzione-1));
  2321.                                 }
  2322.                             }
  2323.     
  2324.                             de = new DataElement();
  2325.                             de.setType(DataElementType.SUBTITLE);
  2326.                             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_OPERATION_TITLE.
  2327.                                     replace(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_OPERATION_TITLE_KEY, opWSDL.getNome()));
  2328.                             de.setSize(this.getSize());
  2329.                             dati.add(de);

  2331.                             de = new DataElement();
  2332.                             de.setName(nomeFieldServizio+
  2333.                                     ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_IS_DEFINED+contatoreAzione);
  2334.                             de.setType(DataElementType.HIDDEN);
  2335.                             de.setValue(CostantiConfigurazione.ABILITATO.toString());
  2336.                             dati.add(de);   
  2337.                             
  2338.                             de = new DataElement();
  2339.                             de.setName(nomeFieldServizio+
  2340.                                     ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION+contatoreAzione);
  2341.                             de.setType(DataElementType.TEXT_EDIT);
  2342.                             if(opOpenSPCoop!=null)
  2343.                                 de.setValue(opOpenSPCoop.getNome());
  2344.                             else
  2345.                                 de.setValue(opWSDL.getNome());
  2346.                             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION);
  2347.                             de.setSize(this.getSize());
  2348.                             dati.add(de);
  2349.     
  2350.                             String profiloCollaborazione = null;
  2351.                             if(opOpenSPCoop!=null){
  2352.                                 if(opOpenSPCoop.getProfiloCollaborazione()!=null){
  2353.                                     profiloCollaborazione = opOpenSPCoop.getProfiloCollaborazione().toString();
  2354.                                 }
  2355.                             }else{
  2356.                                 if(opWSDL.getProfiloCollaborazione()!=null){
  2357.                                     profiloCollaborazione = opWSDL.getProfiloCollaborazione().toString();
  2358.                                 }
  2359.                             }
  2360.     
  2361.                             de = new DataElement();
  2362.                             de.setName(nomeFieldServizio+
  2363.                                     ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_PROFILO+contatoreAzione);
  2364.                             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_PROFILO);
  2365.                             de.setType(DataElementType.SELECT);
  2366.                             de.setValues(this.core.getProfiliDiCollaborazioneSupportatiDalProtocollo(protocolloAccordo,serviceBinding));
  2367.                             de.setSelected(profiloCollaborazione);
  2368.                             if(this.archiviCore.isShowCorrelazioneAsincronaInAccordi()){
  2369.                                 de.setPostBack(true);
  2370.                             }
  2371.                             dati.add(de);
  2372.     
  2373.                             if( AccordiServizioParteComuneCostanti.TIPO_PROFILO_COLLABORAZIONE_ASINCRONO_ASIMMETRICO.equals(profiloCollaborazione) || 
  2374.                                     AccordiServizioParteComuneCostanti.TIPO_PROFILO_COLLABORAZIONE_ASINCRONO_SIMMETRICO.equals(profiloCollaborazione)  ){
  2375.                                     
  2376.                                 de = new DataElement();
  2377.                                 de.setName(nomeFieldServizio+
  2378.                                         ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_SERVIZIO_CORRELATO+contatoreAzione);
  2379.                                 de.setType(DataElementType.TEXT_EDIT);
  2380.                                 if(opOpenSPCoop!=null && opOpenSPCoop.getCorrelataServizio()!=null)
  2381.                                     de.setValue(opOpenSPCoop.getCorrelataServizio());
  2382.                                 else
  2383.                                     de.setValue("");
  2384.                                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_SERVIZIO_CORRELATO);
  2385.                                 de.setSize(this.getSize());
  2386.                                 dati.add(de);

  2388.                                 de = new DataElement();
  2389.                                 de.setName(nomeFieldServizio+
  2390.                                         ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_CORRELATA+contatoreAzione);
  2391.                                 de.setType(DataElementType.TEXT_EDIT);
  2392.                                 if(opOpenSPCoop!=null && opOpenSPCoop.getCorrelata()!=null)
  2393.                                     de.setValue(opOpenSPCoop.getCorrelata());
  2394.                                 else
  2395.                                     de.setValue("");
  2396.                                 de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT_PORT_TYPE_OPERATION_CORRELATA);
  2397.                                 de.setSize(this.getSize());
  2398.                                 dati.add(de);

  2400.                             }
  2401.     
  2402.                             contatoreAzione++;
  2403.     
  2404.                         }
  2405.                     }
  2406.                 }
  2407.                 else{
  2408.                     throw new Exception("Informazioni di protocollo non definite e i wsdl presenti all'interno dell'archivio non possiedeno nemmeno un port type");
  2409.                 }
  2410.             }
  2411.     
  2412.         }
  2413.         else{
  2414.             de = new DataElement();
  2415.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT);
  2416.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT);
  2417.             de.setType(DataElementType.HIDDEN);
  2418.             de.setValue("");
  2419.             dati.add(de);
  2420.         }
  2421.         
  2422.         
  2423.         
  2424.         
  2425.         
  2426.         // servizi parte comune
  2427.         
  2428.         if ( importInformationMissingException!=null && importInformationMissingException.isMismatchPortTypeRifServiziParteComune() ){
  2429.             
  2430.             if(showSection){
  2431.                 de = new DataElement();
  2432.                 de.setLabel(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PORT_TYPE_RIFERITO);
  2433.                 de.setType(DataElementType.TITLE);
  2434.                 dati.add(de);
  2435.             }
  2436.             
  2437.             if ( importInformationMissingException.getMissingInfoHeader()!=null ){
  2438.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoHeader() );
  2439.             }
  2440.             
  2441.             de = new DataElement();
  2442.             de.setType(DataElementType.NOTE);
  2443.             de.setValue(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PORT_TYPE_RIFERITO_MESSAGGIO.
  2444.                     replace(ArchiviCostanti.LABEL_IMPORT_ERROR_INFORMAZIONI_PORT_TYPE_RIFERITO_MESSAGGIO_KEY, 
  2445.                             importInformationMissingException.getMismatchPortTypeRifServiziParteComune_nome()));
  2446.             dati.add(de);
  2447.             
  2448.             de = new DataElement();
  2449.             de.setLabel(ArchiviCostanti.LABEL_PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_PORT_TYPE_IMPLEMENTED_INPUT);
  2450.             de.setType(DataElementType.SELECT);
  2451.             List<String> listServizi = new ArrayList<>();
  2452.             listServizi.add(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED);
  2453.             listServizi.addAll(importInformationMissingException.getMismatchPortTypeRifServiziParteComune_serviziParteComune());
  2454.             de.setValues(listServizi);
  2455.             de.setSelected(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED);
  2456.             de.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_PORT_TYPE_IMPLEMENTED_INPUT);
  2457.             dati.add(de);

  2459.             if ( importInformationMissingException.getMissingInfoFooter()!=null ){
  2460.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoFooter() );
  2461.             }
  2462.         }
  2463.         
  2464.         
  2465.         
  2466.         
  2467.         
  2468.         // invocazioneServizio
  2469.         
  2470.         if( importInformationMissingException!=null && importInformationMissingException.isMissingInfoInvocazioneServizio() ){
  2471.             
  2472.             if ( importInformationMissingException.getMissingInfoHeader()!=null ){
  2473.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoHeader() );
  2474.             }
  2475.             
  2476.             InterfaceType originalInterfaceType = null;
  2477.             User userSession = null;
  2478.             try{
  2479.                 
  2480.                 // Impostazione protocollo
  2481.                 String protocollo = importInformationMissingException.getMissingInfoProtocollo();
  2482.                 if(protocollo==null){
  2483.                     protocollo = protocolloEffettivo; // uso l'impostazione associata al tipo in package scelto.
  2484.                     // NOTA: non devo impostare il protocollo. Serve solo per visualizzare l'info "Sbustamento Info Protocollo 'xxx'"
  2485.                     // Se viene passato null non viene visualizzata la stringa 'xxx'.
  2486.                     // Meglio cosi che fornire il tipo associato al package, che puo' non essere corretto nel casi di archivio openspcoop
  2487.                     // che contiene diversi protocolli (e nella select list dei protocolli non e' stato scelto alcun protocollo)
  2488.                 }
  2489.                 
  2490.                 InterfaceType interfaceType = InterfaceType.STANDARD; 
  2491.                 TipologiaConnettori tipologiaConnettori = null;
  2492.                 
  2493.                 Default defaultProperties = importInformationMissingException.getMissingInfoDefault();
  2494.                 if(defaultProperties!=null && defaultProperties.sizeProprietaList()>0) {
  2495.                     for (ProprietaDefault p : defaultProperties.getProprietaList()) {
  2496.                         if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_MODALIA_INTERFACCIA.equalsIgnoreCase(p.getNome())) {
  2497.                             if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_MODALIA_INTERFACCIA_STANDARD.equalsIgnoreCase(p.getValore())) {
  2498.                                 interfaceType = InterfaceType.STANDARD; 
  2499.                             }
  2500.                             else if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_MODALIA_INTERFACCIA_AVANZATA.equalsIgnoreCase(p.getValore())) {
  2501.                                 interfaceType = InterfaceType.AVANZATA; 
  2502.                             }
  2503.                         }
  2504.                         else if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_TIPO_CONNETTORE.equalsIgnoreCase(p.getNome())) {
  2505.                             if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_TIPO_CONNETTORE_HTTP.equalsIgnoreCase(p.getValore())) {
  2506.                                 tipologiaConnettori = TipologiaConnettori.TIPOLOGIA_CONNETTORI_HTTP; 
  2507.                             }
  2508.                             else if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_TIPO_CONNETTORE_QUALSIASI.equalsIgnoreCase(p.getValore())) {
  2509.                                 tipologiaConnettori = TipologiaConnettori.TIPOLOGIA_CONNETTORI_ALL; 
  2510.                             }
  2511.                         }
  2512.                     }
  2513.                 }
  2514.                 
  2515.                 userSession = ServletUtils.getUserFromSession(this.request, this.session);
  2516.                 originalInterfaceType = userSession.getInterfaceType();
  2517.                 // forzo standard
  2518.                 userSession.setInterfaceType(interfaceType);
  2519.                 // this.setTipoInterfaccia(interfaceType);
  2520.             
  2521.                 String sbustamento = null;
  2522.                 String sbustamentoInformazioniProtocolloRichiesta = null;
  2523.                 String getmsg = null;
  2524.                 String getmsgUsername = null;
  2525.                 String getmsgPassword = null;
  2526.                 
  2527.                 // gestito nel metodo getParameter: if(readedDatiConnettori==false){
  2528.                 sbustamento = this.getParameter(readedDatiConnettori,defaultProperties,ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  2529.                 sbustamentoInformazioniProtocolloRichiesta = this.getParameter(readedDatiConnettori,defaultProperties,ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RICHIESTA);
  2530.                 getmsg = this.getParameter(readedDatiConnettori,defaultProperties,ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  2531.                 getmsgUsername = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  2532.                 getmsgPassword = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  2533.                 //}
  2534.                 boolean erogazioneServizioApplicativoServerEnabled = false;
  2535.                 boolean integrationManagerEnabled = !this.isModalitaStandard() && this.archiviCore.isIntegrationManagerEnabled();
  2536.                 boolean postBackViaPost = true;
  2537.                 this.addEndPointToDati(dati,"","",sbustamento,sbustamentoInformazioniProtocolloRichiesta,
  2538.                         getmsg,getmsgUsername,getmsgPassword,true,
  2539.                         null,null,protocollo,false,true, showSection, null,null, null, erogazioneServizioApplicativoServerEnabled,
  2540.                         null, false,
  2541.                         integrationManagerEnabled,
  2542.                         TipoOperazione.ADD, null, null,
  2543.                         postBackViaPost);
  2544.                             
  2545.                 boolean forceEnabled = true; // non ha senso non fornire un connettore a meno che non vi sia la possibilita' di utilizzare l'integration manager
  2546.                 boolean showSectionTitle = false;
  2547.                 if(InterfaceType.STANDARD.equals(interfaceType)==false) {
  2548.                     showSectionTitle = true;
  2549.                     
  2550.                     if( getmsg!=null && CostantiConfigurazione.ABILITATO.toString().equals(getmsg) ) {
  2551.                         forceEnabled = false;
  2552.                     }
  2553.                     else {
  2554.                         forceEnabled = true;
  2555.                     }
  2556.                     
  2557.                 }

  2559.                 addDatiConnettore(dati, serviceBinding, readedDatiConnettori, importInformationMissingException.getMissingInfoDefault(), showSectionTitle, 
  2560.                         ConnettoreServletType.WIZARD_CONFIG, forceEnabled, tipologiaConnettori);
  2561.             }
  2562.             finally{
  2563.                 // ripristino originale
  2564.                 if(userSession!=null)
  2565.                     userSession.setInterfaceType(originalInterfaceType);
  2566.             }
  2567.             
  2568.             if ( importInformationMissingException.getMissingInfoFooter()!=null ){
  2569.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoFooter() );
  2570.             }
  2571.         }
  2572.         
  2573.         
  2574.         
  2575.         // connettore
  2576.         
  2577.         if( importInformationMissingException!=null && importInformationMissingException.isMissingInfoConnettore() ){
  2578.             
  2579.             if ( importInformationMissingException.getMissingInfoHeader()!=null ){
  2580.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoHeader() );
  2581.             }
  2582.             
  2583.             InterfaceType originalInterfaceType = null;
  2584.             User userSession = null;
  2585.             try{
  2586.                 InterfaceType interfaceType = InterfaceType.STANDARD; 
  2587.                 TipologiaConnettori tipologiaConnettori = null;
  2588.                 
  2589.                 Default defaultProperties = importInformationMissingException.getMissingInfoDefault();
  2590.                 if(defaultProperties!=null && defaultProperties.sizeProprietaList()>0) {
  2591.                     for (ProprietaDefault p : defaultProperties.getProprietaList()) {
  2592.                         if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_MODALIA_INTERFACCIA.equalsIgnoreCase(p.getNome())) {
  2593.                             if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_MODALIA_INTERFACCIA_STANDARD.equalsIgnoreCase(p.getValore())) {
  2594.                                 interfaceType = InterfaceType.STANDARD; 
  2595.                             }
  2596.                             else if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_MODALIA_INTERFACCIA_AVANZATA.equalsIgnoreCase(p.getValore())) {
  2597.                                 interfaceType = InterfaceType.AVANZATA; 
  2598.                             }
  2599.                         }
  2600.                         else if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_TIPO_CONNETTORE.equalsIgnoreCase(p.getNome())) {
  2601.                             if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_TIPO_CONNETTORE_HTTP.equalsIgnoreCase(p.getValore())) {
  2602.                                 tipologiaConnettori = TipologiaConnettori.TIPOLOGIA_CONNETTORI_HTTP; 
  2603.                             }
  2604.                             else if(ArchiviCostanti.DEFAULT_PROPERTY_INFORMATION_MISSING_TIPO_CONNETTORE_QUALSIASI.equalsIgnoreCase(p.getValore())) {
  2605.                                 tipologiaConnettori = TipologiaConnettori.TIPOLOGIA_CONNETTORI_ALL; 
  2606.                             }
  2607.                         }
  2608.                     }
  2609.                 }
  2610.                 
  2611.                 userSession = ServletUtils.getUserFromSession(this.request, this.session);
  2612.                 originalInterfaceType = userSession.getInterfaceType();
  2613.                 // forzo standard
  2614.                 userSession.setInterfaceType(interfaceType);
  2615.                 // this.setTipoInterfaccia(interfaceType);

  2617.                 boolean forceEnabled = true; // non ha senso non fornire un connettore
  2618.                 
  2619.                 addDatiConnettore(dati, serviceBinding, readedDatiConnettori, importInformationMissingException.getMissingInfoDefault(), showSection, 
  2620.                         ConnettoreServletType.WIZARD_REGISTRY, forceEnabled, tipologiaConnettori);
  2621.             }
  2622.             finally{
  2623.                 // ripristino originale
  2624.                 if(userSession!=null)
  2625.                     userSession.setInterfaceType(originalInterfaceType);
  2626.             }
  2627.             
  2628.             if ( importInformationMissingException.getMissingInfoFooter()!=null ){
  2629.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoFooter() );
  2630.             }
  2631.         }
  2632.         
  2633.         
  2634.         
  2635.         // credenziali
  2636.         
  2637.         if( importInformationMissingException!=null && importInformationMissingException.isMissingInfoCredenziali() ){
  2638.             
  2639.             if ( importInformationMissingException.getMissingInfoHeader()!=null ){
  2640.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoHeader() );
  2641.             }
  2642.             
  2643.             InterfaceType originalInterfaceType = null;
  2644.             User userSession = null;
  2645.             try{
  2646.                 userSession = ServletUtils.getUserFromSession(this.request, this.session);
  2647.                 originalInterfaceType = userSession.getInterfaceType();
  2648.                 // forzo standard
  2649.                 userSession.setInterfaceType(InterfaceType.STANDARD);
  2650.             //  this.setTipoInterfaccia(InterfaceType.STANDARD);
  2651.             
  2652.                 this.addDatiCredenzialiAccesso(dati, readedDatiConnettori, importInformationMissingException.getMissingInfoDefault(), showSection);
  2653.             }
  2654.             finally{
  2655.                 // ripristino originale
  2656.                 if(userSession!=null)
  2657.                     userSession.setInterfaceType(originalInterfaceType);
  2658.             }
  2659.             
  2660.             if ( importInformationMissingException.getMissingInfoFooter()!=null ){
  2661.                 this.addDescriptionInformationMissingToDati(dati,  importInformationMissingException.getMissingInfoFooter() );
  2662.             }
  2663.         }
  2664.     }
  2665.     
  2666.     private void addDescriptionInformationMissingToDati(List<DataElement> dati, Description header) {
  2667.         
  2668.         for (DescriptionType item : header.getItemList()) {
  2669.             DataElement de = new DataElement();
  2670.             switch (item.getTipo()) {
  2671.             case TITLE:
  2672.                 de.setType(DataElementType.TITLE);
  2673.                 break;
  2674.             case SUBTITLE:
  2675.                 de.setType(DataElementType.SUBTITLE);
  2676.                 break;
  2677.             case NOTE:
  2678.                 de.setType(DataElementType.NOTE);
  2679.                 break;
  2680.             case TEXT:
  2681.                 de.setType(DataElementType.TEXT);
  2682.                 break;
  2683.             }
  2684.             if(item.getLabel()!=null) {
  2685.                 de.setLabel(item.getLabel());
  2686.             }
  2687.             if(item.getValore()!=null) {
  2688.                 de.setValue(item.getValore());
  2689.             }
  2690.             if(item.isBold()) {
  2691.                 de.setBold(true);
  2692.             }
  2693.             dati.add(de);
  2694.         }

  2696.     }
  2697.     
  2698.     private void addDatiCredenzialiAccesso(List<DataElement> dati, boolean readedDatiConnettori, Default defaultProperties, boolean showSectionTitle) throws Exception{
  2699.                 
  2700.         String tipoauth = null;
  2701.         String utente = null;
  2702.         String password  = null;
  2703.         String subject = null;
  2704.         String principal = null;
  2705.         String tipoCredenzialiSSLSorgente = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL);
  2706.         if(tipoCredenzialiSSLSorgente == null) {
  2707.             tipoCredenzialiSSLSorgente = ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE;
  2708.         }
  2709.         String tipoCredenzialiSSLTipoArchivioS = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_TIPO_ARCHIVIO);
  2710.         BinaryParameter tipoCredenzialiSSLFileCertificato = this.getBinaryParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO);
  2711.         List<String> listaAliasEstrattiCertificato = new ArrayList<>();
  2712.         String tipoCredenzialiSSLFileCertificatoPassword = this.getParameter(readedDatiConnettori, defaultProperties, ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO_PASSWORD);
  2713.         String tipoCredenzialiSSLAliasCertificato = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO);
  2714.         String tipoCredenzialiSSLAliasCertificatoSubject= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_SUBJECT);
  2715.         String tipoCredenzialiSSLAliasCertificatoIssuer= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_ISSUER);
  2716.         String tipoCredenzialiSSLAliasCertificatoType= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_TYPE);
  2717.         String tipoCredenzialiSSLAliasCertificatoVersion= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_VERSION);
  2718.         String tipoCredenzialiSSLAliasCertificatoSerialNumber= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_SERIAL_NUMBER);
  2719.         String tipoCredenzialiSSLAliasCertificatoSelfSigned= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_SELF_SIGNED);
  2720.         String tipoCredenzialiSSLAliasCertificatoNotBefore= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_NOT_BEFORE);
  2721.         String tipoCredenzialiSSLAliasCertificatoNotAfter =this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_NOT_AFTER); 
  2722.         String tipoCredenzialiSSLVerificaTuttiICampi = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI);
  2723.         String tipoCredenzialiSSLConfigurazioneManualeSelfSigned= this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_MANUALE_SELF_SIGNED);
  2724.         String issuer = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_ISSUER);   
  2725.         String tipoCredenzialiSSLStatoElaborazioneCertificato = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_WIZARD_STEP);
  2726.         if (tipoCredenzialiSSLStatoElaborazioneCertificato == null) {
  2727.             tipoCredenzialiSSLStatoElaborazioneCertificato = ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_NO_WIZARD_ARCHIVI;
  2728.         }
  2729.         //String oldTipoCredenzialiSSLStatoElaborazioneCertificato = tipoCredenzialiSSLStatoElaborazioneCertificato;
  2730.         
  2731.         // gestito nel metodo getParameter: if(readedDatiConnettori==false){
  2732.         tipoauth = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE);
  2733.         if (tipoauth == null) {
  2734.             tipoauth = ConnettoriCostanti.DEFAULT_AUTENTICAZIONE_TIPO;
  2735.         }
  2736.         utente = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  2737.         password = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  2738.         subject = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_SUBJECT);
  2739.         principal = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PRINCIPAL);
  2740.         
  2741.         String changepwd = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CHANGE_PASSWORD);
  2742.         
  2743.         String multipleApiKey = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_MULTIPLE_API_KEYS);
  2744.         String appId = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  2745.         String apiKey = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY);
  2746.         
  2747.         String tokenPolicySA = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_POLICY);
  2748.         String tokenClientIdSA = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_CLIENT_ID);
  2749.         
  2750.         boolean tokenWithHttpsEnabledByConfigSA = false;
  2751.         if(tipoauth!=null && !StringUtils.isEmpty(tokenPolicySA)) {
  2752.             boolean tokenByPDND = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(tipoauth);
  2753.             tokenWithHttpsEnabledByConfigSA = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH.equals(tipoauth);
  2754.             if(tokenWithHttpsEnabledByConfigSA) {
  2755.                 tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL;
  2756.             }
  2757.             boolean tokenModiPDNDOauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_OAUTH.equals(tipoauth);
  2758.             if(tokenModiPDNDOauth) {
  2759.                 tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN;
  2760.             }
  2761.             if(tokenPolicySA==null || StringUtils.isEmpty(tokenPolicySA) || CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals(tokenPolicySA)) {
  2762.                 if(tokenByPDND) {
  2763.                     tokenPolicySA = this.saCore.getDefaultPolicyGestioneTokenPDND();
  2764.                 }
  2765.             }
  2766.             else {
  2767.                 if(!tokenByPDND && (tokenWithHttpsEnabledByConfigSA || tokenModiPDNDOauth) && this.saCore.isPolicyGestioneTokenPDND(tokenPolicySA)) {
  2768.                     tokenPolicySA=null;
  2769.                 }
  2770.                 else if(tokenByPDND && !this.saCore.isPolicyGestioneTokenPDND(tokenPolicySA)) {
  2771.                     tokenPolicySA = this.saCore.getDefaultPolicyGestioneTokenPDND();
  2772.                 }
  2773.             }
  2774.         }
  2775.         
  2776.         if(tipoauth==null || tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)){
  2777.             tipoauth = this.saCore.getAutenticazione_generazioneAutomaticaPorteDelegate();
  2778.         } 
  2779.             
  2780.         // Credenziali di accesso
  2781.         if (utente == null) {
  2782.             utente = "";
  2783.         }
  2784.         if (password == null) {
  2785.             password = "";
  2786.         }
  2787.         if (subject == null) {
  2788.             subject = "";
  2789.         }
  2790.         if (principal == null) {
  2791.             principal = "";
  2792.         }
  2793.         if (issuer == null) {
  2794.             issuer = "";
  2795.         }
  2796.         org.openspcoop2.utils.certificate.ArchiveType tipoCredenzialiSSLTipoArchivio= null;
  2797.         if(tipoCredenzialiSSLTipoArchivioS == null) {
  2798.             tipoCredenzialiSSLTipoArchivio = org.openspcoop2.utils.certificate.ArchiveType.CER; 
  2799.         } else {
  2800.             tipoCredenzialiSSLTipoArchivio = org.openspcoop2.utils.certificate.ArchiveType.valueOf(tipoCredenzialiSSLTipoArchivioS);
  2801.         }
  2802.         if (tipoCredenzialiSSLConfigurazioneManualeSelfSigned == null) {
  2803.             tipoCredenzialiSSLConfigurazioneManualeSelfSigned = Costanti.CHECK_BOX_DISABLED;
  2804.         }
  2805.         if (tipoCredenzialiSSLVerificaTuttiICampi == null) {
  2806.             tipoCredenzialiSSLVerificaTuttiICampi = ConnettoriCostanti.DEFAULT_VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI;
  2807.         }
  2808.         if (tipoCredenzialiSSLAliasCertificato == null) {
  2809.             tipoCredenzialiSSLAliasCertificato = "";
  2810.         }
  2811.         
  2812.         // Parametri  accesso alla lista credenziali certificati impostati per nascondere il link.
  2813.         boolean visualizzaModificaCertificato = false;
  2814.         boolean visualizzaAddCertificato = false;
  2815.         String servletCredenzialiList = null;
  2816.         List<Parameter> parametersServletCredenzialiList = null;
  2817.         Integer numeroCertificati = null;
  2818.         String servletCredenzialiAdd = null;
  2819.         
  2820.         // controllo dei postback
  2821.         
  2822.         boolean postBackViaPost = false;
  2823.         
  2824.         //}true,endpointtype,true,false, prefix, true
  2825.         this.addCredenzialiToDati(TipoOperazione.OTHER, dati, tipoauth, null, utente, password, subject, principal,
  2826.                 ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ADD, showSectionTitle, null, false, true, null, true, 
  2827.                 tipoCredenzialiSSLSorgente, tipoCredenzialiSSLTipoArchivio, tipoCredenzialiSSLFileCertificato, tipoCredenzialiSSLFileCertificatoPassword, listaAliasEstrattiCertificato, 
  2828.                 tipoCredenzialiSSLAliasCertificato, tipoCredenzialiSSLAliasCertificatoSubject, tipoCredenzialiSSLAliasCertificatoIssuer,
  2829.                 tipoCredenzialiSSLAliasCertificatoType, tipoCredenzialiSSLAliasCertificatoVersion, tipoCredenzialiSSLAliasCertificatoSerialNumber, 
  2830.                 tipoCredenzialiSSLAliasCertificatoSelfSigned, tipoCredenzialiSSLAliasCertificatoNotBefore, tipoCredenzialiSSLAliasCertificatoNotAfter, 
  2831.                 tipoCredenzialiSSLVerificaTuttiICampi, tipoCredenzialiSSLConfigurazioneManualeSelfSigned, issuer, tipoCredenzialiSSLStatoElaborazioneCertificato,
  2832.                 changepwd, 
  2833.                 multipleApiKey, appId, apiKey, 
  2834.                 visualizzaModificaCertificato, visualizzaAddCertificato, servletCredenzialiList, parametersServletCredenzialiList, numeroCertificati, servletCredenzialiAdd,
  2835.                 false, tokenPolicySA, tokenClientIdSA, tokenWithHttpsEnabledByConfigSA,
  2836.                 false, null,
  2837.                 postBackViaPost); 
  2838.     }
  2839.     
  2840.     private void addDatiConnettore(List<DataElement> dati, ServiceBinding serviceBinding, boolean readedDatiConnettori, Default defaultProperties,
  2841.             boolean showSectionTitle,ConnettoreServletType connettoreServletType,
  2842.             boolean forceEnabled, TipologiaConnettori tipologiaConnettoriInfoMissing) throws Exception{
  2843.         
  2844.         TipologiaConnettori tipologiaConnettoriOriginale = null;
  2845.         try{
  2846.             tipologiaConnettoriOriginale = Utilities.getTipologiaConnettori(this.core);
  2847.             if(tipologiaConnettoriInfoMissing!=null) {
  2848.                 Utilities.setTipologiaConnettori(tipologiaConnettoriInfoMissing);
  2849.             }
  2850.             else {
  2851.                 Utilities.setTipologiaConnettori(TipologiaConnettori.TIPOLOGIA_CONNETTORI_HTTP);
  2852.             }
  2853.         
  2854.             String endpointtype = null;
  2855.             String tipoconn = null;
  2856.             String autenticazioneHttp = null;
  2857.             String user = null;
  2858.             String password = null;
  2859.             
  2860.             String connettoreDebug = null;
  2861.             
  2862.             // http
  2863.             String url = null;
  2864.             
  2865.             // jms
  2866.             String nomeCodaJMS = null;
  2867.             String tipo = null;
  2868.             String initcont = null;
  2869.             String urlpgk = null;
  2870.             String provurl = null;
  2871.             String connfact = null;
  2872.             String sendas = null;
  2873.             
  2874.             // https
  2875.             String httpsurl = null;
  2876.             String httpstipologia = null;
  2877.             String httpshostverifyS = null;
  2878.             boolean httpsTrustVerifyCert = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS;
  2879.             String httpspath = null;
  2880.             String httpstipo = null;
  2881.             String httpspwd = null;
  2882.             String httpsalgoritmo = null;
  2883.             String httpsstatoS = null;
  2884.             String httpskeystore = null;
  2885.             String httpspwdprivatekeytrust = null;
  2886.             String httpspathkey = null;
  2887.             String httpstipokey = null;
  2888.             String httpspwdkey = null;
  2889.             String httpspwdprivatekey = null;
  2890.             String httpsalgoritmokey = null;
  2891.             String httpsKeyAlias = null;
  2892.             String httpsTrustStoreCRLs = null;
  2893.             String httpsTrustStoreOCSPPolicy = null;
  2894.             String httpsKeyStoreBYOKPolicy = null;
  2895.             
  2896.             boolean httpshostverify = false;
  2897.             boolean httpsstato = false;
  2898.             
  2899.             String proxyEnabled = null;
  2900.             String proxyHostname = null;
  2901.             String proxyPort = null;
  2902.             String proxyUsername = null;
  2903.             String proxyPassword = null;
  2904.             
  2905.             String tempiRispostaEnabled = null;
  2906.             String tempiRispostaConnectionTimeout = null; 
  2907.             String tempiRispostaReadTimeout = null;
  2908.             String tempiRispostaTempoMedioRisposta = null;
  2909.             
  2910.             String transferMode = null;
  2911.             String transferModeChunkSize = null;
  2912.             String redirectMode = null;
  2913.             String redirectMaxHop = null;
  2914.             String opzioniAvanzate = null;
  2915.             
  2916.             // file
  2917.             String requestOutputFileName = null;
  2918.             String requestOutputFileNamePermissions = null;
  2919.             String requestOutputFileNameHeaders = null;
  2920.             String requestOutputFileNameHeadersPermissions = null;
  2921.             String requestOutputParentDirCreateIfNotExists = null;
  2922.             String requestOutputOverwriteIfExists = null;
  2923.             String responseInputMode = null;
  2924.             String responseInputFileName = null;
  2925.             String responseInputFileNameHeaders = null;
  2926.             String responseInputDeleteAfterRead = null;
  2927.             String responseInputWaitTime = null;

  2929.             
  2930.             /** NON POSSO USARE QUESTO METODO, SENNO NON LEGGO I PARMETRI DI DEFAULT: endpointtype = this.readEndPointType(); */
  2931.             endpointtype = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE);
  2932.             String endpointtypeCheck = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE_CHECK);
  2933.             String endpointtypeSsl = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE_ENABLE_HTTPS);
  2934.             endpointtype = this.readEndPointType(endpointtype, endpointtypeCheck, endpointtypeSsl);
  2935.             if(endpointtype==null || (forceEnabled && TipiConnettore.DISABILITATO.getNome().equals(endpointtype)) ){
  2936.                 endpointtype = TipiConnettore.HTTP.toString();
  2937.             }
  2938.             tipoconn = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_TIPO_PERSONALIZZATO);
  2939.             autenticazioneHttp = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE_ENABLE_HTTP);
  2940.             
  2941.             connettoreDebug = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_DEBUG);
  2942.                         
  2943.             // token policy
  2944.             String autenticazioneTokenS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TOKEN_POLICY_STATO);
  2945.             boolean autenticazioneToken = ServletUtils.isCheckBoxEnabled(autenticazioneTokenS);
  2946.             String tokenPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_TOKEN_POLICY);
  2947.             boolean forcePDND = false;
  2948.             boolean forceOAuth = false;
  2949.             
  2950.             // proxy
  2951.             proxyEnabled = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_ENABLED);
  2952.             proxyHostname = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_HOSTNAME);
  2953.             proxyPort = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_PORT);
  2954.             proxyUsername = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_USERNAME);
  2955.             proxyPassword = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_PROXY_PASSWORD);
  2956.             
  2957.             // tempi risposta
  2958.             tempiRispostaEnabled = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_REDEFINE);
  2959.             tempiRispostaConnectionTimeout = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_CONNECTION_TIMEOUT);
  2960.             tempiRispostaReadTimeout = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_READ_TIMEOUT);
  2961.             tempiRispostaTempoMedioRisposta = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_TEMPI_RISPOSTA_TEMPO_MEDIO_RISPOSTA);
  2962.             
  2963.             // opzioni avanzate
  2964.             transferMode = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_TRANSFER_MODE);
  2965.             transferModeChunkSize = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_TRANSFER_CHUNK_SIZE);
  2966.             redirectMode = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_REDIRECT_MODE);
  2967.             redirectMaxHop = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_OPZIONI_AVANZATE_REDIRECT_MAX_HOP);
  2968.             opzioniAvanzate = ConnettoriHelper.getOpzioniAvanzate(this, transferMode, redirectMode);
  2969.             
  2970.             // http
  2971.             url = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_URL);
  2972.             if(TipiConnettore.HTTP.toString().equals(endpointtype)){
  2973.                 user = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  2974.                 password = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  2975.             }
  2976.             
  2977.             // api key
  2978.             String autenticazioneApiKey = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_ENDPOINT_TYPE_ENABLE_API_KEY);
  2979.             String apiKeyHeader = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_HEADER);
  2980.             if(apiKeyHeader==null || StringUtils.isEmpty(apiKeyHeader)) {
  2981.                 apiKeyHeader = CostantiConnettori.DEFAULT_HEADER_API_KEY;
  2982.             }
  2983.             String apiKeyValue = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_VALUE);
  2984.             String appIdHeader = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_APP_ID_HEADER);
  2985.             if(appIdHeader==null || StringUtils.isEmpty(appIdHeader)) {
  2986.                 appIdHeader = CostantiConnettori.DEFAULT_HEADER_APP_ID;
  2987.             }
  2988.             String appIdValue = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_APP_ID_VALUE);
  2989.             String useOAS3NamesTmp = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_NOMI_OAS);
  2990.             boolean useOAS3Names=true;
  2991.             if(useOAS3NamesTmp!=null && StringUtils.isNotEmpty(useOAS3NamesTmp)) {
  2992.                 useOAS3Names = ServletUtils.isCheckBoxEnabled(useOAS3NamesTmp);
  2993.             }
  2994.             else {
  2995.                 useOAS3Names = this.isAutenticazioneApiKeyUseOAS3Names(apiKeyHeader, appIdHeader);
  2996.             }
  2997.             String useAppIdTmp = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_API_KEY_USE_APP_ID);
  2998.             boolean useAppId=false;
  2999.             if(useAppIdTmp!=null && StringUtils.isNotEmpty(useAppIdTmp)) {
  3000.                 useAppId = ServletUtils.isCheckBoxEnabled(useAppIdTmp);
  3001.             }
  3002.             else {
  3003.                 useAppId = this.isAutenticazioneApiKeyUseAppId(appIdValue);
  3004.             }
  3005.             
  3006.             // jms
  3007.             nomeCodaJMS = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_NOME_CODA);
  3008.             tipo = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_TIPO_CODA);
  3009.             initcont = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_INIT_CTX);
  3010.             urlpgk = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_URL_PKG);
  3011.             provurl = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_PROVIDER_URL);
  3012.             connfact = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_CONNECTION_FACTORY);
  3013.             sendas = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_TIPO_OGGETTO_JMS);
  3014.             if(TipiConnettore.JMS.toString().equals(endpointtype)){
  3015.                 user = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_USERNAME);
  3016.                 password = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_JMS_PASSWORD);
  3017.             }
  3018.             
  3019.             // https
  3020.             httpsurl = url;
  3021.             httpstipologia = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  3022.             httpshostverifyS = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  3023.             httpshostverify = ServletUtils.isCheckBoxEnabled(httpshostverifyS);
  3024.             String httpsTrustVerifyCertS = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS );
  3025.             httpsTrustVerifyCert = ServletUtils.isCheckBoxEnabled(httpsTrustVerifyCertS);
  3026.             httpspath = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  3027.             httpstipo = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  3028.             httpspwd = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  3029.             httpsalgoritmo = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  3030.             httpsstatoS = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_STATO);
  3031.             httpsstato = ServletUtils.isCheckBoxEnabled(httpsstatoS);
  3032.             httpskeystore = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  3033.             httpspwdprivatekeytrust = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  3034.             httpspathkey = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  3035.             httpstipokey = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  3036.             httpspwdkey = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  3037.             httpspwdprivatekey = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  3038.             httpsalgoritmokey = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  3039.             httpsKeyAlias = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  3040.             httpsTrustStoreCRLs = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  3041.             httpsTrustStoreOCSPPolicy = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  3042.             httpsKeyStoreBYOKPolicy = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  3043.             if(TipiConnettore.HTTPS.toString().equals(endpointtype)){
  3044.                 user = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  3045.                 password = this.getLockedParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  3046.             }
  3047.             
  3048.             // file
  3049.             requestOutputFileName = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME);
  3050.             requestOutputFileNamePermissions = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_PERMISSIONS);
  3051.             requestOutputFileNameHeaders = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_HEADERS);
  3052.             requestOutputFileNameHeadersPermissions = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_FILE_NAME_HEADERS_PERMISSIONS);
  3053.             requestOutputParentDirCreateIfNotExists = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_AUTO_CREATE_DIR);
  3054.             requestOutputOverwriteIfExists = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_REQUEST_OUTPUT_OVERWRITE_FILE_NAME);
  3055.             responseInputMode = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_MODE);
  3056.             responseInputFileName = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME);
  3057.             responseInputFileNameHeaders = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME_HEADERS);
  3058.             responseInputDeleteAfterRead = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_FILE_NAME_DELETE_AFTER_READ);
  3059.             responseInputWaitTime = this.getParameter(readedDatiConnettori,defaultProperties,ConnettoriCostanti.PARAMETRO_CONNETTORE_FILE_RESPONSE_INPUT_WAIT_TIME);

  3061.             // status
  3062.             ConnettoreStatusParams connettoreStatusParams = ConnettoreStatusParams.fillFrom(this);
  3063.             
  3064.             Boolean isConnettoreCustomUltimaImmagineSalvata = null;
  3065.                         
  3066.             if(endpointtype==null || (forceEnabled && TipiConnettore.DISABILITATO.getNome().equals(endpointtype)) ){
  3067.                 endpointtype = TipiConnettore.HTTP.toString();
  3068.             }
  3069.             
  3070.             Connettore conTmp = null;
  3071.             List<ExtendedConnettore> listExtendedConnettore = 
  3072.                     ServletExtendedConnettoreUtils.getExtendedConnettore(conTmp, connettoreServletType, this, false, endpointtype);

  3074.             boolean postBackViaPost = true;
  3075.             
  3076.             this.addEndPointToDati(dati, serviceBinding, connettoreDebug, endpointtype, autenticazioneHttp, "",//ServiziApplicativiCostanti.LABEL_EROGATORE+" ",
  3077.                     url, nomeCodaJMS,
  3078.                     tipo, user, password, initcont, urlpgk, provurl,
  3079.                     connfact, sendas, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI, TipoOperazione.CHANGE, 
  3080.                     httpsurl, httpstipologia, httpshostverify, 
  3081.                     httpsTrustVerifyCert, httpspath, httpstipo, httpspwd,
  3082.                     httpsalgoritmo, httpsstato, httpskeystore,
  3083.                     httpspwdprivatekeytrust, httpspathkey,
  3084.                     httpstipokey, httpspwdkey, 
  3085.                     httpspwdprivatekey, httpsalgoritmokey,
  3086.                     httpsKeyAlias, httpsTrustStoreCRLs, httpsTrustStoreOCSPPolicy, httpsKeyStoreBYOKPolicy,
  3087.                     tipoconn, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT,
  3088.                     "", "", null, null, null,null,
  3089.                     null, null, showSectionTitle,
  3090.                     isConnettoreCustomUltimaImmagineSalvata, 
  3091.                     proxyEnabled, proxyHostname, proxyPort, proxyUsername, proxyPassword,
  3092.                     tempiRispostaEnabled, tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaTempoMedioRisposta,
  3093.                     opzioniAvanzate, transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  3094.                     requestOutputFileName, requestOutputFileNamePermissions, requestOutputFileNameHeaders, requestOutputFileNameHeadersPermissions,
  3095.                     requestOutputParentDirCreateIfNotExists,requestOutputOverwriteIfExists,
  3096.                     responseInputMode, responseInputFileName, responseInputFileNameHeaders, responseInputDeleteAfterRead, responseInputWaitTime,
  3097.                     autenticazioneToken,tokenPolicy, forcePDND, forceOAuth,
  3098.                     listExtendedConnettore, forceEnabled,
  3099.                     null, false,false
  3100.                     , false, false, null, null,
  3101.                     autenticazioneApiKey, useOAS3Names, useAppId, apiKeyHeader, apiKeyValue, appIdHeader, appIdValue,
  3102.                     connettoreStatusParams,
  3103.                     postBackViaPost
  3104.                     );
  3105.             
  3106.         }finally{
  3107.             // ripristino tipologia
  3108.             Utilities.setTipologiaConnettori(tipologiaConnettoriOriginale);
  3109.         }
  3110.     }

  3112.     
  3113.     
  3114.     public boolean accordiAllegatiCheckData(TipoOperazione tipoOperazione,FormFile formFile,Documento documento,ProprietariDocumento proprietario, IProtocolFactory<?> pf)
  3115.             throws Exception {

  3117.         try{

  3119.             String ruolo = this.getParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_RUOLO);

  3121.             // Campi obbligatori
  3122.             if (ruolo.equals("")) {
  3123.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare il Tipo di documento");
  3124.                 return false;
  3125.             }

  3127.             if(formFile==null || formFile.getFileName()!=null && "".equals(formFile.getFileName())){
  3128.                 this.pd.setMessage("&Egrave; necessario selezionare un documento.");
  3129.                 return false;
  3130.             }

  3132.             if(formFile==null || formFile.getFileSize()<=0){
  3133.                 this.pd.setMessage("Il documento selezionato non pu&ograve; essere vuoto.");
  3134.                 return false;
  3135.             }

  3137.             if(documento.getTipo()==null || "".equals(documento.getTipo()) || documento.getTipo().length()>30 || formFile.getFileName().lastIndexOf(".")==-1){
  3138.                 if(documento.getTipo()==null || "".equals(documento.getTipo()) || formFile.getFileName().lastIndexOf(".")==-1){
  3139.                     this.pd.setMessage("L'estensione del documento non &egrave; valida.");
  3140.                 }else{
  3141.                     this.pd.setMessage("L'estensione del documento non &egrave; valida. La dimensione dell'estensione &egrave; troppo lunga.");
  3142.                 }
  3143.                 return false;
  3144.             }

  3146.             boolean documentoUnivocoIndipendentementeTipo = true;
  3147.             if(this.archiviCore.existsDocumento(documento,proprietario,documentoUnivocoIndipendentementeTipo)){

  3149.                 String tipo = documento.getTipo();
  3150.                 String ruoloDoc = documento.getRuolo();
  3151.                 String msgTipo = "(tipo: "+documento.getTipo()+") ";
  3152.                 if(documentoUnivocoIndipendentementeTipo) {
  3153.                     tipo = null;
  3154.                     ruoloDoc = null;
  3155.                     msgTipo = "";
  3156.                 }
  3157.                 
  3158.                 Documento existing = this.archiviCore.getDocumento(documento.getFile(),tipo,ruoloDoc,documento.getIdProprietarioDocumento(),false,proprietario);
  3159.                 if(existing.getId().longValue() == documento.getId().longValue())
  3160.                     return true;

  3162.                 if(RuoliDocumento.allegato.toString().equals(documento.getRuolo()) || documentoUnivocoIndipendentementeTipo)
  3163.                     this.pd.setMessage("L'allegato con nome "+documento.getFile()+" "+msgTipo+"&egrave; gi&agrave; presente nella API.");
  3164.                 else
  3165.                     this.pd.setMessage("La specifica semiformale con nome "+documento.getFile()+" "+msgTipo+"&egrave; gi&agrave; presente nella API.");

  3167.                 return false;
  3168.             }

  3170.             ValidazioneResult valida = pf.createValidazioneDocumenti().valida (documento);
  3171.             if(!valida.isEsito()) {
  3172.                 this.pd.setMessage(valida.getMessaggioErrore());
  3173.                 return false;
  3174.             }
  3175.             
  3176.             return true;

  3178.         } catch (Exception e) {
  3179.             this.log.error("Exception: " + e.getMessage(), e);
  3180.             throw new Exception(e);
  3181.         }
  3182.     }
  3183.     
  3184.     @SuppressWarnings("incomplete-switch")
  3185.     public boolean accordiAllegatiCheckData(TipoOperazione tipoOperazione, List<BinaryParameter> binaryParameterDocumenti, Long idProprietarioDocumento, ProprietariDocumento proprietario, IProtocolFactory<?> pf)
  3186.             throws Exception {

  3188.         try{

  3190.             String ruolo = this.getParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_RUOLO);
  3191.             String tipoFile = this.getParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_TIPO_FILE);
  3192.             
  3193.             // Campi obbligatori
  3194.             if (ruolo.equals("")) {
  3195.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare il Tipo di documento");
  3196.                 return false;
  3197.             }
  3198.             
  3199.             // 1. Controllo selezione almeno un documento -> cioe' almento un value della lista non e' vuoto
  3200.             boolean almenoUnoSelezionato = false;
  3201.             for (int i = 0; i < binaryParameterDocumenti.size() ; i++) {
  3202.                 BinaryParameter binaryParameter = binaryParameterDocumenti.get(i);
  3203.                 
  3204.                 // al primo file non vuoto che trovo mi fermo
  3205.                 if(binaryParameter.getValue() != null && binaryParameter.getValue().length > 0){
  3206.                     almenoUnoSelezionato = true;
  3207.                     break;
  3208.                 }
  3209.             }
  3210.             
  3211.             if(!almenoUnoSelezionato) {
  3212.                 this.pd.setMessage("&Egrave; necessario selezionare almeno un documento.");
  3213.                 return false;
  3214.             }
  3215.             
  3216.             
  3217.             List<String> listaErrori = new ArrayList<>();
  3218.             
  3219.             for (int i = 0; i < binaryParameterDocumenti.size() ; i++) {
  3220.                 BinaryParameter binaryParameter = binaryParameterDocumenti.get(i);
  3221.                 
  3222.                 if(StringUtils.isBlank(binaryParameter.getFilename())){
  3223.                     listaErrori.add("Il documento selezionato in posizione ("+(i+1)+") non ha un nome valido.");
  3224.                     continue;
  3225.                 }

  3227.                 if(binaryParameter.getValue()==null || binaryParameter.getValue().length<=0){
  3228.                     listaErrori.add("Il documento '"+ binaryParameter.getFilename() +"' &egrave; vuoto.");
  3229.                     continue;
  3230.                 }
  3231.             
  3232.                 String tipo = null;
  3233.                 switch (RuoliDocumento.valueOf(ruolo)) {
  3234.                     case allegato:
  3235.                         tipo = binaryParameter.getFilename().substring(binaryParameter.getFilename().lastIndexOf('.')+1, binaryParameter.getFilename().length());
  3236.                         break;
  3237.                     case specificaSemiformale:
  3238.                         tipo = TipiDocumentoSemiformale.valueOf(tipoFile).getNome();
  3239.                         break;
  3240.                     case specificaCoordinamento:
  3241.                         tipo = TipiDocumentoCoordinamento.valueOf(tipoFile).getNome();
  3242.                         break;
  3243.                 }
  3244.                 
  3245.                 
  3246.                 if(tipo==null || "".equals(tipo) || tipo.length()>30 || binaryParameter.getFilename().lastIndexOf(".")==-1){
  3247.                     if(tipo==null || "".equals(tipo) || binaryParameter.getFilename().lastIndexOf(".")==-1){
  3248.                         listaErrori.add("L'estensione del documento '"+ binaryParameter.getFilename() +"' non &egrave; valida.");
  3249.                     }else{
  3250.                         listaErrori.add("L'estensione del documento '"+ binaryParameter.getFilename() +"' non &egrave; valida. La dimensione dell'estensione &egrave; troppo lunga.");
  3251.                     }
  3252.                     continue;
  3253.                 }
  3254.                 
  3255.                 Documento documento = new Documento();
  3256.                 documento.setRuolo(RuoliDocumento.valueOf(ruolo).toString());
  3257.                 documento.setByteContenuto(binaryParameter.getValue());
  3258.                 documento.setFile(binaryParameter.getFilename());

  3260.                 switch (RuoliDocumento.valueOf(ruolo)) {
  3261.                     case allegato:
  3262.                         documento.setTipo(binaryParameter.getFilename().substring(binaryParameter.getFilename().lastIndexOf('.')+1, binaryParameter.getFilename().length()));
  3263.                         break;
  3264.                     case specificaSemiformale:
  3265.                         documento.setTipo(TipiDocumentoSemiformale.valueOf(tipoFile).getNome());
  3266.                         break;
  3267.                     case specificaCoordinamento:
  3268.                         documento.setTipo(TipiDocumentoCoordinamento.valueOf(tipoFile).getNome());
  3269.                         break;
  3270.                 }
  3271.                 documento.setIdProprietarioDocumento(idProprietarioDocumento);
  3272.                 
  3273.                 boolean documentoUnivocoIndipendentementeTipo = true;
  3274.                 if(this.archiviCore.existsDocumento(documento,proprietario,documentoUnivocoIndipendentementeTipo)){
  3275.     
  3276.                     tipo = documento.getTipo();
  3277.                     String ruoloDoc = documento.getRuolo();
  3278.                     String msgTipo = "(tipo: "+documento.getTipo()+") ";
  3279.                     if(documentoUnivocoIndipendentementeTipo) {
  3280.                         tipo = null;
  3281.                         ruoloDoc = null;
  3282.                         msgTipo = "";
  3283.                     }
  3284.                     
  3285.                     Documento existing = this.archiviCore.getDocumento(documento.getFile(),tipo,ruoloDoc,documento.getIdProprietarioDocumento(),false,proprietario);
  3286.                     if(!(existing.getId().longValue() == documento.getId().longValue())) {
  3287.                         if(RuoliDocumento.allegato.toString().equals(documento.getRuolo()) || documentoUnivocoIndipendentementeTipo)
  3288.                             listaErrori.add("L'allegato con nome '"+documento.getFile()+"' "+msgTipo+"&egrave; gi&agrave; presente nella API.");
  3289.                         else
  3290.                             listaErrori.add("La specifica semiformale con nome '"+documento.getFile()+"' "+msgTipo+"&egrave; gi&agrave; presente nella API.");
  3291.     
  3292.                         continue;
  3293.                     }
  3294.                 }
  3295.     
  3296.                 ValidazioneResult valida = pf.createValidazioneDocumenti().valida (documento);
  3297.                 if(!valida.isEsito()) {
  3298.                     listaErrori.add(valida.getMessaggioErrore());
  3299.                     continue;
  3300.                 }
  3301.             }
  3302.             
  3303.             if(!listaErrori.isEmpty()) {
  3304.                 StringBuilder sb = new StringBuilder();
  3305.                 
  3306.                 for (int i = 0; i < listaErrori.size(); i++) {
  3307.                     if(i != 0) {
  3308.                         sb.append("<br/>");
  3309.                     }
  3310.                     sb.append(listaErrori.get(i));
  3311.                 }
  3312.                 
  3313.                 this.pd.setMessage(sb.toString());
  3314.                 return false;
  3315.             }
  3316.             
  3317.             return true;

  3319.         } catch (Exception e) {
  3320.             this.log.error("Exception: " + e.getMessage(), e);
  3321.             throw new Exception(e);
  3322.         }
  3323.     }

  3325.     private String getLockedParameter(boolean readedDatiConnettori, Default defaultProperties, String name) throws Exception {
  3326.         return getParameterEngine(true, readedDatiConnettori, defaultProperties, name);
  3327.     }
  3328.     private String getParameter(boolean readedDatiConnettori, Default defaultProperties, String name) throws Exception {
  3329.         return getParameterEngine(false, readedDatiConnettori, defaultProperties, name);
  3330.     }
  3331.     private String getParameterEngine(boolean locked, boolean readedDatiConnettori, Default defaultProperties, String name) throws Exception {
  3332.         String value = null;
  3333.         if(!readedDatiConnettori) {
  3334.             value = locked ? this.getLockedParameter(name) : this.getParameter(name);
  3335.         }
  3336.         if(value==null &&
  3337.             defaultProperties!=null && defaultProperties.sizeProprietaList()>0) {
  3338.             for (ProprietaDefault defaultProperty : defaultProperties.getProprietaList()) {
  3339.                 if(name.equals(defaultProperty.getNome())) {
  3340.                     return defaultProperty.getValore();
  3341.                 }
  3342.             }
  3343.         }
  3344.         return value;
  3345.     }
  3346.     
  3347.     private BinaryParameter getBinaryParameter(boolean readedDatiConnettori, Default defaultProperties, String name) throws Exception {
  3348.         BinaryParameter toReturn = this.getBinaryParameter(name);
  3349.         byte [] value = null;
  3350.         if(readedDatiConnettori==false) {
  3351.             value = toReturn.getValue();
  3352.         }
  3353.         if(value==null) {
  3354.             if(defaultProperties!=null && defaultProperties.sizeProprietaList()>0) {
  3355.                 for (ProprietaDefault defaultProperty : defaultProperties.getProprietaList()) {
  3356.                     if(name.equals(defaultProperty.getNome())) {
  3357.                         toReturn.setValue(defaultProperty.getValore().getBytes());
  3358.                         break;
  3359.                     }
  3360.                 }
  3361.             }
  3362.         }
  3363.         return toReturn;
  3364.     }

  3366. }
Created with JaCoCo 0.8.8.202204050719