From 69c6691c57587729ac8eb4ca61ba8cf3dc5948ec Mon Sep 17 00:00:00 2001 From: Giancarlo Panichi Date: Mon, 11 May 2015 16:38:54 +0000 Subject: [PATCH] Updated Multi Column Condition git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/portlets/user/tabular-data-expression-widget@114718 82a268e6-3cf1-43bd-a215-b396298e98cf --- .../expressionwidget/ExpressionWidget.gwt.xml | 10 +- .../client/ExpressionWidgetEntry.java | 12 +- .../client/MultiColumnExpressionPanel.java | 8 +- .../client/MultiColumnFilterDialog.java | 2 +- .../ConditionOnMultiColumnWidget.java | 437 +++++++--- .../multicolumn/DepthOfExpressionType.java | 2 +- .../client/multicolumn/LogicalDepth.java | 48 ++ .../ConditionOnMultiColumnTypeMap.java | 775 ++++++++++++++++++ .../expressionwidget/ExpressionWidget.gwt.xml | 7 +- 9 files changed, 1150 insertions(+), 151 deletions(-) create mode 100644 src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/LogicalDepth.java create mode 100644 src/main/java/org/gcube/portlets/user/td/expressionwidget/shared/condition/ConditionOnMultiColumnTypeMap.java diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml b/src/main/java/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml index 9872ab3..530ba0d 100644 --- a/src/main/java/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml @@ -24,20 +24,18 @@ - + - - - + diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/ExpressionWidgetEntry.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/ExpressionWidgetEntry.java index 267565e..02aeb3d 100644 --- a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/ExpressionWidgetEntry.java +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/ExpressionWidgetEntry.java @@ -41,7 +41,7 @@ public class ExpressionWidgetEntry implements EntryPoint { EventBus eventBus= new SimpleEventBus(); trId = new TRId("86", TabResourceType.STANDARD, "1159"); - String columnName="zwqvvx"; + /*String columnName="zwqvvx";*/ // Column Expression Dialog // ColumnExpressionDialog expressionDialog=new @@ -51,9 +51,9 @@ public class ExpressionWidgetEntry implements EntryPoint { // Column Filter Dialog // id=2, tableId=8, tableType=Generic - ColumnFilterDialog columnFilterDialog=new ColumnFilterDialog(trId, - columnName, eventBus); - columnFilterDialog.show(); + //ColumnFilterDialog columnFilterDialog=new ColumnFilterDialog(trId, + // columnName, eventBus); + //columnFilterDialog.show(); // Multi Column Filter Dialog // MultiColumnFilterDialog multiColumnFilterDialog= new @@ -77,9 +77,9 @@ public class ExpressionWidgetEntry implements EntryPoint { //ReplaceExpressionDialog(columnMockUp,trId,eventBus); //replaceExpressionDialog.show(); - /*MultiColumnFilterDialog cond = new MultiColumnFilterDialog(trId, eventBus); + MultiColumnFilterDialog cond = new MultiColumnFilterDialog(trId, eventBus); cond.show(); - */ + } diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnExpressionPanel.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnExpressionPanel.java index 3c4afc3..491325f 100644 --- a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnExpressionPanel.java +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnExpressionPanel.java @@ -65,7 +65,7 @@ public class MultiColumnExpressionPanel extends FramedPanel { ColumnFilter, RowDeleteByExpression, Template, Rule; } - private static final String WIDTH = "888px"; + private static final String WIDTH = "920px"; private static final String HEIGHT = "352px"; private static final String RULE_HEIGHT = "388px"; @@ -569,9 +569,6 @@ public class MultiColumnExpressionPanel extends FramedPanel { } }); - if (column == null) { - btnApply.disable(); - } btnClose = new TextButton("Close"); btnClose.setIcon(ExpressionResources.INSTANCE.close()); @@ -750,8 +747,7 @@ public class MultiColumnExpressionPanel extends FramedPanel { condContainer = new C_ExpressionContainer(); condContainer.setId(C_ExpressionContainer.Contains.C_Expression); condContainer.setExp(exp); - condContainer.setReadableExpression(conditionWidget - .getReadableExpression()); + condContainer.setReadableExpression(exp.getReadableExpression()); exWrapper = new ExpressionWrapper(column.getTrId(), column, condContainer); diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnFilterDialog.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnFilterDialog.java index cdca1fe..ec34424 100644 --- a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnFilterDialog.java +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/MultiColumnFilterDialog.java @@ -37,7 +37,7 @@ import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler; * */ public class MultiColumnFilterDialog extends Window implements MonitorDialogListener { - private static final String WIDTH = "900px"; + private static final String WIDTH = "932px"; private static final String HEIGHT = "388px"; private MultiColumnExpressionPanel multiColumnExpressionPanel; private C_Expression exp = null; diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/expression/ConditionOnMultiColumnWidget.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/expression/ConditionOnMultiColumnWidget.java index 855ba12..2eae660 100644 --- a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/expression/ConditionOnMultiColumnWidget.java +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/expression/ConditionOnMultiColumnWidget.java @@ -3,15 +3,16 @@ package org.gcube.portlets.user.td.expressionwidget.client.expression; import java.util.ArrayList; import java.util.Date; import java.util.Iterator; -import java.util.List; +import java.util.Stack; import org.gcube.portlets.user.td.expressionwidget.client.custom.IconButton; import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.ArgType; import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.ArgTypePropertiesCombo; import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.DepthOfExpressionElement; +import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.DepthOfExpressionElementPropertiesCombo; import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.DepthOfExpressionStore; import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.DepthOfExpressionType; -import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.DepthOfExpressionElementPropertiesCombo; +import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.LogicalDepth; import org.gcube.portlets.user.td.expressionwidget.client.operation.Operation; import org.gcube.portlets.user.td.expressionwidget.client.operation.OperationProperties; import org.gcube.portlets.user.td.expressionwidget.client.operation.OperationsStore; @@ -20,8 +21,9 @@ import org.gcube.portlets.user.td.expressionwidget.client.resources.ExpressionRe import org.gcube.portlets.user.td.expressionwidget.client.threshold.Threshold; import org.gcube.portlets.user.td.expressionwidget.client.threshold.ThresholdProperties; import org.gcube.portlets.user.td.expressionwidget.client.threshold.ThresholdStore; -import org.gcube.portlets.user.td.expressionwidget.shared.condition.ConditionTypeMap; +import org.gcube.portlets.user.td.expressionwidget.shared.condition.ConditionOnMultiColumnTypeMap; import org.gcube.portlets.user.td.expressionwidget.shared.exception.ConditionTypeMapException; +import org.gcube.portlets.user.td.monitorwidget.client.utils.UtilsGXT3; import org.gcube.portlets.user.td.widgetcommonevent.shared.expression.C_Expression; import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnData; import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnDataType; @@ -57,10 +59,9 @@ import com.sencha.gxt.widget.core.client.form.TextField; */ public class ConditionOnMultiColumnWidget extends SimpleContainer { - private static final String SIGN = "ConditionOnMultiColumns"; private static final String HEIGHT = "268px"; - private static final String WIDTH = "612px"; + private static final String WIDTH = "664px"; private static final String COMBO_DEPTH_WIDTH = "64px"; private static final String COMBO_FIRST_ELEMENT_COLUMN_WIDTH = "150px"; private static final String COMBO_OPERATOR_WIDTH = "130px"; @@ -69,9 +70,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { private static final String COMBO_SECOND_ARG_TYPE_WIDTH = "80px"; private static final String COMBO_SECOND_ARG_COLUMN_WIDTH = "150px"; private static final String COMBO_THRESHOLD_WIDTH = "50px"; - - - + private String itemIdComboDepth; private String itemIdFirstElementColumn; @@ -94,7 +93,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { private VerticalLayoutContainer vert; private ArrayList columns; - private String readableExpression; + // private String readableExpression; // private ConditionOnMultiColumnWidget thisCont; @@ -353,8 +352,50 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { public void onClick(ClickEvent event) { Log.debug("Clicked btnAdd"); - addCondition(); - vert.forceLayout(); + DepthOfExpressionElement depthElement = comboDepth + .getCurrentValue(); + + if (depthElement == null) { + Log.debug("Depth Selected: null"); + Log.debug("No Add possible, if And or Or are not set"); + UtilsGXT3.alert("Attention", + "Select And or Or if you want add a condition!"); + return; + } + + DepthOfExpressionType depth = depthElement.getType(); + + if (depth == null) { + Log.debug("Depth Selected: null"); + Log.debug("No Add possible, if And or Or are not set"); + UtilsGXT3.alert("Attention", + "Select And or Or if you want add a condition!"); + } else { + Log.debug("Depth Selected: " + depth.getLabel()); + switch (depth) { + case BOTTOM: + case COMMA: + case ENDAND: + case ENDOR: + Log.debug("No Add possible, if And or Or are not set"); + UtilsGXT3 + .alert("Attention", + "Select And or Or if you want add a condition!"); + break; + case STARTAND: + case STARTOR: + addCondition(); + vert.forceLayout(); + break; + default: + Log.debug("No Add possible, if And or Or are not set"); + UtilsGXT3 + .alert("Attention", + "Select And or Or if you want add a condition!"); + break; + } + + } } }); @@ -395,8 +436,9 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { DepthOfExpressionElement depthElement = event .getSelectedItem(); - - DepthOfExpressionType depth = depthElement.getType(); + + DepthOfExpressionType depth = depthElement + .getType(); if (depth == null) { Log.debug("Depth Selected: null"); @@ -424,7 +466,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); removeCondition(source); break; @@ -451,7 +493,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); if (!existCondition(source)) { addCondition(); @@ -567,7 +609,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); } @@ -633,7 +675,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); break; case BETWEEN: @@ -652,7 +694,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); break; case LEVENSHTEIN: @@ -675,7 +717,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(true); comboThreshold.setVisible(true); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); comboThreshold.setValue(ThresholdStore @@ -702,7 +744,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(true); comboThreshold.setVisible(true); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); comboThreshold.setValue(ThresholdStore @@ -722,7 +764,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); break; default: @@ -891,7 +933,7 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); + btnAdd.setVisible(true); btnDel.setVisible(false); horiz.add(comboDepth, new BoxLayoutData(new Margins(0))); @@ -1159,9 +1201,9 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { DepthOfExpressionElement depthElement = event .getSelectedItem(); - - DepthOfExpressionType depth = depthElement.getType(); - + + DepthOfExpressionType depth = depthElement + .getType(); if (depth == null) { Log.debug("Depth Selected: null"); @@ -1189,8 +1231,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); removeCondition(source); break; case COMMA: @@ -1216,8 +1258,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); if (!existCondition(source)) { addCondition(); } @@ -1332,8 +1374,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); } @@ -1398,8 +1440,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); break; case BETWEEN: case NOT_BETWEEN: @@ -1417,8 +1459,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); break; case LEVENSHTEIN: comboFirstArgType.reset(); @@ -1440,8 +1482,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(true); comboThreshold.setVisible(true); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); comboThreshold.setValue(ThresholdStore .defaultThresholdLevenshtein()); @@ -1467,8 +1509,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(true); comboThreshold.setVisible(true); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); comboThreshold.setValue(ThresholdStore .defaultThresholdSimilarity()); @@ -1487,8 +1529,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); break; default: comboFirstArgType.setVisible(false); @@ -1656,8 +1698,8 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { secondArgDate.setVisible(false); thresholdText.setVisible(false); comboThreshold.setVisible(false); - btnAdd.setVisible(false); - btnDel.setVisible(false); + btnAdd.setVisible(true); + btnDel.setVisible(true); horiz.add(comboDepth, new BoxLayoutData(new Margins(0))); horiz.add(comboFirstElementColumn, new BoxLayoutData(new Margins(0))); @@ -1716,108 +1758,249 @@ public class ConditionOnMultiColumnWidget extends SimpleContainer { @SuppressWarnings("unchecked") public C_Expression getExpression() throws ConditionTypeMapException { C_Expression exp = null; - readableExpression = new String(); - List arguments = new ArrayList(); - List readableExpressionList = new ArrayList(); - TextField firstArg; - TextField secondArg; - DateField firstArgDate; - DateField secondArgDate; - ComboBox comboThreshold; + boolean expSet = false; - C_Expression expression = null; + Stack depthStack = new Stack(); + ComboBox comboDepth; - DateTimeFormat sdf = DateTimeFormat.getFormat("yyyy-MM-dd"); - - ConditionTypeMap mapOp = new ConditionTypeMap(); Iterator iteratorVert = vert.iterator(); HBoxLayoutContainer horiz; while (iteratorVert.hasNext()) { horiz = (HBoxLayoutContainer) iteratorVert.next(); - ComboBox comboFirstElementColumn = (ComboBox) horiz - .getItemByItemId(itemIdFirstElementColumn); - ColumnData column = comboFirstElementColumn.getCurrentValue(); + comboDepth = (ComboBox) horiz + .getItemByItemId(itemIdComboDepth); - ComboBox comboOp = (ComboBox) horiz - .getItemByItemId(itemIdComboOperation); - Log.debug("combo: " + comboOp.getCurrentValue()); + DepthOfExpressionElement depthOfExpressionElement = comboDepth + .getCurrentValue(); - if (comboOp.getCurrentValue() == null) { - throw new ConditionTypeMapException("Fill all conditions!"); + if (depthOfExpressionElement == null) { + return null; } - if (column.getDataTypeName().compareTo( - ColumnDataType.Date.toString()) == 0) { - firstArgDate = (DateField) horiz - .getItemByItemId(itemIdFirstArgDate); - secondArgDate = (DateField) horiz - .getItemByItemId(itemIdSecondArgDate); - Log.debug("argLeft: " + firstArgDate + " argRight:" - + secondArgDate); - Date firstDate = firstArgDate.getCurrentValue(); - Date secondDate = secondArgDate.getCurrentValue(); + DepthOfExpressionType depth = depthOfExpressionElement.getType(); - expression = mapOp.map(column, comboOp.getCurrentValue() - .getOperatorType(), - firstDate == null ? null : sdf.format(firstDate), - secondDate == null ? null : sdf.format(secondDate), - null); - } else { - - firstArg = (TextField) horiz - .getItemByItemId(itemIdFirstArgValue); - secondArg = (TextField) horiz - .getItemByItemId(itemIdSecondArgValue); - comboThreshold = (ComboBox) horiz - .getItemByItemId(itemIdComboThreshold); - - Log.debug("argLeft: " + firstArg.getCurrentValue() - + " argRight: " + secondArg.getCurrentValue()); - - expression = mapOp.map(column, comboOp.getCurrentValue() - .getOperatorType(), - firstArg == null ? null : firstArg.getCurrentValue(), - secondArg == null ? null : secondArg.getCurrentValue(), - comboThreshold.getCurrentValue() == null ? null - : comboThreshold.getCurrentValue()); + if (depth == null) { + return null; } - readableExpressionList.add(mapOp.getReadableExpression()); - Log.debug(expression.toString()); - arguments.add(expression); - } - Log.debug("Expression Arguments Calculated: " + arguments.size()); - if (arguments.size() > 0) { - if (arguments.size() == 1) { - exp = arguments.get(0); - readableExpression = readableExpressionList.get(0); - } else { - /* - * Radio radio = (Radio) groupMatch.getValue(); - * Log.debug("Match:" + radio); if - * (radio.getName().compareTo("All") == 0) { exp = - * mapOp.createC_And(arguments); readableExpression = "And("; - * boolean first = true; for (String read : - * readableExpressionList) { if (first) { readableExpression += - * read; } else { readableExpression += ", " + read; } } - * readableExpression += ")"; - * - * } else { if (radio.getName().compareTo("Any") == 0) { exp = - * mapOp.createC_Or(arguments); readableExpression = "Or("; - * boolean first = true; for (String read : - * readableExpressionList) { if (first) { readableExpression += - * read; } else { readableExpression += ", " + read; } } - * readableExpression += ")"; } else { - * Log.error("No All or Any set!"); } } - */ + + if (expSet) { + return null; + } + + switch (depth) { + case BOTTOM: + if (vert.getWidgetCount() != 1) { + return null; + } + C_Expression singleCondition = calcExpression(horiz); + exp = singleCondition; + expSet = true; + case COMMA: + if (depthStack.isEmpty()) { + return null; + } else { + LogicalDepth logicalDepth = depthStack.peek(); + if (logicalDepth != null) { + ArrayList args = logicalDepth + .getArguments(); + C_Expression commaArg = calcExpression(horiz); + args.add(commaArg); + } else { + return null; + } + } + break; + case ENDAND: + if (depthStack.isEmpty()) { + return null; + } else { + LogicalDepth endAndPopped = depthStack.pop(); + if (endAndPopped.getType().compareTo( + DepthOfExpressionType.STARTAND) == 0) { + ConditionOnMultiColumnTypeMap mapOp = new ConditionOnMultiColumnTypeMap(); + C_Expression cAnd = mapOp.createC_And(endAndPopped.getArguments()); + if (depthStack.isEmpty()) { + exp = cAnd; + expSet = true; + } else { + LogicalDepth logicalDepth = depthStack.peek(); + if (logicalDepth != null) { + ArrayList args = logicalDepth + .getArguments(); + args.add(cAnd); + } else { + return null; + } + } + } else { + return null; + } + } + break; + case ENDOR: + if (depthStack.isEmpty()) { + return null; + } else { + LogicalDepth endOrPopped = depthStack.pop(); + if (endOrPopped.getType().compareTo( + DepthOfExpressionType.STARTOR) == 0) { + ConditionOnMultiColumnTypeMap mapOp = new ConditionOnMultiColumnTypeMap(); + C_Expression cOr = mapOp.createC_Or(endOrPopped.getArguments()); + if (depthStack.isEmpty()) { + exp = cOr; + expSet = true; + } else { + LogicalDepth logicalDepth = depthStack.peek(); + if (logicalDepth != null) { + ArrayList args = logicalDepth + .getArguments(); + args.add(cOr); + } else { + return null; + } + } + } else { + return null; + } + } + break; + case STARTAND: + C_Expression startAndExp = calcExpression(horiz); + ArrayList andArgs = new ArrayList(); + andArgs.add(startAndExp); + LogicalDepth andDepth = new LogicalDepth(depth, andArgs); + depthStack.add(andDepth); + break; + case STARTOR: + C_Expression startOrExp = calcExpression(horiz); + ArrayList orArgs = new ArrayList(); + orArgs.add(startOrExp); + LogicalDepth orDepth = new LogicalDepth(depth, orArgs); + depthStack.add(orDepth); + break; + default: + break; + } } - Log.debug("C_Expression:" + exp.toString()); + + Log.debug("C_Expression:" + exp); return exp; } - public String getReadableExpression() { - return readableExpression; + protected C_Expression calcExpression(HBoxLayoutContainer horiz) + throws ConditionTypeMapException { + C_Expression expression = null; + + DateTimeFormat sdf = DateTimeFormat.getFormat("yyyy-MM-dd"); + + @SuppressWarnings("unchecked") + ComboBox comboFirstElementColumn = (ComboBox) horiz + .getItemByItemId(itemIdFirstElementColumn); + ColumnData column = comboFirstElementColumn.getCurrentValue(); + + if (column == null) { + throw new ConditionTypeMapException("Fill all arguments!"); + } else { + @SuppressWarnings("unchecked") + ComboBox comboOp = (ComboBox) horiz + .getItemByItemId(itemIdComboOperation); + Operation op = comboOp.getCurrentValue(); + if (op == null) { + throw new ConditionTypeMapException("Fill all arguments!"); + } else { + Log.debug("Op.: " + comboOp.getCurrentValue()); + + ColumnData firstArgColumn=null; + String firstArg=null; + ColumnData secondArgColumn=null; + String secondArg=null; + + + @SuppressWarnings("unchecked") + ComboBoxcomboFirstArgType=(ComboBox)horiz.getItemByItemId(itemIdFirstArgType); + ArgType firstArgType=comboFirstArgType.getCurrentValue(); + if(firstArgType!=null){ + if(firstArgType.compareTo(ArgType.COLUMN)==0){ + @SuppressWarnings("unchecked") + ComboBox comboFirstArgColumn=(ComboBox) + horiz.getItemByItemId(itemIdFirstArgColumn); + firstArgColumn=comboFirstArgColumn.getCurrentValue(); + } else { + if(firstArgType.compareTo(ArgType.VALUE)==0){ + if (column.getDataTypeName().compareTo( + ColumnDataType.Date.toString()) == 0) { + DateField firstArgDate = (DateField) horiz + .getItemByItemId(itemIdFirstArgDate); + Date firstDate = firstArgDate.getCurrentValue(); + firstArg=sdf.format(firstDate); + } else { + TextField firstArgText = (TextField) horiz + .getItemByItemId(itemIdFirstArgValue); + firstArg=firstArgText.getCurrentValue(); + } + } else { + + } + } + } + + + @SuppressWarnings("unchecked") + ComboBoxcomboSecondArgType=(ComboBox)horiz.getItemByItemId(itemIdSecondArgType); + ArgType secondArgType=comboSecondArgType.getCurrentValue(); + if(secondArgType!=null){ + if(secondArgType.compareTo(ArgType.COLUMN)==0){ + @SuppressWarnings("unchecked") + ComboBox comboSecondArgColumn=(ComboBox) + horiz.getItemByItemId(itemIdSecondArgColumn); + secondArgColumn=comboSecondArgColumn.getCurrentValue(); + } else { + if(secondArgType.compareTo(ArgType.VALUE)==0){ + if (column.getDataTypeName().compareTo( + ColumnDataType.Date.toString()) == 0) { + DateField secondArgDate = (DateField) horiz + .getItemByItemId(itemIdSecondArgDate); + Date secondDate = secondArgDate.getCurrentValue(); + secondArg=sdf.format(secondDate); + } else { + TextField secondArgText = (TextField) horiz + .getItemByItemId(itemIdSecondArgValue); + secondArg=secondArgText.getCurrentValue(); + + } + + } else { + + } + } + } + + @SuppressWarnings("unchecked") + ComboBox comboThreshold = (ComboBox) horiz + .getItemByItemId(itemIdComboThreshold); + + Threshold threshold=comboThreshold.getCurrentValue(); + + ConditionOnMultiColumnTypeMap mapOp = new ConditionOnMultiColumnTypeMap(); + + expression = mapOp.map( + column, + comboOp.getCurrentValue().getOperatorType(), + firstArgType, firstArgColumn, + firstArg, + secondArgType, secondArgColumn, + secondArg, threshold); + + + + + + } + } + return expression; } + } diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/DepthOfExpressionType.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/DepthOfExpressionType.java index 6c1a133..5c59a77 100644 --- a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/DepthOfExpressionType.java +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/DepthOfExpressionType.java @@ -11,7 +11,7 @@ import java.util.List; * */ public enum DepthOfExpressionType { - BOTTOM(" "), + BOTTOM("Cond."), STARTOR("Or("), ENDOR(")"), STARTAND("And["), diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/LogicalDepth.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/LogicalDepth.java new file mode 100644 index 0000000..8387304 --- /dev/null +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/client/multicolumn/LogicalDepth.java @@ -0,0 +1,48 @@ +package org.gcube.portlets.user.td.expressionwidget.client.multicolumn; + +import java.io.Serializable; +import java.util.ArrayList; + +import org.gcube.portlets.user.td.widgetcommonevent.shared.expression.C_Expression; + +/** + * + * @author giancarlo email: g.panichi@isti.cnr.it + * + */ +public class LogicalDepth implements Serializable { + private static final long serialVersionUID = 3597411498776039440L; + + private DepthOfExpressionType type; + private ArrayList arguments; + + public LogicalDepth(DepthOfExpressionType type, + ArrayList arguments) { + super(); + this.type = type; + this.arguments = arguments; + } + + public DepthOfExpressionType getType() { + return type; + } + + public void setType(DepthOfExpressionType type) { + this.type = type; + } + + public ArrayList getArguments() { + return arguments; + } + + public void setArguments(ArrayList arguments) { + this.arguments = arguments; + } + + @Override + public String toString() { + return "LogicalDepth [type=" + type + ", arguments=" + arguments + "]"; + } + +} diff --git a/src/main/java/org/gcube/portlets/user/td/expressionwidget/shared/condition/ConditionOnMultiColumnTypeMap.java b/src/main/java/org/gcube/portlets/user/td/expressionwidget/shared/condition/ConditionOnMultiColumnTypeMap.java new file mode 100644 index 0000000..fbb15cf --- /dev/null +++ b/src/main/java/org/gcube/portlets/user/td/expressionwidget/shared/condition/ConditionOnMultiColumnTypeMap.java @@ -0,0 +1,775 @@ +package org.gcube.portlets.user.td.expressionwidget.shared.condition; + +import java.util.ArrayList; +import java.util.List; + +import org.gcube.portlets.user.td.expressionwidget.client.multicolumn.ArgType; +import org.gcube.portlets.user.td.expressionwidget.client.threshold.Threshold; +import org.gcube.portlets.user.td.expressionwidget.client.threshold.ThresholdStore; +import org.gcube.portlets.user.td.expressionwidget.shared.exception.ConditionTypeMapException; +import org.gcube.portlets.user.td.expressionwidget.shared.model.C_OperatorType; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_Equals; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_GreaterOrEquals; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_GreaterThan; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_LessOrEquals; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_LessThan; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_NotEquals; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_NotGreater; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_NotLess; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Levenshtein; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Similarity; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Soundex; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextBeginsWith; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextContains; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextEndsWith; +import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextMatchSQLRegexp; +import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_ColumnReference; +import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_ColumnReferencePlaceholder; +import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_ConstantList; +import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_Leaf; +import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_Range; +import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.TD_Value; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_And; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_Between; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_IsNotNull; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_IsNull; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_Not; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_Or; +import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_ValueIsIn; +import org.gcube.portlets.user.td.widgetcommonevent.shared.expression.C_Expression; +import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnData; +import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnDataType; + +import com.allen_sauer.gwt.log.client.Log; + +/** + * ConditionTypeMap creates a C_Expression usable client-side + * + * @author "Giancarlo Panichi" g.panichi@isti.cnr.it + * + */ +public class ConditionOnMultiColumnTypeMap { + + public ConditionOnMultiColumnTypeMap() { + + } + + public C_Expression map(ColumnData column, C_OperatorType operatorType, + ArgType firstArgType, ColumnData firstArgColumn, String firstArg, + ArgType secondArgType, ColumnData secondArgColumn, + String secondArg, Threshold threshold) + throws ConditionTypeMapException { + Log.debug("ConditionOnMultiColumnTypeMap"); + C_Expression exp = null; + if (column.getTrId() == null) { + exp = mapPlaceHolder(column, operatorType, firstArgType, + firstArgColumn, firstArg, secondArgType, secondArgColumn, + secondArg, threshold); + } else { + exp = mapTypedColumnReference(column, operatorType, firstArgType, + firstArgColumn, firstArg, secondArgType, secondArgColumn, + secondArg, threshold); + } + return exp; + } + + public C_Expression mapPlaceHolder(ColumnData column, + C_OperatorType operatorType, ArgType firstArgType, + ColumnData firstArgColumn, String firstArg, ArgType secondArgType, + ColumnData secondArgColumn, String secondArg, Threshold threshold) + throws ConditionTypeMapException { + Log.debug("ConditionOnMultiColumnTypeMap Place Holder"); + C_Expression exp = null; + Log.debug("Column Data Type Name:" + column.getDataTypeName()); + ColumnDataType dataType = ColumnDataType.getColumnDataTypeFromId(column + .getDataTypeName()); + Log.debug("Data Type:" + dataType); + C_ColumnReferencePlaceholder placeHolder = new C_ColumnReferencePlaceholder( + dataType, column.getColumnId()); + Log.debug("placeHolder:" + placeHolder); + + //TD_Value fArg; + // TD_Value sArg; + // C_Range range; + + List arguments = new ArrayList(); + int separator; + + switch (operatorType) { + case ADDITION: + break; + case ALL: + break; + case AND: + break; + case ANY: + break; + case BEGINS_WITH: + exp = placeHolderBeginsWith(column, firstArgType, firstArgColumn, + firstArg, dataType, placeHolder); + break; + case BETWEEN: + exp = placeHolderBetween(column, firstArgType, firstArgColumn, + firstArg, secondArgType, secondArgColumn, secondArg, + dataType, placeHolder); + break; + case CONTAINS: + exp = placeHolderContains(column, firstArgType, firstArgColumn, + firstArg, dataType, placeHolder); + break; + case DIVISION: + break; + case ENDS_WITH: + checkTypeArgument(column, firstArg); + exp = new C_TextEndsWith(placeHolder, new TD_Value(dataType, + firstArg)); + break; + case EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_Equals(placeHolder, new TD_Value(dataType, firstArg)); + break; + case EXISTS: + // exp=new C_Exi(placeHolder,new C_ConstantList(arguments)); + break; + case GREATER: + checkTypeArgument(column, firstArg); + exp = new C_GreaterThan(placeHolder, new TD_Value(dataType, + firstArg)); + break; + case GREATER_OR_EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_GreaterOrEquals(placeHolder, new TD_Value(dataType, + firstArg)); + break; + case IN: + separator = firstArg.indexOf(","); + if (separator == -1 || firstArg.length() == 1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + } else { + String arg; + boolean end = false; + while (!end) { + arg = firstArg.substring(0, separator); + checkTypeArgument(column, arg); + arguments.add(new TD_Value(dataType, arg)); + separator++; + if (separator < firstArg.length()) { + firstArg = firstArg.substring(separator, + firstArg.length()); + separator = firstArg.indexOf(","); + if (separator == -1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + end = true; + } + } else { + end = true; + } + } + } + exp = new C_ValueIsIn(placeHolder, new C_ConstantList(arguments)); + break; + case IS_NOT_NULL: + exp = new C_IsNotNull(placeHolder); + break; + case IS_NULL: + exp = new C_IsNull(placeHolder); + break; + case LESSER: + checkTypeArgument(column, firstArg); + exp = new C_LessThan(placeHolder, new TD_Value(dataType, firstArg)); + break; + case LESSER_OR_EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_LessOrEquals(placeHolder, new TD_Value(dataType, + firstArg)); + break; + case LIKE: + break; + case MATCH_REGEX: + checkTypeArgument(column, firstArg); + exp = new C_TextMatchSQLRegexp(placeHolder, new TD_Value(dataType, + firstArg)); + break; + case MODULUS: + break; + case MULTIPLICATION: + break; + case NOT: + break; + case NOT_BEGINS_WITH: + exp = placeHolderBeginsWith(column, firstArgType, firstArgColumn, + firstArg, dataType, placeHolder); + exp = new C_Not(exp); + break; + case NOT_BETWEEN: + exp = placeHolderBetween(column, firstArgType, firstArgColumn, + firstArg, secondArgType, secondArgColumn, secondArg, + dataType, placeHolder); + exp = new C_Not(exp); + break; + case NOT_CONTAINS: + exp = placeHolderContains(column, firstArgType, firstArgColumn, + firstArg, dataType, placeHolder); + exp = new C_Not(exp); + break; + case NOT_ENDS_WITH: + checkTypeArgument(column, firstArg); + exp = new C_TextEndsWith(placeHolder, new TD_Value(dataType, + firstArg)); + exp = new C_Not(exp); + break; + case NOT_EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_NotEquals(placeHolder, new TD_Value(dataType, firstArg)); + break; + case NOT_GREATER: + checkTypeArgument(column, firstArg); + exp = new C_NotGreater(placeHolder, + new TD_Value(dataType, firstArg)); + break; + case NOT_IN: + separator = firstArg.indexOf(","); + if (separator == -1 || firstArg.length() == 1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + } else { + String arg; + boolean end = false; + while (!end) { + arg = firstArg.substring(0, separator); + checkTypeArgument(column, arg); + arguments.add(new TD_Value(dataType, arg)); + separator++; + if (separator < firstArg.length()) { + firstArg = firstArg.substring(separator, + firstArg.length()); + separator = firstArg.indexOf(","); + if (separator == -1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + end = true; + } + } else { + end = true; + } + } + } + exp = new C_ValueIsIn(placeHolder, new C_ConstantList(arguments)); + exp = new C_Not(exp); + break; + case NOT_LESSER: + checkTypeArgument(column, firstArg); + exp = new C_NotLess(placeHolder, new TD_Value(dataType, firstArg)); + break; + case NOT_LIKE: + break; + case NOT_MATCH_REGEX: + checkTypeArgument(column, firstArg); + exp = new C_TextMatchSQLRegexp(placeHolder, new TD_Value(dataType, + firstArg)); + exp = new C_Not(exp); + break; + case OR: + break; + case SELECT_IN: + break; + case SUBTRACTION: + break; + case UNIQUE: + break; + case SOUNDEX: + checkTypeArgument(column, firstArg); + C_Soundex soundexPlaceHolder = new C_Soundex(placeHolder); + C_Soundex soundexValue = new C_Soundex(new TD_Value(dataType, + firstArg)); + exp = new C_Equals(soundexPlaceHolder, soundexValue); + break; + case LEVENSHTEIN: + checkTypeArgument(column, firstArg); + C_Levenshtein levenshstein = new C_Levenshtein(placeHolder, + new TD_Value(dataType, firstArg)); + Threshold thresholdLev; + + if (threshold == null) { + thresholdLev = ThresholdStore.defaultThresholdLevenshtein(); + } else { + thresholdLev = threshold; + } + exp = new C_LessOrEquals(levenshstein, new TD_Value( + ColumnDataType.Integer, thresholdLev.getIntegerValue() + .toString())); + break; + case SIMILARITY: + checkTypeArgument(column, firstArg); + C_Similarity similarity = new C_Similarity(placeHolder, + new TD_Value(dataType, firstArg)); + Threshold thresholdSim; + + if (threshold == null) { + thresholdSim = ThresholdStore.defaultThresholdSimilarity(); + } else { + thresholdSim = threshold; + } + exp = new C_GreaterOrEquals(similarity, new TD_Value( + ColumnDataType.Numeric, thresholdSim.getLabel())); + break; + + default: + break; + } + + return exp; + } + + protected C_Expression placeHolderContains(ColumnData column, + ArgType firstArgType, ColumnData firstArgColumn, String firstArg, + ColumnDataType dataType, C_ColumnReferencePlaceholder placeHolder) + throws ConditionTypeMapException { + C_Expression exp = null; + + switch (firstArgType) { + case COLUMN: + ColumnDataType firstArgDataType = ColumnDataType + .getColumnDataTypeFromId(firstArgColumn.getDataTypeName()); + C_ColumnReferencePlaceholder firstArgPlaceHolder = new C_ColumnReferencePlaceholder( + firstArgDataType, firstArgColumn.getColumnId()); + exp = new C_TextContains(placeHolder, firstArgPlaceHolder); + break; + case VALUE: + checkTypeArgument(column, firstArg); + TD_Value fArg = new TD_Value(dataType, firstArg); + exp = new C_TextContains(placeHolder, fArg); + + break; + default: + new ConditionTypeMapException( + "No valid first argument type selected!"); + break; + + } + + return exp; + } + + protected C_Expression placeHolderBetween(ColumnData column, + ArgType firstArgType, ColumnData firstArgColumn, String firstArg, + ArgType secondArgType, ColumnData secondArgColumn, + String secondArg, ColumnDataType dataType, + C_ColumnReferencePlaceholder placeHolder) + throws ConditionTypeMapException { + C_Expression exp = null; + C_Leaf fArg; + C_Leaf sArg; + C_Range range; + + switch (firstArgType) { + case COLUMN: + ColumnDataType firstArgDataType = ColumnDataType + .getColumnDataTypeFromId(firstArgColumn.getDataTypeName()); + fArg = new C_ColumnReferencePlaceholder(firstArgDataType, + firstArgColumn.getColumnId()); + break; + case VALUE: + checkTypeArgument(column, firstArg); + fArg = new TD_Value(dataType, firstArg); + break; + default: + new ConditionTypeMapException( + "No valid first argument type selected!"); + break; + } + + switch (secondArgType) { + case COLUMN: + ColumnDataType secondArgDataType = ColumnDataType + .getColumnDataTypeFromId(secondArgColumn.getDataTypeName()); + Log.debug("Second Arg Data Type:" + secondArgDataType); + sArg = new C_ColumnReferencePlaceholder(secondArgDataType, + secondArgColumn.getColumnId()); + break; + case VALUE: + checkTypeArgument(column, secondArg); + sArg = new TD_Value(dataType, secondArg); + break; + default: + new ConditionTypeMapException( + "No valid second argument type selected!"); + break; + } + + // range = new C_Range(fArg, sArg); + // exp = new C_Between(placeHolder, range); + return exp; + } + + protected C_Expression placeHolderBeginsWith(ColumnData column, + ArgType firstArgType, ColumnData firstArgColumn, String firstArg, + ColumnDataType dataType, C_ColumnReferencePlaceholder placeHolder) + throws ConditionTypeMapException { + C_Expression exp = null; + + switch (firstArgType) { + case COLUMN: + ColumnDataType firstArgDataType = ColumnDataType + .getColumnDataTypeFromId(firstArgColumn.getDataTypeName()); + Log.debug("First Arg Data Type:" + firstArgDataType); + C_ColumnReferencePlaceholder firstArgColumnPlaceHolder = new C_ColumnReferencePlaceholder( + firstArgDataType, firstArgColumn.getColumnId()); + Log.debug("FirstArgColumnPlaceHolder:" + firstArgColumnPlaceHolder); + exp = new C_TextBeginsWith(placeHolder, firstArgColumnPlaceHolder); + break; + case VALUE: + checkTypeArgument(column, firstArg); + TD_Value fArg = new TD_Value(dataType, firstArg); + exp = new C_TextBeginsWith(placeHolder, fArg); + break; + default: + new ConditionTypeMapException( + "No valid first argument type selected!"); + break; + } + + return exp; + } + + public C_Expression mapTypedColumnReference(ColumnData column, + C_OperatorType operatorType, ArgType firstArgType, + ColumnData firstArgColumn, String firstArg, ArgType secondArgType, + ColumnData secondArgColumn, String secondArg, Threshold threshold) + throws ConditionTypeMapException { + Log.debug("ConditionTypeMap Map Typed Column Reference"); + C_Expression exp = null; + + Log.debug("Column Data Type Name:" + column.getDataTypeName()); + ColumnDataType dataType = ColumnDataType.getColumnDataTypeFromId(column + .getDataTypeName()); + Log.debug("Data Type:" + dataType); + C_ColumnReference columnReference = new C_ColumnReference( + column.getTrId(), dataType, column.getColumnId()); + Log.debug("Typed Column Reference:" + columnReference); + + TD_Value fArg; + TD_Value sArg; + C_Range range; + + List arguments = new ArrayList(); + int separator; + + switch (operatorType) { + case ADDITION: + break; + case ALL: + break; + case AND: + break; + case ANY: + break; + case BEGINS_WITH: + checkTypeArgument(column, firstArg); + exp = new C_TextBeginsWith(columnReference, new TD_Value(dataType, + firstArg)); + break; + case BETWEEN: + checkTypeArgument(column, firstArg); + checkTypeArgument(column, secondArg); + fArg = new TD_Value(dataType, firstArg); + sArg = new TD_Value(dataType, secondArg); + range = new C_Range(fArg, sArg); + exp = new C_Between(columnReference, range); + break; + case CONTAINS: + checkTypeArgument(column, firstArg); + fArg = new TD_Value(dataType, firstArg); + exp = new C_TextContains(columnReference, fArg); + break; + case DIVISION: + break; + case ENDS_WITH: + checkTypeArgument(column, firstArg); + exp = new C_TextEndsWith(columnReference, new TD_Value(dataType, + firstArg)); + break; + case EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_Equals(columnReference, + new TD_Value(dataType, firstArg)); + break; + case EXISTS: + // exp=new C_Exi(placeHolder,new C_ConstantList(arguments)); + break; + case GREATER: + checkTypeArgument(column, firstArg); + exp = new C_GreaterThan(columnReference, new TD_Value(dataType, + firstArg)); + break; + case GREATER_OR_EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_GreaterOrEquals(columnReference, new TD_Value(dataType, + firstArg)); + break; + case IN: + separator = firstArg.indexOf(","); + if (separator == -1 || firstArg.length() == 1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + } else { + String arg; + boolean end = false; + while (!end) { + arg = firstArg.substring(0, separator); + checkTypeArgument(column, arg); + arguments.add(new TD_Value(dataType, arg)); + separator++; + if (separator < firstArg.length()) { + firstArg = firstArg.substring(separator, + firstArg.length()); + separator = firstArg.indexOf(","); + if (separator == -1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + end = true; + } + } else { + end = true; + } + } + } + exp = new C_ValueIsIn(columnReference, + new C_ConstantList(arguments)); + break; + case IS_NOT_NULL: + exp = new C_IsNotNull(columnReference); + break; + case IS_NULL: + exp = new C_IsNull(columnReference); + break; + case LESSER: + checkTypeArgument(column, firstArg); + exp = new C_LessThan(columnReference, new TD_Value(dataType, + firstArg)); + break; + case LESSER_OR_EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_LessOrEquals(columnReference, new TD_Value(dataType, + firstArg)); + break; + case LIKE: + break; + case MATCH_REGEX: + checkTypeArgument(column, firstArg); + exp = new C_TextMatchSQLRegexp(columnReference, new TD_Value( + dataType, firstArg)); + break; + case MODULUS: + break; + case MULTIPLICATION: + break; + case NOT: + break; + case NOT_BEGINS_WITH: + checkTypeArgument(column, firstArg); + exp = new C_TextBeginsWith(columnReference, new TD_Value(dataType, + firstArg)); + exp = new C_Not(exp); + break; + case NOT_BETWEEN: + checkTypeArgument(column, firstArg); + checkTypeArgument(column, secondArg); + fArg = new TD_Value(dataType, firstArg); + sArg = new TD_Value(dataType, secondArg); + range = new C_Range(fArg, sArg); + exp = new C_Between(columnReference, range); + exp = new C_Not(exp); + break; + case NOT_CONTAINS: + checkTypeArgument(column, firstArg); + fArg = new TD_Value(dataType, firstArg); + exp = new C_TextContains(columnReference, fArg); + exp = new C_Not(exp); + break; + case NOT_ENDS_WITH: + checkTypeArgument(column, firstArg); + exp = new C_TextEndsWith(columnReference, new TD_Value(dataType, + firstArg)); + exp = new C_Not(exp); + break; + case NOT_EQUALS: + checkTypeArgument(column, firstArg); + exp = new C_NotEquals(columnReference, new TD_Value(dataType, + firstArg)); + break; + case NOT_GREATER: + checkTypeArgument(column, firstArg); + exp = new C_NotGreater(columnReference, new TD_Value(dataType, + firstArg)); + break; + case NOT_IN: + separator = firstArg.indexOf(","); + if (separator == -1 || firstArg.length() == 1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + } else { + String arg; + boolean end = false; + while (!end) { + arg = firstArg.substring(0, separator); + checkTypeArgument(column, arg); + arguments.add(new TD_Value(dataType, arg)); + separator++; + if (separator < firstArg.length()) { + firstArg = firstArg.substring(separator, + firstArg.length()); + separator = firstArg.indexOf(","); + if (separator == -1) { + checkTypeArgument(column, firstArg); + arguments.add(new TD_Value(dataType, firstArg)); + end = true; + } + } else { + end = true; + } + } + } + exp = new C_ValueIsIn(columnReference, + new C_ConstantList(arguments)); + exp = new C_Not(exp); + break; + case NOT_LESSER: + checkTypeArgument(column, firstArg); + exp = new C_NotLess(columnReference, new TD_Value(dataType, + firstArg)); + break; + case NOT_LIKE: + break; + case NOT_MATCH_REGEX: + checkTypeArgument(column, firstArg); + exp = new C_TextMatchSQLRegexp(columnReference, new TD_Value( + dataType, firstArg)); + exp = new C_Not(exp); + break; + case OR: + break; + case SELECT_IN: + break; + case SUBTRACTION: + break; + case UNIQUE: + break; + case SOUNDEX: + checkTypeArgument(column, firstArg); + C_Soundex soundexPlaceHolder = new C_Soundex(columnReference); + C_Soundex soundexValue = new C_Soundex(new TD_Value(dataType, + firstArg)); + exp = new C_Equals(soundexPlaceHolder, soundexValue); + break; + case LEVENSHTEIN: + checkTypeArgument(column, firstArg); + C_Levenshtein levenshstein = new C_Levenshtein(columnReference, + new TD_Value(dataType, firstArg)); + Threshold thresholdLev; + + if (threshold == null) { + thresholdLev = ThresholdStore.defaultThresholdLevenshtein(); + } else { + thresholdLev = threshold; + } + exp = new C_LessOrEquals(levenshstein, new TD_Value( + ColumnDataType.Integer, thresholdLev.getIntegerValue() + .toString())); + break; + case SIMILARITY: + checkTypeArgument(column, firstArg); + C_Similarity similarity = new C_Similarity(columnReference, + new TD_Value(dataType, firstArg)); + Threshold thresholdSim; + + if (threshold == null) { + thresholdSim = ThresholdStore.defaultThresholdSimilarity(); + } else { + thresholdSim = threshold; + } + exp = new C_GreaterOrEquals(similarity, new TD_Value( + ColumnDataType.Numeric, thresholdSim.getLabel())); + break; + default: + break; + } + + return exp; + } + + public C_Expression createC_Or(List arguments) { + C_Or or = new C_Or(arguments); + return or; + } + + public C_Expression createC_And(List arguments) { + C_And or = new C_And(arguments); + return or; + } + + protected void checkTypeArgument(ColumnData column, String arg) + throws ConditionTypeMapException { + if (column.getDataTypeName().compareTo(ColumnDataType.Text.toString()) == 0) { + if (arg == null) { + arg = ""; + } + } else { + if (column.getDataTypeName().compareTo( + ColumnDataType.Boolean.toString()) == 0) { + if (arg == null) { + throw new ConditionTypeMapException( + "Insert a valid Boolean(ex: true, false)!"); + } + } else { + if (column.getDataTypeName().compareTo( + ColumnDataType.Date.toString()) == 0) { + + } else { + if (column.getDataTypeName().compareTo( + ColumnDataType.Geometry.toString()) == 0) { + + } else { + if (column.getDataTypeName().compareTo( + ColumnDataType.Integer.toString()) == 0) { + if (arg == null) { + throw new ConditionTypeMapException( + "Insert a valid Integer(ex: -1, 0, 1, 2)!"); + } + + try { + Integer.parseInt(arg); + } catch (NumberFormatException e) { + throw new ConditionTypeMapException( + arg + + " is not valid Integer(ex: -1, 0, 1, 2)!"); + } + } else { + if (column.getDataTypeName().compareTo( + ColumnDataType.Numeric.toString()) == 0) { + if (arg == null) { + throw new ConditionTypeMapException( + "Insert a valid Numeric(ex: -1.2, 0, 1, 2.4)!"); + } + try { + Double.parseDouble(arg); + } catch (NumberFormatException e) { + throw new ConditionTypeMapException( + arg + + " is not valid Numeric(ex: -1.2, 0, 1, 2.4)!"); + } + } else { + + } + } + } + } + } + + } + } + +} diff --git a/src/main/resources/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml b/src/main/resources/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml index eb6f22c..3b873d7 100644 --- a/src/main/resources/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml +++ b/src/main/resources/org/gcube/portlets/user/td/expressionwidget/ExpressionWidget.gwt.xml @@ -36,13 +36,12 @@ - --> - - + --> + - +