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


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


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

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

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

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

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

  241.         return dati;
  242.     }

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

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

  268.         return dati;
  269.     }

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

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

  308.         dati.add(de);

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

  353.     }

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

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

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

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

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

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

  444.             }
  445.         }

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

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

  457.         return dati;
  458.     }

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

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

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

  561.         dati.add(de);

  563.         return dati;
  564.     }

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

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

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

  589.         dati.add(de);

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

  628.     }
  629.     
  630.     public static List<DataElement> getHidden(List<DataElement> dati, ConsoleHelper consoleHelper ,BaseConsoleItem item, int size) {
  631.         DataElement de = new DataElement();
  632.         de.setName(item.getId());
  633.         de.setType(DataElementType.HIDDEN);
  634.         de.setLabel(item.getLabel());
  635.         de.setSize(size);
  636.         dati.add(de);

  638.         return dati;
  639.     }

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

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

  662.         List<String> values = new ArrayList<>();
  663.         List<String> labels = new ArrayList<>();

  665.         switch(consoleItemValueType){
  666.         case BOOLEAN:
  667.             BooleanConsoleItem booleanItem = (BooleanConsoleItem) item;
  668.             Boolean selectedBooleanValue = getSelectedValue(booleanItem, defaultItemValue);
  669.             de.setSelected(selectedBooleanValue);

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

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

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

  704.         de.setValues(values);
  705.         de.setLabels(labels); 

  707.         if(item.getDefaultValueForCloseableSection() instanceof String) {
  708.             String s = (String) item.getDefaultValueForCloseableSection();
  709.             de.setValoreDefaultSelect(s);
  710.         }
  711.         
  712.         dati.add(de);

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

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

  738.         setValuesLabelsMultiSelect(consoleItemValueType, item, defaultItemValue, de);
  739.         
  740.         if(item.getDefaultValueForCloseableSection() instanceof String) {
  741.             String s = (String) item.getDefaultValueForCloseableSection();
  742.             de.setValoreDefaultMultiSelect(new String [] {s});
  743.         }
  744.         
  745.         dati.add(de);

  747.         return dati;
  748.     }
  749.     private static void setValuesLabelsMultiSelect(ConsoleItemValueType consoleItemValueType, AbstractConsoleItem<?> item, Object defaultItemValue, DataElement de) throws ProtocolException {
  750.         List<String> values = new ArrayList<>();
  751.         List<String> labels = new ArrayList<>();

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

  783.         de.setValues(values);
  784.         de.setLabels(labels); 
  785.     }

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

  815.     public static String getValueParametroTipoProprietarioAccordoServizio(String tipo){
  816.         if(ProtocolPropertiesCostanti.PARAMETRO_VALORE_PP_TIPO_ACCORDO_PARTE_COMUNE.equals(tipo)){
  817.             return ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_PROPRIETARIO_VALUE_ACCORDO_SERVIZIO_PARTE_COMUNE;
  818.         }
  819.         else{
  820.             return ProtocolPropertiesCostanti.PARAMETRO_PP_TIPO_PROPRIETARIO_VALUE_ACCORDO_SERVIZIO_COMPOSTO;
  821.         }
  822.     }
  823. }
Created with JaCoCo 0.8.8.202204050719