adds label condition

Author: otaviojava

artemis-graph/src/main/java/org/jnosql/artemis/graph/query/SelectQueryConverter.java

@@ -34,7 +34,7 @@
 import static org.apache.tinkerpop.gremlin.process.traversal.Order.decr;
 import static org.apache.tinkerpop.gremlin.process.traversal.Order.incr;
 
-class SelectQueryConverter implements Function<GraphQueryMethod, List<Vertex>> {
+class SelectQueryConverter extends AbstractQueryConvert implements Function<GraphQueryMethod, List<Vertex>> {
 
 
     @Override
@@ -60,6 +60,7 @@ public List<Vertex> apply(GraphQueryMethod graphQuery) {
             return traversal.next((int) query.getLimit());
         }
         query.getOrderBy().forEach(getSort(traversal, representation));
+        traversal.hasLabel(representation.getName());
         return traversal.toList();
     }
 
@@ -73,41 +74,4 @@ private Consumer<Sort> getSort(GraphTraversal<Vertex, Vertex> traversal, ClassRe
         };
     }
 
-    private GraphTraversal<Vertex, Vertex> getPredicate(GraphQueryMethod graphQuery, Condition condition,
-                                                        ClassRepresentation representation) {
-        Operator operator = condition.getOperator();
-        String name = condition.getName();
-        String nativeName = representation.getColumnField(name);
-        switch (operator) {
-            case EQUALS:
-                return __.has(nativeName, P.eq(graphQuery.getValue(name)));
-            case GREATER_THAN:
-                return __.has(nativeName, P.gt(graphQuery.getValue(name)));
-            case GREATER_EQUALS_THAN:
-                return __.has(nativeName, P.gte(graphQuery.getValue(name)));
-            case LESSER_THAN:
-                return __.has(nativeName, P.lt(graphQuery.getValue(name)));
-            case LESSER_EQUALS_THAN:
-                return __.has(nativeName, P.lte(graphQuery.getValue(name)));
-            case BETWEEN:
-                return __.has(nativeName, P.between(graphQuery.getValue(name), graphQuery.getValue(name)));
-            case IN:
-                return __.has(nativeName, P.within(graphQuery.getInValue(name)));
-            case NOT:
-                Condition notCondition = ConditionValue.class.cast(condition.getValue()).get().get(0);
-                return __.not(getPredicate(graphQuery, notCondition, representation));
-            case AND:
-                return ConditionValue.class.cast(condition.getValue()).get().stream()
-                        .map(c -> getPredicate(graphQuery, c, representation)).reduce((a, b) -> a.and(b))
-                        .orElseThrow(() -> new UnsupportedOperationException("There is an inconsistency at the AND operator"));
-            case OR:
-                return ConditionValue.class.cast(condition.getValue()).get().stream()
-                        .map(c -> getPredicate(graphQuery, c, representation)).reduce((a, b) -> a.or(b))
-                        .orElseThrow(() -> new UnsupportedOperationException("There is an inconsistency at the OR operator"));
-            default:
-                throw new UnsupportedOperationException("There is not support to the type " + operator + " in graph");
-
-
-        }
-    }
 }