ProtocolPropertiesUtilities.java

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

  22. import java.util.ArrayList;
  23. import java.util.List;
  24. import java.util.Properties;

  26. import org.apache.commons.lang.StringEscapeUtils;
  27. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  28. import org.openspcoop2.core.registry.ProtocolProperty;
  29. import org.openspcoop2.protocol.sdk.ProtocolException;
  30. import org.openspcoop2.protocol.sdk.constants.ConsoleInterfaceType;
  31. import org.openspcoop2.protocol.sdk.constants.ConsoleItemType;
  32. import org.openspcoop2.protocol.sdk.constants.ConsoleItemValueType;
  33. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  34. import org.openspcoop2.protocol.sdk.properties.AbstractConsoleItem;
  35. import org.openspcoop2.protocol.sdk.properties.BaseConsoleItem;
  36. import org.openspcoop2.protocol.sdk.properties.BinaryConsoleItem;
  37. import org.openspcoop2.protocol.sdk.properties.BooleanConsoleItem;
  38. import org.openspcoop2.protocol.sdk.properties.NumberConsoleItem;
  39. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  40. import org.openspcoop2.protocol.sdk.properties.StringConsoleItem;
  41. import org.openspcoop2.protocol.sdk.properties.SubtitleConsoleItem;
  42. import org.openspcoop2.protocol.sdk.properties.TitleConsoleItem;
  43. import org.openspcoop2.utils.SortedMap;
  44. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  45. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneUtilities;
  46. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  47. import org.openspcoop2.web.lib.mvc.DataElement;
  48. import org.openspcoop2.web.lib.mvc.DataElement.STATO_APERTURA_SEZIONI;
  49. import org.openspcoop2.web.lib.mvc.DataElementInfo;
  50. import org.openspcoop2.web.lib.mvc.DataElementType;
  51. import org.openspcoop2.web.lib.mvc.Parameter;


  54. /**
  55.  * ProtocolPropertiesUtilities
  56.  *
  57.  * @author Pintori Giuliano (pintori@link.it)
  58.  * @author $Author$
  59.  * @version $Rev$, $Date$
  60.  */
  61. public class ProtocolPropertiesUtilities {
  62.     
  63.     private ProtocolPropertiesUtilities() {}


  66.     public static ConsoleInterfaceType getTipoInterfaccia(ConsoleHelper consoleHelper){
  67.         if(consoleHelper.isModalitaStandard()) {
  68.             return ConsoleInterfaceType.STANDARD;
  69.         }
  70.         if(consoleHelper.isModalitaCompleta()) {
  71.             return ConsoleInterfaceType.COMPLETA;
  72.         }
  73.         return ConsoleInterfaceType.AVANZATA;
  74.     }

  76.     private static String getPrefixErrorItemConClasse(AbstractConsoleItem<?> abItem) {
  77.         return "Item con classe ["+abItem.getClass()+"] ";
  78.     }
  79.     private static String getPrefixErrorItemConClasse(BaseConsoleItem item) {
  80.         return "Item con classe ["+item.getClass()+"] ";
  81.     }
  82.     
  83.     
  84.     public static List<DataElement> itemToDataElement(List<DataElement> dati ,
  85.             ConsoleHelper consoleHelper,
  86.             BaseConsoleItem item, Object defaultItemValue,
  87.             ConsoleOperationType consoleOperationType, 
  88.             Properties binaryChangeProperties, ProtocolProperty protocolProperty, int size) throws ProtocolException {
  89.         return itemToDataElementEngine(dati, consoleHelper,
  90.                 item, defaultItemValue, 
  91.                 consoleOperationType, 
  92.                 binaryChangeProperties, 
  93.                 protocolProperty!=null ? protocolProperty.getId() : null, 
  94.                 protocolProperty!=null ? protocolProperty.getFile() : null, 
  95.                 size,
  96.                 protocolProperty!=null && (protocolProperty.getByteFile()!=null));
  97.     }
  98.     public static List<DataElement> itemToDataElement(List<DataElement> dati ,
  99.             ConsoleHelper consoleHelper,
  100.             BaseConsoleItem item, Object defaultItemValue,
  101.             ConsoleOperationType consoleOperationType, 
  102.             Properties binaryChangeProperties, org.openspcoop2.core.config.ProtocolProperty protocolProperty, int size) throws ProtocolException {
  103.         return itemToDataElementEngine(dati, consoleHelper,
  104.                 item, defaultItemValue, 
  105.                 consoleOperationType, 
  106.                 binaryChangeProperties, 
  107.                 protocolProperty!=null ? protocolProperty.getId() : null, 
  108.                 protocolProperty!=null ? protocolProperty.getFile() : null, 
  109.                 size,
  110.                 protocolProperty!=null && (protocolProperty.getByteFile()!=null));
  111.     }
  112.     private static List<DataElement> itemToDataElementEngine(List<DataElement> dati ,
  113.             ConsoleHelper consoleHelper,
  114.             BaseConsoleItem item, Object defaultItemValue,
  115.             ConsoleOperationType consoleOperationType, 
  116.             Properties binaryChangeProperties, 
  117.             Long protocolPropertyId, String protocolPropertyFile, int size,
  118.             boolean contentSaved) throws ProtocolException {
  119.         if(item == null)
  120.             return dati;

  122.         // tipi con valore
  123.         if(item instanceof AbstractConsoleItem<?>){
  124.             AbstractConsoleItem<?> abItem = (AbstractConsoleItem<?>) item;
  125.             switch (abItem.getType()) {
  126.             case CHECKBOX:
  127.                 getCheckbox(dati,abItem, defaultItemValue, size);
  128.                 break;
  129.             case LOCK:
  130.                 getText(dati, consoleHelper,abItem, size, DataElementType.LOCK);
  131.                 break;
  132.             case LOCK_HIDDEN:
  133.                 getHidden(dati, consoleHelper, abItem, size);
  134.                 break;
  135.             case CRYPT:
  136.                 getText(dati, consoleHelper,abItem, size, DataElementType.CRYPT);
  137.                 break;
  138.             case FILE:
  139.                 getFile(dati, consoleHelper, abItem, size, consoleOperationType,binaryChangeProperties, protocolPropertyId, protocolPropertyFile, contentSaved); 
  140.                 break;
  141.             case HIDDEN:
  142.                 getHidden(dati, consoleHelper, abItem, size);
  143.                 break;
  144.             case SELECT:
  145.                 getSelect(dati,abItem, defaultItemValue, size);
  146.                 break;
  147.             case MULTI_SELECT:
  148.                 getMultiSelect(dati,abItem, defaultItemValue, size);
  149.                 break;
  150.             case TEXT:
  151.                 getText(dati, consoleHelper,abItem, size, DataElementType.TEXT);
  152.                 break;
  153.             case TEXT_AREA:
  154.                 getText(dati, consoleHelper,abItem, size, DataElementType.TEXT_AREA);
  155.                 break;
  156.             case TEXT_AREA_NO_EDIT:
  157.                 getText(dati, consoleHelper,abItem, size, DataElementType.TEXT_AREA_NO_EDIT);
  158.                 break;
  159.             case TEXT_EDIT:
  160.                 getText(dati, consoleHelper,abItem, size, DataElementType.TEXT_EDIT);
  161.                 break;
  162.             case TAGS:
  163.                 getText(dati, consoleHelper,abItem, size, DataElementType.TEXT_EDIT);
  164.                 dati.get(dati.size()-1).enableTags();
  165.                 break;
  166.             case NUMBER:
  167.                 getText(dati, consoleHelper,abItem, size, DataElementType.NUMBER);
  168.                 break;
  169.             default:
  170.                 throw new ProtocolException(getPrefixErrorItemConClasse(abItem)+"identificato come tipo AbstractConsoleItem ma con Type: ["+abItem.getType()+"] di tipo titolo o note");
  171.             }
  172.         } else {
  173.             // titoli e note
  174.             switch (item.getType()) {
  175.             case NOTE:
  176.                 getTitle(dati,item, size,DataElementType.NOTE);
  177.                 break;
  178.             case SUBTITLE:
  179.                 getTitle(dati,item, size,DataElementType.SUBTITLE);
  180.                 break;
  181.             case TITLE:
  182.                 getTitle(dati,item, size,DataElementType.TITLE);
  183.                 break;
  184.             case HIDDEN:
  185.                 getHidden(dati, consoleHelper, item, size);
  186.                 break;
  187.             default:
  188.                 throw new ProtocolException(getPrefixErrorItemConClasse(item)+"non identificato come tipo AbstractConsoleItem ma con Type: ["+item.getType()+"] non di tipo titolo o note");
  189.             }
  190.         }

  192.         return dati;
  193.     }
  194.     
  195.     public static List<DataElement> itemToDataElementAsHidden(List<DataElement> dati ,ConsoleHelper consoleHelper, BaseConsoleItem item, Object defaultItemValue,
  196.             ConsoleOperationType consoleOperationType, 
  197.             Properties binaryChangeProperties, ProtocolProperty protocolProperty, int size) throws ProtocolException {
  198.         
  199.         if(defaultItemValue!=null || consoleOperationType!=null || binaryChangeProperties!=null || protocolProperty!=null) {
  200.             // nop
  201.         }
  202.         
  203.         if(item == null)
  204.             return dati;

  206.         // tipi con valore
  207.         if(item instanceof AbstractConsoleItem<?>){
  208.             AbstractConsoleItem<?> abItem = (AbstractConsoleItem<?>) item;
  209.             switch (abItem.getType()) {
  210.             case CHECKBOX:
  211.             case LOCK:
  212.             case LOCK_HIDDEN:
  213.             case CRYPT:
  214.             case FILE:
  215.             case HIDDEN:
  216.             case SELECT:
  217.             case MULTI_SELECT:
  218.             case TEXT:
  219.             case TEXT_AREA:
  220.             case TEXT_AREA_NO_EDIT:
  221.             case TEXT_EDIT:
  222.             case TAGS:
  223.             case NUMBER:
  224.                 getHidden(dati, consoleHelper, abItem, size);
  225.                 break;
  226.             default:
  227.                 throw new ProtocolException(getPrefixErrorItemConClasse(abItem)+"identificato come tipo AbstractConsoleItem ma con Type: ["+abItem.getType()+"] di tipo titolo o note");
  228.             }
  229.         } else {
  230.             // titoli e note non vengono aggiunti lascio il controllo dei tipi per sicurezza
  231.             switch (item.getType()) {
  232.             case NOTE:
  233.             case SUBTITLE:
  234.             case TITLE:
  235.             case HIDDEN:
  236.                 break;
  237.             default:
  238.                 throw new ProtocolException(getPrefixErrorItemConClasse(item)+"non identificato come tipo AbstractConsoleItem ma con Type: ["+item.getType()+"] non di tipo titolo o note");
  239.             }
  240.         }

  242.         return dati;
  243.     }

  245.     public static List<DataElement> getTitle(List<DataElement> dati ,BaseConsoleItem item, int size, DataElementType type) {
  246.         DataElement de = new DataElement();
  247.         de.setName(item.getId());
  248.         de.setType(type);
  249.         de.setLabel(item.getLabel());
  250.         de.setSize(size);
  251.         de.setValue("");

  253.         if(ConsoleItemType.TITLE.equals(item.getType()) && item instanceof TitleConsoleItem) {
  254.             TitleConsoleItem titleItem = (TitleConsoleItem) item;
  255.             if(titleItem.isCloseable()) {
  256.                 de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);
  257.             }
  258.         }
  259.         else if(ConsoleItemType.SUBTITLE.equals(item.getType()) && item instanceof SubtitleConsoleItem) {
  260.             SubtitleConsoleItem subItem = (SubtitleConsoleItem) item;
  261.             if(subItem.isCloseable()) {
  262.                 de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);
  263.             }
  264.         }
  265.         
  266.         
  267.         dati.add(de);

  269.         return dati;
  270.     }

  272.     private static String getPrefixMessageErrorConsoleItemType(ConsoleItemValueType consoleItemValueType) {
  273.         return "Item con consoleItemType ["+consoleItemValueType+"] "; 
  274.     }
  275.     
  276.     public static List<DataElement> getText(List<DataElement> dati ,ConsoleHelper consoleHelper, AbstractConsoleItem<?> item, int size, DataElementType type) throws ProtocolException {
  277.         DataElement de = new DataElement();
  278.         de.setName(item.getId());
  279.         if(DataElementType.LOCK.equals(type)) {
  280.             // imposto il tipo insieme al valore
  281.         }
  282.         else {
  283.             de.setType(type);
  284.         }
  285.         de.setRequired(item.isRequired());
  286.         de.setLabel(item.getLabel());
  287.         de.setLabelRight(item.getLabelRight());
  288.         if(item.isReloadOnChange()) {
  289.             if(item.isReloadOnHttpPost()) {
  290.                 de.setPostBack_viaPOST(true); 
  291.             }
  292.             else {
  293.                 de.setPostBack(true); 
  294.             }
  295.         }
  296.         de.setNote(item.getNote());
  297.         de.setSize(size);
  298.         addDataElementInfo(item, de);
  299.         
  300.         ConsoleItemValueType consoleItemValueType = ProtocolPropertiesUtils.getConsoleItemValueType(item);

  302.         setTextValue(consoleItemValueType, consoleHelper, item, de, type);
  303.         
  304.         if(item.getDefaultValueForCloseableSection() instanceof String) {
  305.             String s = (String) item.getDefaultValueForCloseableSection();
  306.             de.setValoreDefault(s);
  307.         }       

  309.         dati.add(de);

  311.         return dati;
  312.     }
  313.     private static void setTextValue(ConsoleItemValueType consoleItemValueType,ConsoleHelper consoleHelper,AbstractConsoleItem<?> item,DataElement de, DataElementType type) throws ProtocolException {
  314.         String value = null;
  315.         switch(consoleItemValueType){
  316.         case BOOLEAN:
  317.             BooleanConsoleItem booleanItem = (BooleanConsoleItem) item;
  318.             value = booleanItem.getDefaultValue() != null ? booleanItem.getDefaultValue() + "" : "";
  319.             break;
  320.         case NUMBER:
  321.             NumberConsoleItem numberItem = (NumberConsoleItem) item;
  322.             value = numberItem.getDefaultValue() != null ? numberItem.getDefaultValue() + "" : "";
  323.             if(DataElementType.NUMBER.equals(type)) {
  324.                 de.setMinValue((int)numberItem.getMin());
  325.                 de.setMaxValue((int)numberItem.getMax());
  326.             }
  327.             break;
  328.         case STRING:
  329.             StringConsoleItem stringItem = (StringConsoleItem) item;
  330.             value = stringItem.getDefaultValue() != null ? stringItem.getDefaultValue() : "";
  331.             if(stringItem.getRows()!=null) {
  332.                 de.setRows(stringItem.getRows());
  333.             }
  334.             break;
  335.         case BINARY: // NOP
  336.             value = "Prova Binary";
  337.             break;
  338.         default:
  339.             throw new ProtocolException(getPrefixMessageErrorConsoleItemType(consoleItemValueType)+"non puo' essere visualizzato come un "+type);
  340.         }
  341.         
  342.         if(DataElementType.LOCK.equals(type)) {
  343.             // imposto il tipo insieme al valore
  344.             try {
  345.                 consoleHelper.getCore().getLockUtilities().lock(de, value);
  346.             }catch(Exception e) {
  347.                 throw new ProtocolException(e.getMessage(),e);
  348.             }
  349.         }
  350.         else {
  351.             de.setValue(value);
  352.         }

  354.     }

  356.     public static List<DataElement> getFile(List<DataElement> dati ,
  357.             ConsoleHelper consoleHelper,
  358.             AbstractConsoleItem<?> item, int size, ConsoleOperationType consoleOperationType, 
  359.             Properties binaryChangeProperties,
  360.             Long protocolPropertyId, String protocolPropertyFile,
  361.             boolean contentSaved) {
  362.         
  363.         if(consoleHelper!=null) {
  364.             // nop
  365.         }
  366.         
  367.         DataElement de = new DataElement();
  368.         DataElement de2 =null ;
  369.         List<DataElement> df = null;
  370.         de.setName(item.getId());

  372.         /**String nameRechange = ProtocolPropertiesCostanti.PARAMETER_FILENAME_RECHANGE_PREFIX + item.getId();
  373.         String nameRechangeParamTmp = consoleHelper.getParameter(nameRechange);
  374.         boolean isNameRechange = "true".equals(nameRechangeParamTmp);
  375.         
  376.         org.openspcoop2.protocol.sdk.properties.BinaryConsoleItem bci = null;
  377.         String fileName = null;
  378.         if(item!=null && item instanceof org.openspcoop2.protocol.sdk.properties.BinaryConsoleItem) {
  379.             bci = (org.openspcoop2.protocol.sdk.properties.BinaryConsoleItem) item;
  380.             fileName = bci.getFileName();
  381.         }
  382.         if(!consoleOperationType.equals(ConsoleOperationType.ADD) && fileName==null) {
  383.             // aggiungo riferimento per dopo
  384.             DataElement deChange = new DataElement();
  385.             deChange.setName(nameRechange);
  386.             deChange.setValue("true");
  387.             deChange.setType(DataElementType.HIDDEN);
  388.             dati.add(deChange);
  389.         }*/
  390.         
  391.         /**boolean addDE = true;*/
  392.         
  393.         if(consoleOperationType.equals(ConsoleOperationType.ADD) || !contentSaved){
  394.             BinaryConsoleItem binaryItem = (BinaryConsoleItem) item;

  396.             BinaryParameter bp = new BinaryParameter();
  397.             bp.setName(binaryItem.getId());
  398.             bp.setFilename(binaryItem.getFileName());
  399.             bp.setId(binaryItem.getFileId());

  401.             de = bp.getFileDataElement(item.getLabel(), "", size);
  402.             de.setRequired(item.isRequired());
  403.             /**         de.setPostBack(item.isReloadOnChange()); */ 
  404.             df = bp.getFileNameDataElement();
  405.             de2 = bp.getFileIdDataElement();
  406.         } else {
  407.             
  408.             /**if(fileName==null || isNameRechange) {
  409.                 addDE = false;
  410.             }*/
  411.             
  412.             de.setType(DataElementType.LINK);
  413.             String idItem = protocolPropertyId != null ? protocolPropertyId + "" : ""; 
  414.             String idProprietario = binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_ID_PROPRIETARIO);
  415.             String urlChange= binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_URL_ORIGINALE_CHANGE);
  416.             String tipoProprietario = binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_PROPRIETARIO);
  417.             String nomeProprietario = binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_NOME_PROPRIETARIO);
  418.             String parentProprietario = binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_NOME_PARENT_PROPRIETARIO);
  419.             if(parentProprietario == null)
  420.                 parentProprietario = "";
  421.             String protocollo = binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_PROTOCOLLO);
  422.             String tipoAccordo = binaryChangeProperties.getProperty(ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_ACCORDO);
  423.             if(tipoAccordo == null)
  424.                 tipoAccordo = "";

  426.             de.setUrl(ProtocolPropertiesCostanti.SERVLET_NAME_BINARY_PROPERTY_CHANGE, 
  427.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_ID,idItem),
  428.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_NOME,item.getId()),
  429.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_ID_PROPRIETARIO,idProprietario),
  430.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_PROPRIETARIO,tipoProprietario),
  431.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_NOME_PROPRIETARIO,nomeProprietario),
  432.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_NOME_PARENT_PROPRIETARIO,parentProprietario),
  433.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_PROTOCOLLO,protocollo),
  434.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_ACCORDO, tipoAccordo),
  435.                     new Parameter(ProtocolPropertiesCostanti.PARAMETRO_PP_URL_ORIGINALE_CHANGE,urlChange));
  436.             // CHANGE Label del link
  437.             de.setValue(item.getLabel());

  439.             if(protocolPropertyFile != null){
  440.                 de2 = new DataElement();
  441.                 de2.setName(ProtocolPropertiesCostanti.PARAMETER_FILENAME_PREFIX + item.getId());
  442.                 de2.setValue(protocolPropertyFile);
  443.                 de2.setType(DataElementType.HIDDEN);

  445.             }
  446.         }

  448.         /**if(addDE) {*/
  449.         dati.add(de);
  450.         /**}*/
  451.         
  452.         if(df != null)
  453.             dati.addAll(df);

  455.         if(de2 != null)
  456.             dati.add(de2);

  458.         return dati;
  459.     }

  461.     private static void addDataElementInfo(AbstractConsoleItem<?> item, DataElement de) {
  462.         if(item.getInfo()!=null) {
  463.             DataElementInfo dInfo = new DataElementInfo(item.getInfo().getHeaderFinestraModale());
  464.             dInfo.setHeaderBody(StringEscapeUtils.escapeHtml(item.getInfo().getHeaderBody()));
  465.             if(item.getInfo().getListBody()!=null && !item.getInfo().getListBody().isEmpty()) {
  466.                 List<String> escapedValues = new ArrayList<>();
  467.                 for (String v : item.getInfo().getListBody()) {
  468.                     escapedValues.add(StringEscapeUtils.escapeHtml(v));
  469.                 }
  470.                 dInfo.setListBody(escapedValues);
  471.             }
  472.             de.setInfo(dInfo);
  473.         }
  474.     }
  475.     
  476.     private static Boolean getSelectedValue(BooleanConsoleItem booleanItem, Object defaultItemValue) {
  477.         Boolean selectedBooleanValue = null;
  478.         if(booleanItem.getDefaultValue() != null) {
  479.             selectedBooleanValue = booleanItem.getDefaultValue();
  480.         }
  481.         else if(defaultItemValue instanceof Boolean) {
  482.             selectedBooleanValue = (Boolean) defaultItemValue;
  483.         }
  484.         else {
  485.             selectedBooleanValue = false;
  486.         }
  487.         return selectedBooleanValue;
  488.     }
  489.     private static String getSelectedValue(NumberConsoleItem numberItem, Object defaultItemValue) {
  490.         String selectedNumberValue = null;
  491.         if(numberItem.getDefaultValue()!=null) {
  492.             selectedNumberValue = numberItem.getDefaultValue() + "";
  493.         }
  494.         else if(defaultItemValue instanceof Long) {
  495.             selectedNumberValue = (defaultItemValue) + "";
  496.         }
  497.         else if(defaultItemValue instanceof Integer) {
  498.             selectedNumberValue = (defaultItemValue) + "";
  499.         }
  500.         else {
  501.             selectedNumberValue = null;
  502.         }
  503.         return selectedNumberValue;
  504.     }
  505.     private static String getSelectedValue(StringConsoleItem stringItem, Object defaultItemValue) {
  506.         String selectedStringValue = null;
  507.         if(stringItem.getDefaultValue()!=null) {
  508.             selectedStringValue = stringItem.getDefaultValue();
  509.         }
  510.         else if(defaultItemValue instanceof String) {
  511.             selectedStringValue = ((String) defaultItemValue);
  512.         }
  513.         else {
  514.             selectedStringValue = null;
  515.         }
  516.         return selectedStringValue;
  517.     }
  518.     
  519.     public static List<DataElement> getCheckbox(List<DataElement> dati ,AbstractConsoleItem<?> item, Object defaultItemValue, int size) throws ProtocolException{
  520.         DataElement de = new DataElement();
  521.         de.setName(item.getId());
  522.         de.setType(DataElementType.CHECKBOX);
  523.         de.setRequired(item.isRequired());
  524.         de.setLabel(item.getLabel());
  525.         de.setLabelRight(item.getLabelRight());
  526.         if(item.isReloadOnChange()) {
  527.             if(item.isReloadOnHttpPost()) {
  528.                 de.setPostBack_viaPOST(true); 
  529.             }
  530.             else {
  531.                 de.setPostBack(true); 
  532.             }
  533.         }
  534.         de.setNote(item.getNote());
  535.         de.setSize(size);
  536.         addDataElementInfo(item, de);

  538.         ConsoleItemValueType consoleItemValueType = ProtocolPropertiesUtils.getConsoleItemValueType(item);

  540.         switch(consoleItemValueType){
  541.         case BOOLEAN:
  542.             BooleanConsoleItem booleanItem = (BooleanConsoleItem) item;
  543.             Boolean selectedBooleanValue = getSelectedValue(booleanItem, defaultItemValue);
  544.             de.setSelected(selectedBooleanValue);
  545.             break;
  546.         case NUMBER:
  547.             NumberConsoleItem numberItem = (NumberConsoleItem) item;
  548.             String selectedNumberValue = getSelectedValue(numberItem, defaultItemValue);
  549.             de.setSelected(selectedNumberValue);
  550.             break;
  551.         case STRING:
  552.             StringConsoleItem stringItem = (StringConsoleItem) item;
  553.             String selectedStringValue = getSelectedValue(stringItem, defaultItemValue);
  554.             de.setSelected(selectedStringValue);
  555.             break;
  556.         case BINARY: // non supportato 
  557.         default:
  558.             throw new ProtocolException(getPrefixMessageErrorConsoleItemType(consoleItemValueType)+"non puo' essere visualizzato come una CheckBox");
  559.         }
  560.         
  561.         if(item.getDefaultValueForCloseableSection() instanceof Boolean) {
  562.             boolean b = (Boolean) item.getDefaultValueForCloseableSection();
  563.             de.setValoreDefaultCheckbox(b);
  564.         }

  566.         dati.add(de);

  568.         return dati;
  569.     }

  571.     public static List<DataElement> getHidden(List<DataElement> dati, ConsoleHelper consoleHelper, AbstractConsoleItem<?> item, int size) throws ProtocolException {
  572.         DataElement de = new DataElement();
  573.         de.setName(item.getId());
  574.         de.setType(DataElementType.HIDDEN);
  575.         de.setRequired(item.isRequired());
  576.         de.setLabel(item.getLabel());
  577.         de.setLabelRight(item.getLabelRight());
  578.         if(item.isReloadOnChange()) {
  579.             if(item.isReloadOnHttpPost()) {
  580.                 de.setPostBack_viaPOST(true); 
  581.             }
  582.             else {
  583.                 de.setPostBack(true); 
  584.             }
  585.         }
  586.         de.setNote(item.getNote());
  587.         de.setSize(size);
  588.         /**addDataElementInfo(item, de);*/

  590.         ConsoleItemValueType consoleItemValueType = ProtocolPropertiesUtils.getConsoleItemValueType(item);

  592.         setHiddenValue(consoleItemValueType, consoleHelper, item, de);

  594.         dati.add(de);

  596.         return dati;
  597.     }
  598.     private static void setHiddenValue(ConsoleItemValueType consoleItemValueType,ConsoleHelper consoleHelper,AbstractConsoleItem<?> item,DataElement de) throws ProtocolException {
  599.         
  600.         String value = null;
  601.         switch(consoleItemValueType){
  602.         case BOOLEAN:
  603.             BooleanConsoleItem booleanItem = (BooleanConsoleItem) item;
  604.             value = booleanItem.getDefaultValue() != null ? booleanItem.getDefaultValue() + "" : "";
  605.             break;
  606.         case NUMBER:
  607.             NumberConsoleItem numberItem = (NumberConsoleItem) item;
  608.             value = numberItem.getDefaultValue() != null ? numberItem.getDefaultValue() + "" : "";
  609.             break;
  610.         case STRING:
  611.             StringConsoleItem stringItem = (StringConsoleItem) item;
  612.             value = stringItem.getDefaultValue() != null ? stringItem.getDefaultValue() + "" : "";
  613.             break;
  614.         case BINARY: // NOP
  615.             value = "";
  616.             break;
  617.         default:
  618.             throw new ProtocolException(getPrefixMessageErrorConsoleItemType(consoleItemValueType)+"non puo' essere visualizzato come una Hidden");
  619.         }
  620.         
  621.         if(item.isLockedType()) {
  622.             // imposto il tipo insieme al valore
  623.             try {
  624.                 consoleHelper.getCore().getLockUtilities().lockHidden(de, value);
  625.             }catch(Exception e) {
  626.                 throw new ProtocolException(e.getMessage(),e);
  627.             }
  628.         }
  629.         else {
  630.             de.setValue(value);
  631.         }

  633.     }
  634.     
  635.     public static List<DataElement> getHidden(List<DataElement> dati, ConsoleHelper consoleHelper ,BaseConsoleItem item, int size) {
  636.         DataElement de = new DataElement();
  637.         de.setName(item.getId());
  638.         de.setType(DataElementType.HIDDEN);
  639.         de.setLabel(item.getLabel());
  640.         de.setSize(size);
  641.         dati.add(de);

  643.         return dati;
  644.     }

  646.     public static List<DataElement> getSelect(List<DataElement> dati ,AbstractConsoleItem<?> item, Object defaultItemValue, int size) throws ProtocolException {
  647.         DataElement de = new DataElement();
  648.         de.setName(item.getId());
  649.         de.setType(DataElementType.SELECT);
  650.         de.setRequired(item.isRequired());
  651.         de.setLabel(item.getLabel());
  652.         de.setLabelRight(item.getLabelRight());
  653.         if(item.isReloadOnChange()) {
  654.             if(item.isReloadOnHttpPost()) {
  655.                 de.setPostBack_viaPOST(true); 
  656.             }
  657.             else {
  658.                 de.setPostBack(true); 
  659.             }
  660.         }
  661.         de.setNote(item.getNote());
  662.         de.setSize(size);
  663.         addDataElementInfo(item, de);

  665.         ConsoleItemValueType consoleItemValueType = ProtocolPropertiesUtils.getConsoleItemValueType(item);

  667.         List<String> values = new ArrayList<>();
  668.         List<String> labels = new ArrayList<>();

  670.         switch(consoleItemValueType){
  671.         case BOOLEAN:
  672.             BooleanConsoleItem booleanItem = (BooleanConsoleItem) item;
  673.             Boolean selectedBooleanValue = getSelectedValue(booleanItem, defaultItemValue);
  674.             de.setSelected(selectedBooleanValue);

  676.             SortedMap<Boolean> booleanMapLabelValues = booleanItem.getMapLabelValues();
  677.             for (String key : booleanMapLabelValues.keys()) {
  678.                 labels.add(key);
  679.                 values.add(booleanMapLabelValues.get(key)+ "");
  680.             }
  681.             break;
  682.         case NUMBER:
  683.             NumberConsoleItem numberItem = (NumberConsoleItem) item;
  684.             String selectedNumberValue = getSelectedValue(numberItem, defaultItemValue);
  685.             de.setSelected(selectedNumberValue);

  687.             SortedMap<Long> numberMapLabelValues = numberItem.getMapLabelValues();
  688.             for (String key : numberMapLabelValues.keys()) {
  689.                 labels.add(key);
  690.                 values.add(numberMapLabelValues.get(key)+ "");
  691.             }
  692.             break;
  693.         case STRING:
  694.             StringConsoleItem stringItem = (StringConsoleItem) item;
  695.             String selectedStringValue = getSelectedValue(stringItem, defaultItemValue);
  696.             de.setSelected(selectedStringValue);

  698.             SortedMap<String> stringMapLabelValues = stringItem.getMapLabelValues();
  699.             for (String key : stringMapLabelValues.keys()) {
  700.                 labels.add(key);
  701.                 values.add(stringMapLabelValues.get(key)+ "");
  702.             }
  703.             break;
  704.         case BINARY: // non supportato 
  705.         default:
  706.             throw new ProtocolException(getPrefixMessageErrorConsoleItemType(consoleItemValueType)+"non puo' essere visualizzato come una Select List");
  707.         }

  709.         de.setValues(values);
  710.         de.setLabels(labels); 

  712.         if(item.getDefaultValueForCloseableSection() instanceof String) {
  713.             String s = (String) item.getDefaultValueForCloseableSection();
  714.             de.setValoreDefaultSelect(s);
  715.         }
  716.         
  717.         dati.add(de);

  719.         return dati;
  720.     }
  721.     
  722.     public static List<DataElement> getMultiSelect(List<DataElement> dati ,AbstractConsoleItem<?> item, Object defaultItemValue, int size) throws ProtocolException {
  723.         DataElement de = new DataElement();
  724.         de.setName(item.getId());
  725.         de.setType(DataElementType.MULTI_SELECT);
  726.         de.setRequired(item.isRequired());
  727.         de.setLabel(item.getLabel());
  728.         de.setLabelRight(item.getLabelRight());
  729.         if(item.isReloadOnChange()) {
  730.             if(item.isReloadOnHttpPost()) {
  731.                 de.setPostBack_viaPOST(true); 
  732.             }
  733.             else {
  734.                 de.setPostBack(true); 
  735.             }
  736.         }
  737.         de.setNote(item.getNote());
  738.         de.setSize(size);
  739.         addDataElementInfo(item, de);

  741.         ConsoleItemValueType consoleItemValueType = ProtocolPropertiesUtils.getConsoleItemValueType(item);

  743.         setValuesLabelsMultiSelect(consoleItemValueType, item, defaultItemValue, de);
  744.         
  745.         if(item.getDefaultValueForCloseableSection() instanceof String) {
  746.             String s = (String) item.getDefaultValueForCloseableSection();
  747.             de.setValoreDefaultMultiSelect(new String [] {s});
  748.         }
  749.         
  750.         dati.add(de);

  752.         return dati;
  753.     }
  754.     private static void setValuesLabelsMultiSelect(ConsoleItemValueType consoleItemValueType, AbstractConsoleItem<?> item, Object defaultItemValue, DataElement de) throws ProtocolException {
  755.         List<String> values = new ArrayList<>();
  756.         List<String> labels = new ArrayList<>();

  758.         switch(consoleItemValueType){
  759.         case STRING:
  760.             StringConsoleItem stringItem = (StringConsoleItem) item;
  761.             String selectedStringValue = getSelectedValue(stringItem, defaultItemValue);
  762.             if(selectedStringValue!=null) {
  763.                 if(selectedStringValue.contains(",")) {
  764.                     de.setSelezionati(selectedStringValue.split(","));
  765.                 }
  766.                 else {
  767.                     de.setSelezionati(new String[] {selectedStringValue});
  768.                 }
  769.             }
  770.             if(stringItem.getRows()!=null) {
  771.                 de.setRows(stringItem.getRows());
  772.             }
  773.             
  774.             SortedMap<String> stringMapLabelValues = stringItem.getMapLabelValues();
  775.             for (String key : stringMapLabelValues.keys()) {
  776.                 labels.add(key);
  777.                 values.add(stringMapLabelValues.get(key)+ "");
  778.             }
  779.             break;
  780.         
  781.         case BINARY:
  782.         case BOOLEAN:
  783.         case NUMBER:
  784.         default:
  785.             throw new ProtocolException(getPrefixMessageErrorConsoleItemType(consoleItemValueType)+"non puo' essere visualizzato come una Multi-Select List");
  786.         }

  788.         de.setValues(values);
  789.         de.setLabels(labels); 
  790.     }

  792.     public static String getLabelTipoProprietario(ProprietariProtocolProperty tipoProprietario, String tipoAccordo) {
  793.         if(tipoProprietario != null){
  794.             switch (tipoProprietario) {
  795.             case ACCORDO_COOPERAZIONE:
  796.                 return ProtocolPropertiesCostanti.LABEL_AC;
  797.             case ACCORDO_SERVIZIO_PARTE_COMUNE:
  798.                 return AccordiServizioParteComuneUtilities.getTerminologiaAccordoServizio(tipoAccordo);
  799.             case ACCORDO_SERVIZIO_PARTE_SPECIFICA:
  800.                 return ProtocolPropertiesCostanti.LABEL_APS;
  801.             case AZIONE_ACCORDO:
  802.                 return ProtocolPropertiesCostanti.LABEL_AZIONE_ACCORDO;
  803.             case FRUITORE:
  804.                 return ProtocolPropertiesCostanti.LABEL_FRUITORE;
  805.             case OPERATION:
  806.                 return ProtocolPropertiesCostanti.LABEL_OPERATION;
  807.             case PORT_TYPE:
  808.                 return ProtocolPropertiesCostanti.LABEL_PORT_TYPE;
  809.             case RESOURCE:
  810.                 return ProtocolPropertiesCostanti.LABEL_RESOURCE;
  811.             case SOGGETTO:
  812.                 return ProtocolPropertiesCostanti.LABEL_SOGGETTO;
  813.             case SERVIZIO_APPLICATIVO:
  814.                 return ProtocolPropertiesCostanti.LABEL_SERVIZIO_APPLICATIVO;
  815.             }
  816.         }
  817.         return null;
  818.     }

  820.     public static String getValueParametroTipoProprietarioAccordoServizio(String tipo){
  821.         if(ProtocolPropertiesCostanti.PARAMETRO_VALORE_PP_TIPO_ACCORDO_PARTE_COMUNE.equals(tipo)){
  822.             return ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_PROPRIETARIO_VALUE_ACCORDO_SERVIZIO_PARTE_COMUNE;
  823.         }
  824.         else{
  825.             return ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_PROPRIETARIO_VALUE_ACCORDO_SERVIZIO_COMPOSTO;
  826.         }
  827.     }
  828. }
Created with JaCoCo 0.8.8.202204050719