BasicArchive.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.protocol.basic.archive;

  23. import java.io.InputStream;
  24. import java.io.OutputStream;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.wsdl.BindingOperation;
  32. import javax.xml.namespace.QName;

  34. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  35. import org.openspcoop2.core.registry.Operation;
  36. import org.openspcoop2.core.registry.PortType;
  37. import org.openspcoop2.core.registry.Resource;
  38. import org.openspcoop2.core.registry.ResourceParameter;
  39. import org.openspcoop2.core.registry.ResourceRepresentation;
  40. import org.openspcoop2.core.registry.ResourceRepresentationJson;
  41. import org.openspcoop2.core.registry.ResourceRepresentationXml;
  42. import org.openspcoop2.core.registry.ResourceRequest;
  43. import org.openspcoop2.core.registry.ResourceResponse;
  44. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  45. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  46. import org.openspcoop2.core.registry.constants.HttpMethod;
  47. import org.openspcoop2.core.registry.constants.ParameterType;
  48. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  49. import org.openspcoop2.core.registry.constants.RepresentationType;
  50. import org.openspcoop2.core.registry.constants.RepresentationXmlType;
  51. import org.openspcoop2.core.registry.constants.ServiceBinding;
  52. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  53. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  54. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  55. import org.openspcoop2.core.registry.wsdl.AccordoServizioWrapperUtilities;
  56. import org.openspcoop2.message.xml.MessageXMLUtils;
  57. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  58. import org.openspcoop2.protocol.basic.Costanti;
  59. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  60. import org.openspcoop2.protocol.sdk.ProtocolException;
  61. import org.openspcoop2.protocol.sdk.archive.Archive;
  62. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoDelete;
  63. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImport;
  64. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  65. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  66. import org.openspcoop2.protocol.sdk.archive.ExportMode;
  67. import org.openspcoop2.protocol.sdk.archive.IArchive;
  68. import org.openspcoop2.protocol.sdk.archive.ImportMode;
  69. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  70. import org.openspcoop2.protocol.sdk.archive.MappingModeTypesExtensions;
  71. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  72. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  73. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  74. import org.openspcoop2.utils.rest.ApiFactory;
  75. import org.openspcoop2.utils.rest.ApiFormats;
  76. import org.openspcoop2.utils.rest.ApiReaderConfig;
  77. import org.openspcoop2.utils.rest.IApiReader;
  78. import org.openspcoop2.utils.rest.ParseWarningException;
  79. import org.openspcoop2.utils.rest.api.Api;
  80. import org.openspcoop2.utils.rest.api.ApiBodyParameter;
  81. import org.openspcoop2.utils.rest.api.ApiCookieParameter;
  82. import org.openspcoop2.utils.rest.api.ApiHeaderParameter;
  83. import org.openspcoop2.utils.rest.api.ApiOperation;
  84. import org.openspcoop2.utils.rest.api.ApiReference;
  85. import org.openspcoop2.utils.rest.api.ApiRequestDynamicPathParameter;
  86. import org.openspcoop2.utils.rest.api.ApiRequestFormParameter;
  87. import org.openspcoop2.utils.rest.api.ApiRequestQueryParameter;
  88. import org.openspcoop2.utils.rest.api.ApiResponse;
  89. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  90. import org.openspcoop2.utils.wsdl.DefinitionWrapper;
  91. import org.openspcoop2.utils.wsdl.WSDLUtilities;
  92. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  93. import org.slf4j.Logger;
  94. import org.w3c.dom.Document;

  96. /**
  97.  *  BasicArchive
  98.  *
  99.  * @author Poli Andrea (apoli@link.it)
  100.  * @author $Author$
  101.  * @version $Rev$, $Date$
  102.  */
  103. public class BasicArchive extends BasicComponentFactory implements IArchive {

  105.     protected IDAccordoCooperazioneFactory idAccordoCooperazioneFactory;
  106.     protected IDAccordoFactory idAccordoFactory;
  107.     protected IDServizioFactory idServizioFactory;
  108.     protected EsitoUtils esitoUtils;
  109.     public BasicArchive(IProtocolFactory<?> protocolFactory) throws ProtocolException{
  110.         super(protocolFactory);
  111.         this.idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  112.         this.idAccordoFactory = IDAccordoFactory.getInstance();
  113.         this.idServizioFactory = IDServizioFactory.getInstance();
  114.         this.esitoUtils = new EsitoUtils(protocolFactory);
  115.     }

  117.     
  118.     
  119.     
  120.     /* ----- Utilita' generali ----- */
  121.     
  122.     @Override
  123.     public MappingModeTypesExtensions getMappingTypesExtensions(ArchiveMode mode)
  124.             throws ProtocolException {
  125.         MappingModeTypesExtensions m = new MappingModeTypesExtensions();
  126.         m.add(Costanti.OPENSPCOOP_ARCHIVE_EXT, Costanti.OPENSPCOOP_ARCHIVE_MODE_TYPE);
  127.         return m;
  128.     }
  129.     
  130.     private static boolean normalizeDescription255 = false;
  131.     public static boolean isNormalizeDescription255() {
  132.         return normalizeDescription255;
  133.     }
  134.     public static void setNormalizeDescription255(boolean normalizeDescription255) {
  135.         BasicArchive.normalizeDescription255 = normalizeDescription255;
  136.     }
  137.     private static boolean normalizeDescription4000 = false;
  138.     public static boolean isNormalizeDescription4000() {
  139.         return normalizeDescription4000;
  140.     }
  141.     public static void setNormalizeDescription4000(boolean normalizeDescription4000) {
  142.         BasicArchive.normalizeDescription4000 = normalizeDescription4000;
  143.     }
  144.     private String normalizeDescriptionApi(String description) {
  145.         if(BasicArchive.normalizeDescription255) {
  146.             return normalizeDescriptionEngine(description, 255);
  147.         }
  148.         else if(BasicArchive.normalizeDescription4000) {
  149.             return normalizeDescriptionEngine(description, 4000);
  150.         }
  151.         else {
  152.             return description;
  153.         }
  154.     }
  155.     private String normalizeDescriptionOtherElementApi(String description) {
  156.         return normalizeDescriptionEngine(description, 255);
  157.     }
  158.     private String normalizeDescriptionEngine(String description, int maxSize) {
  159.         if(description==null) {
  160.             return null;
  161.         }
  162.          String descr = description;
  163.          while(descr.contains("\r")) {
  164.              descr = descr.replace("\r", "");
  165.          }
  166.          int offset = 15; // uso maxSize-15 per essere sicuro che finisca in oracle con caratteri strani (value too large for column "GOVWAY330"."ACCORDI"."DESCRIZIONE" (actual: 257, maximum: 255))
  167.          if(descr.length()<=(maxSize-offset)) { 
  168.              return descr;
  169.          }
  170.          else {
  171.              int ulterioreOffset = 10;
  172.              if(maxSize==4000) {
  173.                  ulterioreOffset = 50;
  174.              }
  175.              return descr.substring(0, ((maxSize-ulterioreOffset)-offset))+ " ...";
  176.          }
  177.     }
  178.     
  179.     /**
  180.      * Imposta per ogni portType e operation presente nell'accordo fornito come parametro 
  181.      * le informazioni di protocollo analizzando i documenti interni agli archivi
  182.      */
  183.     @Override
  184.     public void setProtocolInfo(AccordoServizioParteComune accordoServizioParteComune) throws ProtocolException{
  185.         setProtocolInfoEngine(accordoServizioParteComune, this.protocolFactory.getLogger());
  186.     }
  187.     public void setProtocolInfo(AccordoServizioParteComune accordoServizioParteComune,Logger log) throws ProtocolException{
  188.         setProtocolInfoEngine(accordoServizioParteComune, log);
  189.     }
  190.     private void setProtocolInfoEngine(AccordoServizioParteComune accordoServizioParteComune,Logger log) throws ProtocolException{
  191.         
  192.         // NOTA non usare in questo metodo e nel metodo _setProtocolInfo il protocolFactory e dipendenze su di uno specifico protocollo.
  193.         //      Viene usato dal meccanismo di import per definire la struttura di un accordo in base al wsdl, indipendentemente dallo specifico protocollo
  194.         

  196.         
  197.         if(ServiceBinding.SOAP.equals(accordoServizioParteComune.getServiceBinding())) {
  198.         
  199.             if(accordoServizioParteComune.sizePortTypeList()>0){
  200.                 throw new ProtocolException("Protocol Info already exists");
  201.             }
  202.             
  203.             if(accordoServizioParteComune.getFormatoSpecifica()==null || FormatoSpecifica.WSDL_11.equals(accordoServizioParteComune.getFormatoSpecifica())) {
  204.                 byte[] wsdlConcettuale = accordoServizioParteComune.getByteWsdlConcettuale();
  205.                 if(wsdlConcettuale!=null){
  206.                     setProtocolInfoFromWsdlEngine(wsdlConcettuale, accordoServizioParteComune, "Concettuale", log);
  207.                 }
  208.                 else{
  209.                     if(accordoServizioParteComune.getByteWsdlLogicoErogatore()!=null){
  210.                         setProtocolInfoFromWsdlEngine(accordoServizioParteComune.getByteWsdlLogicoErogatore(), accordoServizioParteComune, "LogicoErogatore", log);
  211.                     }
  212.                     if(accordoServizioParteComune.getByteWsdlLogicoFruitore()!=null){
  213.                         setProtocolInfoFromWsdlEngine(accordoServizioParteComune.getByteWsdlLogicoFruitore(), accordoServizioParteComune, "LogicoFruitore", log);
  214.                     }
  215.                 }
  216.             }
  217.             
  218.         }
  219.         else {
  220.             
  221.             if(accordoServizioParteComune.sizeResourceList()>0){
  222.                 throw new ProtocolException("Protocol Info already exists");
  223.             }
  224.             
  225.             if(accordoServizioParteComune.getFormatoSpecifica()!=null) {
  226.                 
  227.                 byte[] wsdlConcettuale = accordoServizioParteComune.getByteWsdlConcettuale();
  228.                 if(wsdlConcettuale!=null){
  229.                     switch (accordoServizioParteComune.getFormatoSpecifica()) {
  230.                     case WADL:
  231.                         setProtocolInfoFromRestInterfaceEngine(wsdlConcettuale, accordoServizioParteComune, ApiFormats.WADL, log);
  232.                         break;
  233.                     case SWAGGER_2:
  234.                         setProtocolInfoFromRestInterfaceEngine(wsdlConcettuale, accordoServizioParteComune, ApiFormats.SWAGGER_2, log);
  235.                         break;
  236.                     case OPEN_API_3:
  237.                         setProtocolInfoFromRestInterfaceEngine(wsdlConcettuale, accordoServizioParteComune, ApiFormats.OPEN_API_3, log);
  238.                         break;
  239.                     default:
  240.                         // altre interfacce non supportate per rest
  241.                         break;
  242.                     }
  243.                 }
  244.                 
  245.             }
  246.             
  247.         }
  248.     }
  249.     private void setProtocolInfoFromWsdlEngine(byte [] wsdlBytes,AccordoServizioParteComune accordoServizioParteComune,String tipo,Logger log) throws ProtocolException{
  250.         
  251.         try{
  252.         
  253.             AbstractXMLUtils xmlUtils = MessageXMLUtils.DEFAULT;
  254.             WSDLUtilities wsdlUtilities = new WSDLUtilities(xmlUtils);
  255.             Document d = xmlUtils.newDocument(wsdlBytes);
  256.             wsdlUtilities.removeTypes(d);
  257.             DefinitionWrapper wsdl = new DefinitionWrapper(d,xmlUtils,false,false);
  258.             
  259.             // port types
  260.             Map<?, ?> porttypesWSDL = wsdl.getAllPortTypes();
  261.             if(porttypesWSDL==null || porttypesWSDL.size()<=0){
  262.                 throw new ProtocolException("WSDL"+tipo+" corrotto: non contiene la definizione di nessun port-type");
  263.             }
  264.             if(porttypesWSDL!=null && porttypesWSDL.size()>0){
  265.     
  266.                 Iterator<?> it = porttypesWSDL.keySet().iterator();
  267.                 while(it.hasNext()){
  268.                     javax.xml.namespace.QName key = (javax.xml.namespace.QName) it.next();
  269.                     javax.wsdl.PortType ptWSDL = (javax.wsdl.PortType) porttypesWSDL.get(key);
  270.                     String ptName = ptWSDL.getQName().getLocalPart();
  271.                     
  272.                     // cerco portType
  273.                     boolean foundPortType = false;
  274.                     PortType ptOpenSPCoop = null;
  275.                     for (PortType ptCheck : accordoServizioParteComune.getPortTypeList()) {
  276.                         if(ptCheck.getNome().equals(ptName)){
  277.                             ptOpenSPCoop = ptCheck;
  278.                             foundPortType = true;
  279.                             break;
  280.                         }
  281.                     }
  282.                     
  283.                     // cerco binding (se il wsdl contiene la parte implementativa)
  284.                     Map<?, ?> bindingsWSDL = wsdl.getAllBindings();
  285.                     javax.wsdl.Binding bindingWSDL = null;
  286.                     if(bindingsWSDL!=null && bindingsWSDL.size()>0){
  287.                         Iterator<?> itBinding = bindingsWSDL.keySet().iterator();
  288.                         while (itBinding.hasNext()) {
  289.                             javax.xml.namespace.QName tmp = (javax.xml.namespace.QName) itBinding.next();
  290.                             if(tmp!=null){
  291.                                 javax.wsdl.Binding tmpBinding = wsdl.getBinding(tmp);
  292.                                 if(tmpBinding!=null && tmpBinding.getPortType()!=null &&
  293.                                         tmpBinding.getPortType().getQName()!=null &&
  294.                                         ptName.equals(tmpBinding.getPortType().getQName().getLocalPart())){
  295.                                     bindingWSDL = tmpBinding;
  296.                                     break;
  297.                                 }
  298.                             }
  299.                         }
  300.                     }
  301.                     
  302.                     // se non esiste creo il port-type
  303.                     if(ptOpenSPCoop==null){
  304.                         ptOpenSPCoop = new PortType();
  305.                         ptOpenSPCoop.setNome(ptName);
  306.                         ptOpenSPCoop.setProfiloCollaborazione(CostantiRegistroServizi.SINCRONO);
  307.                         ptOpenSPCoop.setProfiloPT(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  308.                         ptOpenSPCoop.setFiltroDuplicati(CostantiRegistroServizi.ABILITATO);                 
  309.                     }
  310.                     
  311.                     // Calcolo profilo del port-type
  312.                     ProfiloCollaborazione profiloPt = accordoServizioParteComune.getProfiloCollaborazione();
  313.                     if(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(ptOpenSPCoop.getProfiloPT()) && ptOpenSPCoop.getProfiloCollaborazione()!=null) {
  314.                         profiloPt = ptOpenSPCoop.getProfiloCollaborazione();
  315.                     }
  316.                     
  317.                     // SoapBinding
  318.                     if(bindingWSDL!=null){
  319.                         AccordoServizioWrapperUtilities.setPortTypeSoapBindingStyle(bindingWSDL, log, ptOpenSPCoop);
  320.                     }
  321.                     
  322.                     // itero sulle operation
  323.                     for(int i=0; i<ptWSDL.getOperations().size();i++){
  324.                         javax.wsdl.Operation opWSDL = (javax.wsdl.Operation) ptWSDL.getOperations().get(i);
  325.                         String opNome = opWSDL.getName();
  326.                         
  327.                         boolean foundOperation = false;
  328.                         Operation opOpenSPCoop = null;
  329.                         for (Operation opCheck : ptOpenSPCoop.getAzioneList()) {
  330.                             if(opCheck.getNome().equals(opNome)){
  331.                                 foundOperation = true; 
  332.                                 break;
  333.                             }
  334.                         }
  335.                         if(foundOperation){
  336.                             continue;// gia definito in un altro wsdl (normale e correlato) ??
  337.                         }
  338.                         
  339.                         // imposto dati base operazione
  340.                         opOpenSPCoop = new Operation();
  341.                         opOpenSPCoop.setNome(opNome);
  342.                         opOpenSPCoop.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  343.                         opOpenSPCoop.setFiltroDuplicati(CostantiRegistroServizi.ABILITATO);
  344.                         
  345.                         // Prendo la definizione del messaggio di input
  346.                         HashMap<String,QName> mapPartQNameInput = new HashMap<>();
  347.                         AccordoServizioWrapperUtilities.addMessageInputOperation(opWSDL, log, opOpenSPCoop, mapPartQNameInput);
  348.                         
  349.                         // Prendo la definizione del messaggio di output
  350.                         HashMap<String,QName> mapPartQNameOutput = new HashMap<>();
  351.                         AccordoServizioWrapperUtilities.addMessageOutputOperation(opWSDL, log, opOpenSPCoop, mapPartQNameOutput);
  352.                         
  353.                         // profilo di collaborazione (non basta guardare l'output, poiche' puo' avere poi un message vuoto e quindi equivale a non avere l'output)
  354.                         /**if(opWSDL.getOutput()!=null){*/
  355.                         ProfiloCollaborazione profiloOp = null;
  356.                         if(opOpenSPCoop.getMessageOutput()!=null){
  357.                             profiloOp = CostantiRegistroServizi.SINCRONO;
  358.                         }else{
  359.                             profiloOp = CostantiRegistroServizi.ONEWAY;
  360.                         }
  361.                         opOpenSPCoop.setProfiloCollaborazione(profiloOp);
  362.                         if(profiloPt.equals(profiloOp)) {
  363.                             opOpenSPCoop.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT);
  364.                         }
  365.                         
  366.                         // cerco operation binding (se il wsdl contiene la parte implementativa)
  367.                         if(bindingWSDL!=null){
  368.                                 
  369.                             List<?> bindingsOperation = bindingWSDL.getBindingOperations();
  370.                             for(int j=0; j<bindingsOperation.size();j++){
  371.                                 BindingOperation bindingOperationWSDL = (BindingOperation) bindingsOperation.get(j);
  372.                                 
  373.                                 if(bindingOperationWSDL.getOperation()!=null && 
  374.                                         opNome.equals(bindingOperationWSDL.getOperation().getName())){
  375.                                 
  376.                                     // SoapBinding Operation
  377.                                     AccordoServizioWrapperUtilities.
  378.                                         setOperationSoapBindingInformation(bindingOperationWSDL, log, 
  379.                                                 opOpenSPCoop, ptOpenSPCoop);
  380.                                     
  381.                                     // Raccolgo Message-Input
  382.                                     if(opOpenSPCoop.getMessageInput()!=null){
  383.                                         AccordoServizioWrapperUtilities.
  384.                                             setMessageInputSoapBindingInformation(bindingOperationWSDL, log, 
  385.                                                     opOpenSPCoop, ptOpenSPCoop, mapPartQNameInput,
  386.                                                     wsdl.getTargetNamespace());
  387.                                     }
  388.                                     
  389.                                     // Raccolgo Message-Output
  390.                                     if(opOpenSPCoop.getMessageOutput()!=null){
  391.                                         AccordoServizioWrapperUtilities.
  392.                                             setMessageOutputSoapBindingInformation(bindingOperationWSDL, log, 
  393.                                                     opOpenSPCoop, ptOpenSPCoop, mapPartQNameOutput,
  394.                                                     wsdl.getTargetNamespace());
  395.                                     }
  396.                                     
  397.                                 }
  398.                             }
  399.                         }
  400.                         
  401.                         // aggiunto l'azione al port type
  402.                         ptOpenSPCoop.addAzione(opOpenSPCoop);
  403.                         
  404.                     }
  405.                     
  406.                     if(!foundPortType){
  407.                         accordoServizioParteComune.addPortType(ptOpenSPCoop);
  408.                     }
  409.                     
  410.                 }
  411.             }
  412.         }catch(Exception e){
  413.             throw new ProtocolException(e.getMessage(),e);
  414.         }
  415.     }
  416.     
  417.     private static final String TROVATO_PARAMETRO_COOKIE_PREFIX = "Trovato parametro cookie '";
  418.     private static final String TROVATO_PARAMETRO_HEADER_PREFIX = "Trovato parametro header '";
  419.     private static final String SENZA_TIPO_SUFFIX = "' senza tipo";
  420.     private static final String SENZA_SCHEMA_SUFFIX = "' senza schema";
  421.     
  422.     private void setProtocolInfoFromRestInterfaceEngine(byte [] bytes,AccordoServizioParteComune accordoServizioParteComune,ApiFormats format,Logger log) throws ProtocolException{
  423.         
  424.         try {
  425.             
  426.             ApiReaderConfig config = new ApiReaderConfig();
  427.             config.setProcessInclude(false);
  428.             
  429.             IApiReader apiReader = ApiFactory.newApiReader(format);
  430.             apiReader.init(log, bytes, config);
  431.             
  432.              Api api = apiReader.read();
  433.              try {
  434.                  boolean usingFromSetProtocolInfo = true;
  435.                  api.validate(usingFromSetProtocolInfo, false);
  436.              }catch(ParseWarningException warning) {
  437.                  // ignore
  438.              }
  439.              
  440.              if( 
  441.                 (accordoServizioParteComune.getDescrizione()==null || "".equals(accordoServizioParteComune.getDescrizione())) 
  442.                 &&
  443.                 (api.getDescription()!=null) 
  444.                  ){
  445.                  accordoServizioParteComune.setDescrizione(this.normalizeDescriptionApi(api.getDescription()));
  446.              }
  447.              
  448.              if(api.sizeOperations()>0) {
  449.                  for (ApiOperation apiOp : api.getOperations()) {
  450.                     
  451.                     // cerco resource
  452.                     Resource resourceOpenSPCoop = null;
  453.                     for (Resource resourceCheck : accordoServizioParteComune.getResourceList()) {
  454.                         if(resourceCheck.getPath()!=null && resourceCheck.getMethod()!=null) {
  455.                             HttpRequestMethod httpMethodCheck = HttpRequestMethod.valueOf(resourceCheck.getMethod().getValue());
  456.                             if(resourceCheck.getPath().equals(apiOp.getPath()) && 
  457.                                     httpMethodCheck!=null &&
  458.                                     httpMethodCheck.equals(apiOp.getHttpMethod())) {
  459.                                 resourceOpenSPCoop = resourceCheck;
  460.                                 break;
  461.                             }
  462.                         }
  463.                     }
  464.                     
  465.                     // se non esiste creo la risorsa
  466.                     if(resourceOpenSPCoop==null){
  467.                         resourceOpenSPCoop = new Resource();
  468.                         resourceOpenSPCoop.setNome(APIUtils.normalizeResourceName(apiOp.getHttpMethod(), apiOp.getPath()));
  469.                         resourceOpenSPCoop.setDescrizione(this.normalizeDescriptionOtherElementApi(apiOp.getDescription()));    
  470.                         resourceOpenSPCoop.setMethod(HttpMethod.toEnumConstant(apiOp.getHttpMethod().name()));
  471.                         resourceOpenSPCoop.setPath(apiOp.getPath());
  472.                         accordoServizioParteComune.addResource(resourceOpenSPCoop);
  473.                     }

  475.                     // Richiesta
  476.                     if(resourceOpenSPCoop.getRequest()==null) {
  477.                         resourceOpenSPCoop.setRequest(new ResourceRequest());
  478.                     }
  479.                     if(apiOp.getRequest()!=null) {
  480.                         
  481.                         if(apiOp.getRequest().sizeBodyParameters()>0) {
  482.                             for (ApiBodyParameter body : apiOp.getRequest().getBodyParameters()) {
  483.                                 String mediaType = body.getMediaType();
  484.                                 ResourceRepresentation rr = null;
  485.                                 for (ResourceRepresentation rrCheck : resourceOpenSPCoop.getRequest().getRepresentationList()) {
  486.                                     if(mediaType.equals(rrCheck.getMediaType())) {
  487.                                         rr = rrCheck;
  488.                                         break;
  489.                                     }
  490.                                 }
  491.                                 if(rr==null) {
  492.                                     rr = new ResourceRepresentation();
  493.                                     rr.setMediaType(mediaType);
  494.                                     resourceOpenSPCoop.getRequest().addRepresentation(rr);
  495.                                 }
  496.                                 rr.setNome(body.getName());
  497.                                 rr.setDescrizione(this.normalizeDescriptionOtherElementApi(body.getDescription()));
  498.                                 if(body.getElement()!=null) {
  499.                                     if(body.getElement() instanceof QName) {
  500.                                         QName qname = (QName)body.getElement();
  501.                                         rr.setRepresentationType(RepresentationType.XML);
  502.                                         ResourceRepresentationXml xml = new ResourceRepresentationXml();
  503.                                         xml.setXmlType(RepresentationXmlType.ELEMENT);
  504.                                         xml.setNome(qname.getLocalPart());
  505.                                         xml.setNamespace(qname.getNamespaceURI());
  506.                                         rr.setXml(xml);
  507.                                     }
  508.                                     else if(body.getElement() instanceof String) {
  509.                                         String jsonType = (String)body.getElement();
  510.                                         rr.setRepresentationType(RepresentationType.JSON);
  511.                                         ResourceRepresentationJson json = new ResourceRepresentationJson();
  512.                                         json.setTipo(jsonType);
  513.                                         rr.setJson(json);
  514.                                     }
  515.                                     else if(body.getElement() instanceof ApiReference) {
  516.                                         ApiReference apiRef = (ApiReference) body.getElement();
  517.                                         String jsonType = apiRef.getType();
  518.                                         rr.setRepresentationType(RepresentationType.JSON);
  519.                                         ResourceRepresentationJson json = new ResourceRepresentationJson();
  520.                                         json.setTipo(apiRef.getSchemaRef()+"#"+jsonType);
  521.                                         rr.setJson(json);
  522.                                     }
  523.                                     else {
  524.                                         rr.setRepresentationType(null);
  525.                                         rr.setJson(null);
  526.                                         rr.setXml(null);
  527.                                     }
  528.                                 }
  529.                                 else {
  530.                                     rr.setRepresentationType(null);
  531.                                     rr.setJson(null);
  532.                                     rr.setXml(null);
  533.                                 }
  534.                             }
  535.                         }

  537.                         if(apiOp.getRequest().sizeCookieParameters()>0) {
  538.                             for (ApiCookieParameter cookie : apiOp.getRequest().getCookieParameters()) {
  539.                                 String nome = cookie.getName();
  540.                                 if(nome==null) {
  541.                                     throw new ProtocolException("Trovato parametro cookie senza nome");
  542.                                 }
  543.                                 ResourceParameter rp = null;
  544.                                 for (ResourceParameter rpCheck : resourceOpenSPCoop.getRequest().getParameterList()) {
  545.                                     if(ParameterType.COOKIE.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  546.                                         rp = rpCheck;
  547.                                         break;
  548.                                     }
  549.                                 }
  550.                                 if(rp==null) {
  551.                                     rp = new ResourceParameter();
  552.                                     rp.setParameterType(ParameterType.COOKIE);
  553.                                     rp.setNome(cookie.getName());
  554.                                     resourceOpenSPCoop.getRequest().addParameter(rp);
  555.                                 }
  556.                                 rp.setDescrizione(this.normalizeDescriptionOtherElementApi(cookie.getDescription()));
  557.                                 rp.setRequired(cookie.isRequired());
  558.                                 if(cookie.getApiParameterSchema()!=null) {
  559.                                     String type = cookie.getApiParameterSchema().getType();
  560.                                     if(type==null) {
  561.                                         throw new ProtocolException(TROVATO_PARAMETRO_COOKIE_PREFIX+rp.getNome()+SENZA_TIPO_SUFFIX);
  562.                                     }
  563.                                     rp.setTipo(type);
  564.                                     rp.setRestrizioni(cookie.getApiParameterSchema().toString());
  565.                                 }
  566.                                 else {
  567.                                     throw new ProtocolException(TROVATO_PARAMETRO_COOKIE_PREFIX+rp.getNome()+SENZA_SCHEMA_SUFFIX);
  568.                                 }
  569.                             }                           
  570.                         }
  571.                         
  572.                         if(apiOp.getRequest().sizeDynamicPathParameters()>0) {
  573.                             for (ApiRequestDynamicPathParameter dynamicPath : apiOp.getRequest().getDynamicPathParameters()) {
  574.                                 String nome = dynamicPath.getName();
  575.                                 if(nome==null) {
  576.                                     throw new ProtocolException("Trovato parametro dynamic path senza nome");
  577.                                 }
  578.                                 ResourceParameter rp = null;
  579.                                 for (ResourceParameter rpCheck : resourceOpenSPCoop.getRequest().getParameterList()) {
  580.                                     if(ParameterType.DYNAMIC_PATH.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  581.                                         rp = rpCheck;
  582.                                         break;
  583.                                     }
  584.                                 }
  585.                                 if(rp==null) {
  586.                                     rp = new ResourceParameter();
  587.                                     rp.setParameterType(ParameterType.DYNAMIC_PATH);
  588.                                     rp.setNome(dynamicPath.getName());
  589.                                     resourceOpenSPCoop.getRequest().addParameter(rp);
  590.                                 }
  591.                                 rp.setDescrizione(this.normalizeDescriptionOtherElementApi(dynamicPath.getDescription()));
  592.                                 rp.setRequired(dynamicPath.isRequired());
  593.                                 if(dynamicPath.getApiParameterSchema()!=null) {
  594.                                     String type = dynamicPath.getApiParameterSchema().getType();
  595.                                     if(type==null) {
  596.                                         throw new ProtocolException("Trovato parametro dynamic path '"+rp.getNome()+SENZA_TIPO_SUFFIX);
  597.                                     }
  598.                                     rp.setTipo(type);
  599.                                     rp.setRestrizioni(dynamicPath.getApiParameterSchema().toString());
  600.                                 }
  601.                                 else {
  602.                                     throw new ProtocolException("Trovato parametro dynamic path '"+rp.getNome()+SENZA_SCHEMA_SUFFIX);
  603.                                 }
  604.                             }                           
  605.                         }
  606.                         
  607.                         if(apiOp.getRequest().sizeFormParameters()>0) {
  608.                             for (ApiRequestFormParameter form : apiOp.getRequest().getFormParameters()) {
  609.                                 String nome = form.getName();
  610.                                 if(nome==null) {
  611.                                     throw new ProtocolException("Trovato parametro form senza nome");
  612.                                 }
  613.                                 ResourceParameter rp = null;
  614.                                 for (ResourceParameter rpCheck : resourceOpenSPCoop.getRequest().getParameterList()) {
  615.                                     if(ParameterType.FORM.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  616.                                         rp = rpCheck;
  617.                                         break;
  618.                                     }
  619.                                 }
  620.                                 if(rp==null) {
  621.                                     rp = new ResourceParameter();
  622.                                     rp.setParameterType(ParameterType.FORM);
  623.                                     rp.setNome(form.getName());
  624.                                     resourceOpenSPCoop.getRequest().addParameter(rp);
  625.                                 }
  626.                                 rp.setDescrizione(this.normalizeDescriptionOtherElementApi(form.getDescription()));
  627.                                 rp.setRequired(form.isRequired());
  628.                                 if(form.getApiParameterSchema()!=null) {
  629.                                     String type = form.getApiParameterSchema().getType();
  630.                                     if(type==null) {
  631.                                         throw new ProtocolException("Trovato parametro form '"+rp.getNome()+SENZA_TIPO_SUFFIX);
  632.                                     }
  633.                                     rp.setTipo(type);
  634.                                     rp.setRestrizioni(form.getApiParameterSchema().toString());
  635.                                 }
  636.                                 else {
  637.                                     throw new ProtocolException("Trovato parametro form '"+rp.getNome()+SENZA_SCHEMA_SUFFIX);
  638.                                 }
  639.                             }                           
  640.                         }
  641.                         
  642.                         if(apiOp.getRequest().sizeHeaderParameters()>0) {
  643.                             for (ApiHeaderParameter header : apiOp.getRequest().getHeaderParameters()) {
  644.                                 String nome = header.getName();
  645.                                 if(nome==null) {
  646.                                     throw new ProtocolException("Trovato parametro header senza nome");
  647.                                 }
  648.                                 ResourceParameter rp = null;
  649.                                 for (ResourceParameter rpCheck : resourceOpenSPCoop.getRequest().getParameterList()) {
  650.                                     if(ParameterType.HEADER.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  651.                                         rp = rpCheck;
  652.                                         break;
  653.                                     }
  654.                                 }
  655.                                 if(rp==null) {
  656.                                     rp = new ResourceParameter();
  657.                                     rp.setParameterType(ParameterType.HEADER);
  658.                                     rp.setNome(header.getName());
  659.                                     resourceOpenSPCoop.getRequest().addParameter(rp);
  660.                                 }
  661.                                 rp.setDescrizione(this.normalizeDescriptionOtherElementApi(header.getDescription()));
  662.                                 rp.setRequired(header.isRequired());
  663.                                 if(header.getApiParameterSchema()!=null) {
  664.                                     String type = header.getApiParameterSchema().getType();
  665.                                     if(type==null) {
  666.                                         throw new ProtocolException(TROVATO_PARAMETRO_HEADER_PREFIX+rp.getNome()+SENZA_TIPO_SUFFIX);
  667.                                     }
  668.                                     rp.setTipo(type);
  669.                                     rp.setRestrizioni(header.getApiParameterSchema().toString());
  670.                                 }
  671.                                 else {
  672.                                     throw new ProtocolException(TROVATO_PARAMETRO_HEADER_PREFIX+rp.getNome()+SENZA_SCHEMA_SUFFIX);
  673.                                 }
  674.                             }                           
  675.                         }
  676.                         
  677.                         if(apiOp.getRequest().sizeQueryParameters()>0) {
  678.                             for (ApiRequestQueryParameter query : apiOp.getRequest().getQueryParameters()) {
  679.                                 String nome = query.getName();
  680.                                 if(nome==null) {
  681.                                     throw new ProtocolException("Trovato parametro query senza nome");
  682.                                 }
  683.                                 ResourceParameter rp = null;
  684.                                 for (ResourceParameter rpCheck : resourceOpenSPCoop.getRequest().getParameterList()) {
  685.                                     if(ParameterType.QUERY.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  686.                                         rp = rpCheck;
  687.                                         break;
  688.                                     }
  689.                                 }
  690.                                 if(rp==null) {
  691.                                     rp = new ResourceParameter();
  692.                                     rp.setParameterType(ParameterType.QUERY);
  693.                                     rp.setNome(query.getName());
  694.                                     resourceOpenSPCoop.getRequest().addParameter(rp);
  695.                                 }
  696.                                 rp.setDescrizione(this.normalizeDescriptionOtherElementApi(query.getDescription()));
  697.                                 rp.setRequired(query.isRequired());
  698.                                 if(query.getApiParameterSchema()!=null) {
  699.                                     String type = query.getApiParameterSchema().getType();
  700.                                     if(type==null) {
  701.                                         throw new ProtocolException("Trovato parametro query '"+rp.getNome()+SENZA_TIPO_SUFFIX);
  702.                                     }
  703.                                     rp.setTipo(type);
  704.                                     rp.setRestrizioni(query.getApiParameterSchema().toString());
  705.                                 }
  706.                                 else {
  707.                                     throw new ProtocolException("Trovato parametro query '"+rp.getNome()+SENZA_SCHEMA_SUFFIX);
  708.                                 }
  709.                             }                           
  710.                         }
  711.                         
  712.                     }
  713.                     
  714.                     // Risposta
  715.                     if(apiOp.sizeResponses()>0) {
  716.                         for (ApiResponse apiResponse : apiOp.getResponses()) {
  717.                             
  718.                             int status = apiResponse.getHttpReturnCode();
  719.                             boolean defaultResponse = apiResponse.isDefaultHttpReturnCode();
  720.                             ResourceResponse resourceOpenSPCoopResponse = null;
  721.                             for (ResourceResponse resourceCheck : resourceOpenSPCoop.getResponseList()) {
  722.                                 if( (status == resourceCheck.getStatus()) || (defaultResponse && ApiResponse.isDefaultHttpReturnCode(resourceCheck.getStatus()))) {
  723.                                     resourceOpenSPCoopResponse = resourceCheck;
  724.                                     break;
  725.                                 }
  726.                             }
  727.                             if(resourceOpenSPCoopResponse==null) {
  728.                                 resourceOpenSPCoopResponse = new ResourceResponse();
  729.                                 if(defaultResponse) {
  730.                                     resourceOpenSPCoopResponse.setStatus(ApiResponse.getDefaultHttpReturnCode());
  731.                                 }
  732.                                 else {
  733.                                     resourceOpenSPCoopResponse.setStatus(status);
  734.                                 }
  735.                                 resourceOpenSPCoop.addResponse(resourceOpenSPCoopResponse);
  736.                             }
  737.                             resourceOpenSPCoopResponse.setDescrizione(this.normalizeDescriptionOtherElementApi(apiResponse.getDescription()));
  738.                             
  739.                             if(apiResponse.sizeBodyParameters()>0) {
  740.                                 for (ApiBodyParameter body : apiResponse.getBodyParameters()) {
  741.                                     String mediaType = body.getMediaType();
  742.                                     ResourceRepresentation rr = null;
  743.                                     for (ResourceRepresentation rrCheck : resourceOpenSPCoopResponse.getRepresentationList()) {
  744.                                         if(mediaType.equals(rrCheck.getMediaType())) {
  745.                                             rr = rrCheck;
  746.                                             break;
  747.                                         }
  748.                                     }
  749.                                     if(rr==null) {
  750.                                         rr = new ResourceRepresentation();
  751.                                         rr.setMediaType(mediaType);
  752.                                         resourceOpenSPCoopResponse.addRepresentation(rr);
  753.                                     }
  754.                                     rr.setNome(body.getName());
  755.                                     rr.setDescrizione(this.normalizeDescriptionOtherElementApi(body.getDescription()));
  756.                                     if(body.getElement()!=null) {
  757.                                         if(body.getElement() instanceof QName) {
  758.                                             QName qname = (QName)body.getElement();
  759.                                             rr.setRepresentationType(RepresentationType.XML);
  760.                                             ResourceRepresentationXml xml = new ResourceRepresentationXml();
  761.                                             xml.setXmlType(RepresentationXmlType.ELEMENT);
  762.                                             xml.setNome(qname.getLocalPart());
  763.                                             xml.setNamespace(qname.getNamespaceURI());
  764.                                             rr.setXml(xml);
  765.                                         }
  766.                                         else if(body.getElement() instanceof String) {
  767.                                             String jsonType = (String)body.getElement();
  768.                                             rr.setRepresentationType(RepresentationType.JSON);
  769.                                             ResourceRepresentationJson json = new ResourceRepresentationJson();
  770.                                             json.setTipo(jsonType);
  771.                                             rr.setJson(json);
  772.                                         }
  773.                                         else if(body.getElement() instanceof ApiReference) {
  774.                                             ApiReference apiRef = (ApiReference) body.getElement();
  775.                                             String jsonType = apiRef.getType();
  776.                                             rr.setRepresentationType(RepresentationType.JSON);
  777.                                             ResourceRepresentationJson json = new ResourceRepresentationJson();
  778.                                             json.setTipo(apiRef.getSchemaRef()+"#"+jsonType);
  779.                                             rr.setJson(json);
  780.                                         }
  781.                                         else {
  782.                                             rr.setRepresentationType(null);
  783.                                             rr.setJson(null);
  784.                                             rr.setXml(null);
  785.                                         }
  786.                                     }
  787.                                     else {
  788.                                         rr.setRepresentationType(null);
  789.                                         rr.setJson(null);
  790.                                         rr.setXml(null);
  791.                                     }
  792.                                 }
  793.                             }
  794.                             
  795.                             if(apiResponse.sizeCookieParameters()>0) {
  796.                                 for (ApiCookieParameter cookie : apiResponse.getCookieParameters()) {
  797.                                     String nome = cookie.getName();
  798.                                     if(nome==null) {
  799.                                         throw new ProtocolException("Trovato parametro cookie nella risposta senza nome");
  800.                                     }
  801.                                     ResourceParameter rp = null;
  802.                                     for (ResourceParameter rpCheck : resourceOpenSPCoopResponse.getParameterList()) {
  803.                                         if(ParameterType.COOKIE.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  804.                                             rp = rpCheck;
  805.                                             break;
  806.                                         }
  807.                                     }
  808.                                     if(rp==null) {
  809.                                         rp = new ResourceParameter();
  810.                                         rp.setParameterType(ParameterType.COOKIE);
  811.                                         rp.setNome(cookie.getName());
  812.                                         resourceOpenSPCoopResponse.addParameter(rp);
  813.                                     }
  814.                                     rp.setDescrizione(this.normalizeDescriptionOtherElementApi(cookie.getDescription()));
  815.                                     rp.setRequired(cookie.isRequired());
  816.                                     if(cookie.getApiParameterSchema()!=null) {
  817.                                         String type = cookie.getApiParameterSchema().getType();
  818.                                         if(type==null) {
  819.                                             throw new ProtocolException(TROVATO_PARAMETRO_COOKIE_PREFIX+rp.getNome()+"' nella risposta senza tipo");
  820.                                         }
  821.                                         rp.setTipo(type);
  822.                                         rp.setRestrizioni(cookie.getApiParameterSchema().toString());
  823.                                     }
  824.                                     else {
  825.                                         throw new ProtocolException(TROVATO_PARAMETRO_COOKIE_PREFIX+rp.getNome()+"' nella risposta senza schema");
  826.                                     }
  827.                                 }                           
  828.                             }
  829.                             
  830.                             if(apiResponse.sizeHeaderParameters()>0) {
  831.                                 for (ApiHeaderParameter header : apiResponse.getHeaderParameters()) {
  832.                                     String nome = header.getName();
  833.                                     if(nome==null) {
  834.                                         throw new ProtocolException("Trovato parametro header nella risposta senza nome");
  835.                                     }
  836.                                     ResourceParameter rp = null;
  837.                                     for (ResourceParameter rpCheck : resourceOpenSPCoopResponse.getParameterList()) {
  838.                                         if(ParameterType.HEADER.equals(rpCheck.getParameterType()) && nome.equals(rpCheck.getNome())) {
  839.                                             rp = rpCheck;
  840.                                             break;
  841.                                         }
  842.                                     }
  843.                                     if(rp==null) {
  844.                                         rp = new ResourceParameter();
  845.                                         rp.setParameterType(ParameterType.HEADER);
  846.                                         rp.setNome(header.getName());
  847.                                         resourceOpenSPCoopResponse.addParameter(rp);
  848.                                     }
  849.                                     rp.setDescrizione(this.normalizeDescriptionOtherElementApi(header.getDescription()));
  850.                                     rp.setRequired(header.isRequired());
  851.                                     if(header.getApiParameterSchema()!=null) {
  852.                                         String type = header.getApiParameterSchema().getType();
  853.                                         if(type==null) {
  854.                                             throw new ProtocolException(TROVATO_PARAMETRO_HEADER_PREFIX+rp.getNome()+"' nella risposta senza tipo");
  855.                                         }
  856.                                         rp.setTipo(type);
  857.                                         rp.setRestrizioni(header.getApiParameterSchema().toString());
  858.                                     }
  859.                                     else {
  860.                                         throw new ProtocolException(TROVATO_PARAMETRO_HEADER_PREFIX+rp.getNome()+"' nella risposta senza schema");
  861.                                     }
  862.                                 }                           
  863.                             }
  864.                         }
  865.                     }
  866.                 }
  867.              }
  868.              
  869.              // Check nomi univoci delle risorse
  870.              if(accordoServizioParteComune.sizeResourceList()>0) {
  871.                  boolean foundEquals = true;
  872.                  while (foundEquals) {
  873.                      foundEquals = false;
  874.                      
  875.                      for (int i = 0; i < accordoServizioParteComune.sizeResourceList(); i++) {
  876.                          Resource resource = accordoServizioParteComune.getResource(i);
  877.                          List<Resource> lR = new ArrayList<>();
  878.                          for (Resource resourceCheck : accordoServizioParteComune.getResourceList()) {
  879.                              if(resourceCheck.getNome().equals(resource.getNome())) {
  880.                                  lR.add(resourceCheck);
  881.                              }
  882.                          }
  883.                          if(lR.size()>1) {
  884.                              for (int j = 0; j < lR.size(); j++) {
  885.                                  Resource resourceDaModificare = lR.get(j);
  886.                                  String newName = resourceDaModificare.getNome();
  887.                                  if(newName.length()>250) {
  888.                                      newName = newName.substring(0, 250)+"_"+(j+1);
  889.                                  }
  890.                                  else {
  891.                                      newName = newName +"_"+(j+1);
  892.                                  }
  893.                                  resourceDaModificare.setNome(newName);
  894.                              }
  895.                              foundEquals = true;
  896.                          }
  897.                      }
  898.                  }
  899.                  
  900.              }

  902.             
  903.         }catch(Exception e){
  904.             throw new ProtocolException(e.getMessage(),e);
  905.         }
  906.         
  907.     }
  908.     
  909.     
  910.     

  912.     
  913.     
  914.     
  915.     /* ----- Import ----- */
  916.     
  917.     @Override
  918.     public List<ImportMode> getImportModes() throws ProtocolException {
  919.         List<ImportMode> list = new ArrayList<>();
  920.         list.add(Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE);
  921.         return list;
  922.     }

  924.     @Override
  925.     public Archive importArchive(byte[]archive,ArchiveMode mode,ArchiveModeType type,
  926.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader,
  927.             boolean validationDocuments, MapPlaceholder placeholder) throws ProtocolException {
  928.         
  929.         ZIPReadUtils zipUtils = new ZIPReadUtils(this.protocolFactory.getLogger(),registryReader,configIntegrationReader);
  930.         return zipUtils.getArchive(archive,placeholder,validationDocuments);
  931.         
  932.     }
  933.     
  934.     @Override
  935.     public Archive importArchive(InputStream archive,ArchiveMode mode,ArchiveModeType type,
  936.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader,
  937.             boolean validationDocuments, MapPlaceholder placeholder) throws ProtocolException {
  938.         
  939.         try{
  940.             ZIPReadUtils zipUtils = new ZIPReadUtils(this.protocolFactory.getLogger(),registryReader,configIntegrationReader);
  941.             return zipUtils.getArchive(archive,placeholder,validationDocuments);
  942.         }finally{
  943.             try{
  944.                 if(archive!=null){
  945.                     archive.close();
  946.                 }
  947.             }catch(Exception eClose){
  948.                 // close
  949.             }
  950.         }
  951.         
  952.     }
  953.     
  954.     @Override
  955.     public void finalizeImportArchive(Archive archive,ArchiveMode mode,ArchiveModeType type,
  956.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader,
  957.             boolean validationDocuments, MapPlaceholder placeholder) throws ProtocolException {
  958.         // nop
  959.     }
  960.     
  961.     @Override
  962.     public String toString(ArchiveEsitoImport esito, ArchiveMode archiveMode) throws ProtocolException{
  963.         return this.esitoUtils.toString(esito,true,true);
  964.     }
  965.     
  966.     @Override
  967.     public String toString(ArchiveEsitoDelete esito, ArchiveMode archiveMode) throws ProtocolException{
  968.         return this.esitoUtils.toString(esito,true,false);
  969.     }
  970.     
  971.     
  972.     
  973.     
  974.     
  975.     
  976.     
  977.     /* ----- Export ----- */
  978.     
  979.     @Override
  980.     public List<ExportMode> getExportModes(ArchiveType archiveType)
  981.             throws ProtocolException {
  982.         List<ExportMode> list = new ArrayList<>();
  983.         list.add((ExportMode)Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE.clone()); // vengono supportati tutti i tipi
  984.         return list;
  985.     }
  986.     
  987.     @Override
  988.     public MappingModeTypesExtensions getExportMappingTypesExtensions(Archive archive, ArchiveMode mode,
  989.             IRegistryReader registroReader, IConfigIntegrationReader configIntegrationReader) throws ProtocolException{
  990.         return this.getMappingTypesExtensions(mode); // basic ignora archive
  991.     }

  993.     @Override
  994.     public byte[] exportArchive(Archive archive, ArchiveMode mode,
  995.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader)
  996.             throws ProtocolException {
  997.         ZIPWriteUtils zipUtils = new ZIPWriteUtils(super.getProtocolFactory().getLogger(),registryReader,configIntegrationReader);
  998.         return zipUtils.generateArchive(archive);
  999.     }
  1000.     
  1001.     @Override
  1002.     public void exportArchive(Archive archive, OutputStream out, ArchiveMode mode,
  1003.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader)
  1004.             throws ProtocolException {
  1005.         ZIPWriteUtils zipUtils = new ZIPWriteUtils(super.getProtocolFactory().getLogger(),registryReader,configIntegrationReader);
  1006.         zipUtils.generateArchive(archive, out);
  1007.     }
  1008.     




  1013. }
Created with JaCoCo 0.8.8.202204050719