TemplateCore.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.abstraction.template;

  23. import java.io.File;
  24. import java.io.FileOutputStream;
  25. import java.io.IOException;
  26. import java.io.InputStream;
  27. import java.util.HashMap;
  28. import java.util.Iterator;
  29. import java.util.Map;
  30. import java.util.zip.ZipEntry;
  31. import java.util.zip.ZipFile;

  33. import javax.activation.FileDataSource;

  35. import org.openspcoop2.protocol.abstraction.constants.CostantiAbstraction;
  36. import org.openspcoop2.protocol.sdk.ProtocolException;
  37. import org.openspcoop2.utils.Utilities;
  38. import org.openspcoop2.utils.io.ZipUtilities;
  39. import org.openspcoop2.utils.resources.FileSystemUtilities;
  40. import org.openspcoop2.utils.resources.TemplateUtils;

  42. import freemarker.template.Template;

  44. /**     
  45.  * TemplateCore
  46.  *
  47.  * @author Poli Andrea (poli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class TemplateCore {

  53.     protected TemplateCore(boolean erogazione) throws ProtocolException{
  54.         
  55.         this.zipName = "openspcoop_core_template";
  56.         this.rootDirName = CostantiAbstraction.TEMPLATES_CORE_DIR;
  57.         try{
  58.             String baseUrl = "/"+CostantiAbstraction.TEMPLATES_DIR+"/"+CostantiAbstraction.TEMPLATES_CORE_DIR+"."+CostantiAbstraction.ZIP_EXTENSION;
  59.             InputStream is = TemplateCore.class.getResourceAsStream(baseUrl);
  60.             if(is==null){
  61.                 throw new ProtocolException("Resource with url ["+baseUrl+"] not found");
  62.             }
  63.             byte[]zipFile = Utilities.getAsByteArray(is);
  64.             is.close();
  65.             this.updateTemplates(zipFile);
  66.         }catch(Exception e){
  67.             throw new ProtocolException(e.getMessage(),e);
  68.         }
  69.         
  70.         if(erogazione){
  71.             this.zipName = "openspcoop_erogazione_template";
  72.             this.rootDirName = CostantiAbstraction.TEMPLATES_EROGAZIONE_DIR;
  73.         }
  74.         else{
  75.             this.zipName = "openspcoop_fruizione_template";
  76.             this.rootDirName = CostantiAbstraction.TEMPLATES_FRUIZIONE_DIR;
  77.         }
  78.     }
  79.     
  80.     private String zipName;
  81.     private String rootDirName;
  82.     public String getZipName() {
  83.         return this.zipName;
  84.     }
  85.     public String getRootDirName() {
  86.         return this.rootDirName;
  87.     }

  89.     private byte[] pdd;
  90.     private byte[] soggetto;
  91.     private byte[] fruitore;
  92.     
  93.     public byte[] getPdd() {
  94.         return this.pdd;
  95.     }
  96.     public void setPdd(byte[] pdd) {
  97.         this.pdd = pdd;
  98.     }
  99.     public Template getTemplatePdd() throws IOException {
  100.         return TemplateUtils.buildTemplate("pdd",this.pdd);
  101.     }
  102.     
  103.     public byte[] getSoggetto() {
  104.         return this.soggetto;
  105.     }
  106.     public void setSoggetto(byte[] soggetto) {
  107.         this.soggetto = soggetto;
  108.     }
  109.     public Template getTemplateSoggetto() throws IOException {
  110.         return TemplateUtils.buildTemplate("soggetto",this.soggetto);
  111.     }
  112.     
  113.     
  114.     public byte[] getFruitore() {
  115.         return this.fruitore;
  116.     }
  117.     public void setFruitore(byte[] fruitore) {
  118.         this.fruitore = fruitore;
  119.     }
  120.     public Template getTemplateFruitore() throws IOException {
  121.         return TemplateUtils.buildTemplate("fruitore",this.fruitore);
  122.     }
  123.     
  124.     
  125.     
  126.     
  127.     
  128.     public void updateTemplates(byte[] zip) throws ProtocolException{
  129.         File tmp = null;
  130.         FileOutputStream fout = null; 
  131.         try{
  132.             tmp = FileSystemUtilities.createTempFile(this.zipName, ".zip");
  133.             
  134.             fout = new FileOutputStream(tmp);
  135.             fout.write(zip);
  136.             fout.flush();
  137.             fout.close();

  139.             this.updateTemplates(tmp);
  140.             
  141.             if(tmp!=null) {
  142.                 if(!tmp.delete()) {
  143.                     // ignore
  144.                 }
  145.             }
  146.             
  147.         }catch(Exception e){
  148.             if(tmp!=null)
  149.                 throw new ProtocolException("["+tmp.getAbsolutePath()+"] "+ e.getMessage(),e);
  150.             else
  151.                 throw new ProtocolException(e.getMessage(),e);
  152.         }finally{
  153.             try{
  154.                 if(fout!=null)
  155.                     fout.close();
  156.             }catch(Exception eClose){
  157.                 // close
  158.             }
  159.         }
  160.         
  161.     }
  162.     public void updateTemplates(File zip) throws ProtocolException{
  163.         ZipFile zipFile = null;
  164.         try{
  165.             zipFile = new ZipFile(zip);
  166.             this.updateTemplates(zipFile);
  167.         }catch(Exception e){
  168.             throw new ProtocolException(e.getMessage(),e);
  169.         }finally{
  170.             try{
  171.                 if(zipFile!=null)
  172.                     zipFile.close();
  173.             }catch(Exception eClose){
  174.                 // close
  175.             }
  176.         }
  177.     }
  178.     public void updateTemplates(ZipFile zip) throws ProtocolException{
  179.         try{
  180.             
  181.             String rootDir = null;
  182.             
  183.             boolean foundPdd = false;
  184.             boolean foundSoggetto = false;
  185.             boolean foundFruitore = false;
  186.             Map<String, Boolean> mapFound = new HashMap<String, Boolean>();
  187.             
  188.             Iterator<ZipEntry> it = ZipUtilities.entries(zip, true);
  189.             while (it.hasNext()) {
  190.                 ZipEntry zipEntry = (ZipEntry) it.next();
  191.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  192.                 
  193.                 //System.out.println("FILE NAME:  "+entryName);
  194.                 //System.out.println("SIZE:  "+entry.getSize());

  196.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  197.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  198.                 if(rootDir==null){
  199.                     // Calcolo ROOT DIR
  200.                     rootDir=ZipUtilities.getRootDir(entryName);
  201.                 }
  202.                 
  203.                 if(zipEntry.isDirectory()) {
  204.                     continue; // directory
  205.                 }
  206.                 else {
  207.                     FileDataSource fds = new FileDataSource(entryName);
  208.                     String nome = fds.getName();
  209.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  210.                     tipo = tipo.toUpperCase();
  211.                     //System.out.println("VERIFICARE NAME["+nome+"] TIPO["+tipo+"]");
  212.                     
  213.                     InputStream inputStream = zip.getInputStream(zipEntry);
  214.                     byte[]xml = Utilities.getAsByteArray(inputStream);

  216.                     try{
  217.                         
  218.                         // ********** configurazione ****************
  219.                         String rootDirNameExpected = this.rootDirName+File.separatorChar;
  220.                         if(rootDir.equals(rootDirNameExpected) ){
  221.                                                         
  222.                             if(entryName.endsWith("."+CostantiAbstraction.FTL_EXTENSION) == false ){
  223.                                 throw new ProtocolException("Elemento ["+entryName+"] non atteso (E' richiesto un file template .ftl)");
  224.                             }
  225.                             
  226.                             if(entryName.startsWith(rootDirNameExpected+CostantiAbstraction.TEMPLATES_PDD+File.separatorChar) ){
  227.                                 if(foundPdd==true){
  228.                                     throw new ProtocolException("Elemento ["+entryName+"] non atteso (E' possibile indicare solamente una definizione di porta di dominio)");
  229.                                 }
  230.                                 this.pdd = xml;
  231.                                 foundPdd = true;
  232.                             }
  233.                             else if(entryName.startsWith(rootDirNameExpected+CostantiAbstraction.TEMPLATES_SOGGETTO+File.separatorChar) ){
  234.                                 if(foundSoggetto==true){
  235.                                     throw new ProtocolException("Elemento ["+entryName+"] non atteso (E' possibile indicare solamente una definizione di soggetto)");
  236.                                 }
  237.                                 this.soggetto = xml;
  238.                                 foundSoggetto = true;
  239.                             }
  240.                             else if(entryName.startsWith(rootDirNameExpected+CostantiAbstraction.TEMPLATES_FRUITORE+File.separatorChar) ){
  241.                                 if(foundFruitore==true){
  242.                                     throw new ProtocolException("Elemento ["+entryName+"] non atteso (E' possibile indicare solamente una definizione di fruitore)");
  243.                                 }
  244.                                 this.fruitore = xml;
  245.                                 foundFruitore = true;
  246.                             }
  247.                             else{
  248.                                 this.updateOtherResource(entryName, inputStream, xml, mapFound);
  249.                             }
  250.                             
  251.                         }
  252.                         else{
  253.                             throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  254.                         }
  255.                         
  256.                     }finally{
  257.                         try{
  258.                             if(inputStream!=null){
  259.                                 inputStream.close();
  260.                             }
  261.                         }catch(Exception eClose){
  262.                             // close
  263.                         }
  264.                     }
  265.                 }
  266.             }

  268.         }catch(Exception e){
  269.             throw new ProtocolException(e.getMessage(),e);
  270.         }
  271.     }
  272.     
  273.     public void updateOtherResource(String entryName,InputStream inputStream,byte[]xml,Map<String, Boolean> mapFound) throws ProtocolException{
  274.         throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  275.     }
  276. }
Created with JaCoCo 0.8.8.202204050719