FunctionField.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.generic_project.beans;

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

  25. import org.openspcoop2.generic_project.exception.ExpressionException;

  27. /**
  28.  * FunctionField
  29.  * 
  30.  * @author Poli Andrea (apoli@link.it)
  31.  * @author $Author$
  32.  * @version $Rev$, $Date$
  33.  */
  34. public class FunctionField {

  36.     // campi per la funct
  37.     private String functionValue;
  38.     private Class<?> functionValueType;
  39.     private List<IField> fields = new ArrayList<IField>();
  40.     private String operator;
  41.     
  42.     // function
  43.     private Function function;
  44.     private boolean customFunction;
  45.     private String prefixFunctionCustom;
  46.     private String suffixFunctionCustom;
  47.     
  48.     // alias
  49.     private String alias;
  50.     
  51.     
  52.     private void checkAlias() throws ExpressionException{
  53.         if(this.function!=null && this.alias!=null){
  54.             
  55.             // hsql le utilizza come chiavi
  56.             
  57.             if("count".equalsIgnoreCase(this.alias) && Function.COUNT.equals(this.function) ){
  58.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function COUNT"); 
  59.             }
  60.             
  61.             if("count".equalsIgnoreCase(this.alias) && Function.COUNT_DISTINCT.equals(this.function) ){
  62.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function COUNT"); 
  63.             }
  64.             
  65.             if("avg".equalsIgnoreCase(this.alias) && Function.AVG.equals(this.function) ){
  66.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function AVG"); 
  67.             }
  68.             
  69.             if("avg".equalsIgnoreCase(this.alias) && Function.AVG_DOUBLE.equals(this.function) ){
  70.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function AVG_DOUBLE"); 
  71.             }
  72.             
  73.             if("max".equalsIgnoreCase(this.alias) && Function.MAX.equals(this.function) ){
  74.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function MAX"); 
  75.             }
  76.             
  77.             if("min".equalsIgnoreCase(this.alias) && Function.MIN.equals(this.function) ){
  78.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function MIN"); 
  79.             }
  80.             
  81.             if("sum".equalsIgnoreCase(this.alias) && Function.SUM.equals(this.function) ){
  82.                 throw new ExpressionException("Alias ["+this.alias+"] is not allowed with the function SUM"); 
  83.             }
  84.         }
  85.     }
  86.     
  87.     
  88.     /**
  89.      * Esempio di utilizzo di una funzione conosciuta su di un field
  90.      **/
  91.     public FunctionField(IField field,Function function,String alias) throws ExpressionException{
  92.         if(field==null){
  93.             throw new ExpressionException("IField is null");
  94.         }
  95.         if(function==null){
  96.             throw new ExpressionException("Function is null");
  97.         }
  98.         if(alias==null){
  99.             throw new ExpressionException("Alias is null");
  100.         }

  102.         this.fields.add(field);
  103.         this.function = function;
  104.         this.alias = alias;
  105.         this.customFunction = false;
  106.         this.checkAlias();
  107.     }
  108.     
  109.     /**
  110.      * Esempio di utilizzo di una funzione conosciuta su piu' fields uniti da uno stesso operatore (F1 operator F2 operator ... FN)
  111.      **/
  112.     public FunctionField(Function function,String alias,String operator,IField ... field) throws ExpressionException{

  114.         if(function==null){
  115.             throw new ExpressionException("Function is null");
  116.         }
  117.         if(alias==null){
  118.             throw new ExpressionException("Alias is null");
  119.         }
  120.         if(operator==null){
  121.             throw new ExpressionException("Operator is null");
  122.         }

  124.         if(field==null || field.length<=0){
  125.             throw new ExpressionException("IField is null");
  126.         }
  127.         if(field.length<2){
  128.             throw new ExpressionException("IField less then 2. With operator constructor is required almost two field");
  129.         }
  130.         Class<?> cField = null;
  131.         for (int i = 0; i < field.length; i++) {
  132.             if(i==0){
  133.                 cField = field[i].getFieldType();
  134.             }
  135.             else{
  136.                 String cFieldName = cField.getName() + "";
  137.                 String fieldName = field[i].getFieldType().getName() + "";
  138.                 if(cFieldName.equals(fieldName)==false){
  139.                     throw new ExpressionException("Fields aren't same type [0]="+cField.getClass().getName()+" ["+i+"]="+field[i].getFieldType().getName());
  140.                 }
  141.             }
  142.             this.fields.add(field[i]);
  143.         }
  144.         this.function = function;
  145.         this.alias = alias;
  146.         this.operator = operator;
  147.         this.customFunction = false;
  148.         this.checkAlias();
  149.     }
  150.     
  151.     /**
  152.      * Esempio di utilizzo di una funzione conosciuta su dei valori input based (functionValue)
  153.      **/
  154.     public FunctionField(String functionValue,Class<?> functionValueType,Function function,String alias) throws ExpressionException{
  155.         if(functionValue==null){
  156.             throw new ExpressionException("functionValue is null");
  157.         }
  158.         if(functionValueType==null){
  159.             throw new ExpressionException("functionValueType is null");
  160.         }
  161.         if(function==null){
  162.             throw new ExpressionException("Function is null");
  163.         }
  164.         if(alias==null){
  165.             throw new ExpressionException("Alias is null");
  166.         }
  167.         this.functionValue = functionValue;
  168.         this.functionValueType = functionValueType;
  169.         this.function = function;
  170.         this.alias = alias;
  171.         this.customFunction = false;
  172.         this.checkAlias();
  173.     }
  174.     
  175.     /**
  176.      * Esempio di utilizzo di una funzione custom su di un field
  177.      **/
  178.     public FunctionField(IField field,String prefixFunctionCustom,String suffixFunctionCustom,String alias) throws ExpressionException{
  179.         if(field==null){
  180.             throw new ExpressionException("IField is null");
  181.         }
  182.         if(prefixFunctionCustom==null){
  183.             throw new ExpressionException("prefixFunctionCustom is null");
  184.         }
  185.         if(suffixFunctionCustom==null){
  186.             throw new ExpressionException("suffixFunctionCustom is null");
  187.         }
  188.         if(alias==null){
  189.             throw new ExpressionException("Alias is null");
  190.         }
  191.         this.fields.add(field);
  192.         this.prefixFunctionCustom = prefixFunctionCustom;
  193.         this.suffixFunctionCustom = suffixFunctionCustom;
  194.         this.alias = alias;
  195.         this.customFunction = true;
  196.         this.checkAlias();
  197.     }
  198.     
  199.     /**
  200.      * Esempio di utilizzo di una funzione custom su piu' fields uniti da uno stesso operatore (F1 operator F2 operator ... FN)
  201.      **/
  202.     public FunctionField(String prefixFunctionCustom,String suffixFunctionCustom,String alias,String operator,IField ... field) throws ExpressionException{

  204.         if(prefixFunctionCustom==null){
  205.             throw new ExpressionException("prefixFunctionCustom is null");
  206.         }
  207.         if(suffixFunctionCustom==null){
  208.             throw new ExpressionException("suffixFunctionCustom is null");
  209.         }
  210.         if(alias==null){
  211.             throw new ExpressionException("Alias is null");
  212.         }
  213.         if(operator==null){
  214.             throw new ExpressionException("Operator is null");
  215.         }

  217.         if(field==null || field.length<=0){
  218.             throw new ExpressionException("IField is null");
  219.         }
  220.         if(field.length<2){
  221.             throw new ExpressionException("IField less then 2. With operator constructor is required almost two field");
  222.         }
  223.         Class<?> cField = null;
  224.         for (int i = 0; i < field.length; i++) {
  225.             if(i==0){
  226.                 cField = field[i].getFieldType();
  227.             }
  228.             else{
  229.                 String cFieldName = cField.getName() + "";
  230.                 String fieldName = field[i].getFieldType().getName() + "";
  231.                 if(cFieldName.equals(fieldName)==false){
  232.                     throw new ExpressionException("Fields aren't same type [0]="+cField.getClass().getName()+" ["+i+"]="+field[i].getFieldType().getName());
  233.                 }
  234.             }
  235.             this.fields.add(field[i]);
  236.         }
  237.         this.prefixFunctionCustom = prefixFunctionCustom;
  238.         this.suffixFunctionCustom = suffixFunctionCustom;
  239.         this.alias = alias;
  240.         this.operator = operator;
  241.         this.customFunction = true;
  242.         this.checkAlias();
  243.     }
  244.     
  245.     /**
  246.      * Esempio di utilizzo di una funzione custom su dei valori input based (functionValue)
  247.      **/
  248.     public FunctionField(String functionValue,Class<?> functionValueType,String prefixFunctionCustom,String suffixFunctionCustom,String alias) throws ExpressionException{
  249.         if(functionValue==null){
  250.             throw new ExpressionException("functionValue is null");
  251.         }
  252.         if(functionValueType==null){
  253.             throw new ExpressionException("functionValueType is null");
  254.         }
  255.         if(prefixFunctionCustom==null){
  256.             throw new ExpressionException("prefixFunctionCustom is null");
  257.         }
  258.         if(suffixFunctionCustom==null){
  259.             throw new ExpressionException("suffixFunctionCustom is null");
  260.         }
  261.         if(alias==null){
  262.             throw new ExpressionException("Alias is null");
  263.         }
  264.         this.functionValue = functionValue;
  265.         this.functionValueType = functionValueType;
  266.         this.prefixFunctionCustom = prefixFunctionCustom;
  267.         this.suffixFunctionCustom = suffixFunctionCustom;
  268.         this.alias = alias;
  269.         this.customFunction = true;
  270.         this.checkAlias();
  271.     }
  272.     
  273.     
  274.     
  275.     public String getFunctionValue() {
  276.         return this.functionValue;
  277.     }
  278.     public Class<?> getFunctionValueType() {
  279.         return this.functionValueType;
  280.     }
  281.     public List<IField> getFields() {
  282.         return this.fields;
  283.     }
  284.     public String getOperator() {
  285.         return this.operator;
  286.     }
  287.     public Class<?> getFieldType(){
  288.         if(this.functionValueType!=null){
  289.             return this.functionValueType;
  290.         }
  291.         else{
  292.             if(this.function!=null && Function.AVG_DOUBLE.equals(this.function)){
  293.                 return Double.class;
  294.             }
  295.             else{
  296.                 // devono essere tutti dello stesso tipo
  297.                 return this.fields.get(0).getFieldType();
  298.             }
  299.         }
  300.     }
  301.     
  302.     
  303.     public boolean isCustomFunction() {
  304.         return this.customFunction;
  305.     }
  306.     public Function getFunction() {
  307.         return this.function;
  308.     }
  309.     public String getPrefixFunctionCustom() {
  310.         return this.prefixFunctionCustom;
  311.     }
  312.     public String getSuffixFunctionCustom() {
  313.         return this.suffixFunctionCustom;
  314.     }
  315.     
  316.         
  317.     public String getAlias() {
  318.         return this.alias;
  319.     }



  323.     
  324.     @Override
  325.     public boolean equals(Object o){
  326.         if(o instanceof FunctionField){
  327.             return this.equals((FunctionField)o);
  328.         }
  329.         else{
  330.             return false;
  331.         }
  332.     }
  333.     public boolean equals(FunctionField o){
  334.         if(o==null){
  335.             return false;
  336.         }
  337.         
  338.         if(this.functionValue==null){
  339.             if(o.getFunctionValue()!=null){
  340.                 return false;
  341.             }
  342.         }
  343.         else {
  344.             if(this.functionValue.equals(o.getFunctionValue())==false){
  345.                 return false;
  346.             }
  347.         }
  348.         
  349.         if(this.functionValueType==null){
  350.             if(o.getFunctionValueType()!=null){
  351.                 return false;
  352.             }
  353.         }
  354.         else {
  355.             if(o.getFunctionValueType()==null){
  356.                 return false;
  357.             }
  358.             String functionValueTypeName = this.functionValueType.getName() + "";
  359.             String oFunctionValueTypeName = o.getFunctionValueType().getName() + "";
  360.             if(functionValueTypeName.equals(oFunctionValueTypeName)==false){
  361.                 return false;
  362.             }
  363.         }
  364.         
  365.         if(this.getFields().size()!=o.getFields().size()){
  366.             return false;
  367.         }
  368.         for (IField field : this.fields) {
  369.             boolean find = false;
  370.             for (IField fieldParam : o.getFields()) {
  371.                 if(fieldParam.equals(field)){
  372.                     find = true;
  373.                     break;
  374.                 }
  375.             }
  376.             if(!find){
  377.                 return false;
  378.             }
  379.         }
  380.         for (IField fieldParam : o.getFields()) {
  381.             boolean find = false;
  382.             for (IField field : this.fields) {
  383.                 if(fieldParam.equals(field)){
  384.                     find = true;
  385.                     break;
  386.                 }
  387.             }
  388.             if(!find){
  389.                 return false;
  390.             }
  391.         }

  393.         
  394.         if(o.getOperator()==null){
  395.             if(this.operator!=null)
  396.                 return false;
  397.         }
  398.         else{
  399.             if(o.getOperator().equals(this.operator)==false){
  400.                 return false;
  401.             }
  402.         }
  403.         
  404.         if(this.customFunction != o.isCustomFunction() ){
  405.             return false;
  406.         }

  408.         if(this.function==null){
  409.             if(o.getFunction()!=null){
  410.                 return false;
  411.             }
  412.         }
  413.         else {
  414.             if(o.getFunction()==null){
  415.                 return false;
  416.             }
  417.             if(this.function.name().equals(o.getFunction().name())==false){
  418.                 return false;
  419.             }
  420.         }

  422.         if(this.prefixFunctionCustom==null){
  423.             if(o.getPrefixFunctionCustom()!=null){
  424.                 return false;
  425.             }
  426.         }
  427.         else {
  428.             if(this.prefixFunctionCustom.equals(o.getPrefixFunctionCustom())==false){
  429.                 return false;
  430.             }
  431.         }
  432.         
  433.         if(this.suffixFunctionCustom==null){
  434.             if(o.getSuffixFunctionCustom()!=null){
  435.                 return false;
  436.             }
  437.         }
  438.         else {
  439.             if(this.suffixFunctionCustom.equals(o.getSuffixFunctionCustom())==false){
  440.                 return false;
  441.             }
  442.         }
  443.         
  444.         if(this.alias==null){
  445.             if(o.getAlias()!=null){
  446.                 return false;
  447.             }
  448.         }
  449.         else {
  450.             if(this.alias.equals(o.getAlias())==false){
  451.                 return false;
  452.             }
  453.         }
  454.         
  455.         
  456.         return true;
  457.     }
  458.     
  459.     @Override 
  460.     public int hashCode() {
  461.         return super.hashCode();
  462.     }
  463.     
  464.     @Override
  465.     public String toString(){
  466.                 
  467.         StringBuilder bf = new StringBuilder();
  468.         
  469.         bf.append("- Alias: "+this.alias);
  470.         bf.append("\n");
  471.         if(this.customFunction){
  472.             bf.append("- CustomFunction: "+this.prefixFunctionCustom +" @VALUE@ "+this.suffixFunctionCustom);
  473.         }else{
  474.             bf.append("- Function: "+this.function);
  475.         }
  476.         bf.append("\n");
  477.         if(this.functionValue!=null){
  478.             bf.append("- FunctionValue (type:"+this.functionValueType+"): "+this.functionValue);
  479.         }
  480.         else{
  481.             if(this.operator!=null){
  482.                 bf.append("- Operator: "+this.operator);
  483.                 bf.append("\n");
  484.             }
  485.             if(this.fields.size()==1){
  486.                 bf.append(this.fields.get(0).toString());
  487.             }
  488.             else{
  489.                 for (int i = 0; i < this.fields.size(); i++) {
  490.                     bf.append("- Field["+i+"]: "+this.fields.get(i));
  491.                     bf.append("\n");
  492.                 }
  493.             }
  494.         }
  495.                 
  496.         return bf.toString();
  497.     }
  498. }
Created with JaCoCo 0.8.8.202204050719