public void execute(Context context) {
    // pre-processing with filters
    for (Filter filter : filters) {
      if (filter.getClass() == AuthenticationFilter.class) {
        filter.execute(context.getUserRequest());
      } else if (filter.getClass() == DebugFilter.class) {
        filter.execute(context.getPageRequest());
      }
    }

    // main processing
    target.execute(context.getPageRequest());
  }
Example #2
0
 public String toString() {
   String str = "";
   for (Filter filter : filters) {
     str += filter.getClass().getCanonicalName() + ":";
   }
   return str;
 }
Example #3
0
 public <A> QueryWhere<T> where(Filter filter) {
   HashMap<String, Object> fieldMap = New.hashMap();
   for (Field f : filter.getClass().getDeclaredFields()) {
     f.setAccessible(true);
     try {
       Object obj = f.get(filter);
       if (obj == from.getAlias()) {
         List<TableDefinition.FieldDefinition> fields = from.getAliasDefinition().getFields();
         String name = f.getName();
         for (TableDefinition.FieldDefinition field : fields) {
           String n = name + "." + field.field.getName();
           Object o = field.field.get(obj);
           fieldMap.put(n, o);
         }
       }
       fieldMap.put(f.getName(), f.get(filter));
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
   }
   Token filterCode = new ClassReader().decompile(filter, fieldMap, "where");
   // String filterQuery = filterCode.toString();
   conditions.add(filterCode);
   return new QueryWhere<T>(this);
 }
Example #4
0
  @Override
  public JSONObject serialize(Filter bean) throws JSONException {
    if (bean == null) {
      return null;
    }
    if (bean instanceof Selection) {
      return selectionJsonHandler.serialize((Selection) bean);
    }
    if (bean instanceof StringQuery) {
      JSONObject ret = (JSONObject) JsonSerializer.serialize(bean);
      return new JSONObject().put("query", ret);
    }
    if (bean instanceof AndOr) {
      AndOr andOr = (AndOr) bean;
      String operation = andOr.getOperation().name();

      List<JSONObject> filters = convertToJson(andOr.filters);
      return new JSONObject().put(operation, new JSONArray(filters));
    }
    if (bean instanceof BoolFilter) {
      BoolFilter bool = (BoolFilter) bean;
      JSONObject ret = new JSONObject();
      if (bool.getMust() != null) {
        ret.put("must", new JSONArray(convertToJson(bool.getMust())));
      }
      if (bool.getMust_not() != null) {
        ret.put("must_not", new JSONArray(convertToJson(bool.getMust_not())));
      }
      if (bool.getShould() != null) {
        ret.put("should", new JSONArray(convertToJson(bool.getShould())));
      }
      return new JSONObject().put("bool", ret);
    }
    if (bean instanceof Ids) {
      Ids ids = (Ids) bean;
      JSONObject ret = new JSONObject();
      if (ids.getValues() != null) {
        ret.put("values", new JSONArray(ids.getValues()));
      }
      if (ids.getExcludes() != null) {
        ret.put("excludes", new JSONArray(ids.getExcludes()));
      }

      return new JSONObject().put("ids", ret);
    }
    if (bean instanceof Query) {
      return queryJsonHandler.serialize((Query) bean);
    }
    if (bean instanceof QueryFilter) {
      return new JSONObject()
          .put("query", queryJsonHandler.serialize(((QueryFilter) bean).getQuery()));
    }
    throw new UnsupportedOperationException(bean.getClass() + " is not supported");
  }
Example #5
0
  @Override
  public DBObject createFilter(final Filter<K, T> filter, final MongoStore<K, T> store) {

    if (filter instanceof FilterList) {
      FilterList<K, T> filterList = (FilterList<K, T>) filter;
      return transformListFilter(filterList, store);
    } else if (filter instanceof SingleFieldValueFilter) {
      SingleFieldValueFilter<K, T> fieldFilter = (SingleFieldValueFilter<K, T>) filter;
      return transformFieldFilter(fieldFilter, store);
    } else if (filter instanceof MapFieldValueFilter) {
      MapFieldValueFilter<K, T> mapFilter = (MapFieldValueFilter<K, T>) filter;
      return transformMapFilter(mapFilter, store);
    } else {
      LOG.warn(
          "MongoDB remote filter not yet implemented for " + filter.getClass().getCanonicalName());
      return null;
    }
  }
Example #6
0
  /**
   * Returns true under the following conditions:
   *
   * <ol>
   *   <li>If this filter is the same type as the given filter.
   *   <li>If this filter type is a descendant of the given filter's type.
   *   <li>If the given filter's type is a descendant of this filter's type.
   * </ol>
   *
   * If the given filter is not of type {@link TypeFilter} then false is returned.
   *
   * <p>If the given filter is null then false is returned.
   *
   * @param filter the other filter
   */
  @Override
  public boolean isAllowed(Filter filter) {
    // if its null then just return
    if (filter == null) return false;
    // check for the same instance
    if (this == filter) return true;
    // make sure the given filter is a TypeFilter
    if (filter instanceof TypeFilter) {
      // because the TypeFilter class is abstract, this.getClass() should never return
      // TypeFilter, but should return the type of the class that extends TypeFilter

      // then check the types
      if (this.getClass().isInstance(filter) || filter.getClass().isInstance(this)) {
        // if they are the same type then return true
        // if the given filter is a descendant type of this filter type then return true
        // if this type is a descendant of the given filter's type then return true
        return true;
      }
    }
    // otherwise return false
    return false;
  }
 public FilterModel(Filter filter) {
   String typeName = filter.getClass().getSimpleName();
   FilterType type = FilterType.valueOf(typeName);
   this.type = typeName;
   switch (type) {
     case ColumnCountGetFilter:
       this.limit = ((ColumnCountGetFilter) filter).getLimit();
       break;
     case ColumnPaginationFilter:
       this.limit = ((ColumnPaginationFilter) filter).getLimit();
       this.offset = ((ColumnPaginationFilter) filter).getOffset();
       break;
     case ColumnPrefixFilter:
       this.value = Base64.encodeBytes(((ColumnPrefixFilter) filter).getPrefix());
       break;
     case ColumnRangeFilter:
       this.minColumn = Base64.encodeBytes(((ColumnRangeFilter) filter).getMinColumn());
       this.minColumnInclusive = ((ColumnRangeFilter) filter).getMinColumnInclusive();
       this.maxColumn = Base64.encodeBytes(((ColumnRangeFilter) filter).getMaxColumn());
       this.maxColumnInclusive = ((ColumnRangeFilter) filter).getMaxColumnInclusive();
       break;
     case DependentColumnFilter:
       {
         DependentColumnFilter dcf = (DependentColumnFilter) filter;
         this.family = Base64.encodeBytes(dcf.getFamily());
         byte[] qualifier = dcf.getQualifier();
         if (qualifier != null) {
           this.qualifier = Base64.encodeBytes(qualifier);
         }
         this.op = dcf.getOperator().toString();
         this.comparator = new WritableByteArrayComparableModel(dcf.getComparator());
         this.dropDependentColumn = dcf.dropDependentColumn();
       }
       break;
     case FilterList:
       this.op = ((FilterList) filter).getOperator().toString();
       this.filters = new ArrayList<FilterModel>();
       for (Filter child : ((FilterList) filter).getFilters()) {
         this.filters.add(new FilterModel(child));
       }
       break;
     case FirstKeyOnlyFilter:
     case KeyOnlyFilter:
       break;
     case InclusiveStopFilter:
       this.value = Base64.encodeBytes(((InclusiveStopFilter) filter).getStopRowKey());
       break;
     case MultipleColumnPrefixFilter:
       this.prefixes = new ArrayList<String>();
       for (byte[] prefix : ((MultipleColumnPrefixFilter) filter).getPrefix()) {
         this.prefixes.add(Base64.encodeBytes(prefix));
       }
       break;
     case PageFilter:
       this.value = Long.toString(((PageFilter) filter).getPageSize());
       break;
     case PrefixFilter:
       this.value = Base64.encodeBytes(((PrefixFilter) filter).getPrefix());
       break;
     case FamilyFilter:
     case QualifierFilter:
     case RowFilter:
     case ValueFilter:
       this.op = ((CompareFilter) filter).getOperator().toString();
       this.comparator =
           new WritableByteArrayComparableModel(((CompareFilter) filter).getComparator());
       break;
     case RandomRowFilter:
       this.chance = ((RandomRowFilter) filter).getChance();
       break;
     case SingleColumnValueExcludeFilter:
     case SingleColumnValueFilter:
       {
         SingleColumnValueFilter scvf = (SingleColumnValueFilter) filter;
         this.family = Base64.encodeBytes(scvf.getFamily());
         byte[] qualifier = scvf.getQualifier();
         if (qualifier != null) {
           this.qualifier = Base64.encodeBytes(qualifier);
         }
         this.op = scvf.getOperator().toString();
         this.comparator = new WritableByteArrayComparableModel(scvf.getComparator());
         if (scvf.getFilterIfMissing()) {
           this.ifMissing = true;
         }
         if (scvf.getLatestVersionOnly()) {
           this.latestVersion = true;
         }
       }
       break;
     case SkipFilter:
       this.filters = new ArrayList<FilterModel>();
       this.filters.add(new FilterModel(((SkipFilter) filter).getFilter()));
       break;
     case TimestampsFilter:
       this.timestamps = ((TimestampsFilter) filter).getTimestamps();
       break;
     case WhileMatchFilter:
       this.filters = new ArrayList<FilterModel>();
       this.filters.add(new FilterModel(((WhileMatchFilter) filter).getFilter()));
       break;
     default:
       throw new RuntimeException("unhandled filter type " + type);
   }
 }