| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.usergrid.persistence; |
| |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import org.apache.usergrid.persistence.index.query.CounterResolution; |
| |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| import org.apache.usergrid.persistence.index.query.Query.CounterFilterPredicate; |
| import org.apache.usergrid.utils.JsonUtils; |
| import static org.apache.usergrid.utils.ClassUtils.cast; |
| import static org.apache.usergrid.utils.ListUtils.firstBoolean; |
| import static org.apache.usergrid.utils.ListUtils.firstInteger; |
| import static org.apache.usergrid.utils.ListUtils.firstLong; |
| import static org.apache.usergrid.utils.ListUtils.isEmpty; |
| import static org.apache.usergrid.utils.MapUtils.toMapList; |
| |
| |
| public class CounterQuery { |
| |
| public static final Logger logger = LoggerFactory.getLogger( CounterQuery.class ); |
| |
| public static final int DEFAULT_MAX_RESULTS = 10; |
| |
| private int limit = 0; |
| boolean limitSet = false; |
| |
| private Long startTime; |
| private Long finishTime; |
| private boolean pad; |
| private CounterResolution resolution = CounterResolution.ALL; |
| private List<String> categories; |
| private List<CounterFilterPredicate> counterFilters; |
| |
| |
| public CounterQuery() { |
| } |
| |
| |
| public CounterQuery( CounterQuery q ) { |
| if ( q != null ) { |
| limit = q.limit; |
| limitSet = q.limitSet; |
| startTime = q.startTime; |
| finishTime = q.finishTime; |
| resolution = q.resolution; |
| pad = q.pad; |
| categories = q.categories != null ? new ArrayList<String>( q.categories ) : null; |
| counterFilters = |
| q.counterFilters != null ? new ArrayList<CounterFilterPredicate>( q.counterFilters ) : null; |
| } |
| } |
| |
| |
| public static CounterQuery newQueryIfNull( CounterQuery query ) { |
| if ( query == null ) { |
| query = new CounterQuery(); |
| } |
| return query; |
| } |
| |
| |
| public static CounterQuery fromJsonString( String json ) { |
| Object o = JsonUtils.parse( json ); |
| if ( o instanceof Map ) { |
| @SuppressWarnings({ "unchecked", "rawtypes" }) Map<String, List<String>> params = |
| cast( toMapList( ( Map ) o ) ); |
| return fromQueryParams( params ); |
| } |
| return null; |
| } |
| |
| |
| public static CounterQuery fromQueryParams( Map<String, List<String>> params ) { |
| |
| CounterQuery q = null; |
| CounterResolution resolution = null; |
| List<CounterFilterPredicate> counterFilters = null; |
| Integer limit = firstInteger( params.get( "limit" ) ); |
| Long startTime = firstLong( params.get( "start_time" ) ); |
| Long finishTime = firstLong( params.get( "end_time" ) ); |
| |
| List<String> l = params.get( "resolution" ); |
| if ( !isEmpty( l ) ) { |
| resolution = CounterResolution.fromString( l.get( 0 ) ); |
| } |
| |
| List<String> categories = params.get( "category" ); |
| |
| l = params.get( "counter" ); |
| if ( !isEmpty( l ) ) { |
| counterFilters = CounterFilterPredicate.fromList( l ); |
| } |
| |
| Boolean pad = firstBoolean( params.get( "pad" ) ); |
| |
| if ( limit != null ) { |
| q = newQueryIfNull( q ); |
| q.setLimit( limit ); |
| } |
| |
| if ( startTime != null ) { |
| q = newQueryIfNull( q ); |
| q.setStartTime( startTime ); |
| } |
| |
| if ( finishTime != null ) { |
| q = newQueryIfNull( q ); |
| q.setFinishTime( finishTime ); |
| } |
| |
| if ( resolution != null ) { |
| q = newQueryIfNull( q ); |
| q.setResolution( resolution ); |
| } |
| |
| if ( categories != null ) { |
| q = newQueryIfNull( q ); |
| q.setCategories( categories ); |
| } |
| |
| if ( counterFilters != null ) { |
| q = newQueryIfNull( q ); |
| q.setCounterFilters( counterFilters ); |
| } |
| |
| if ( pad != null ) { |
| q = newQueryIfNull( q ); |
| q.setPad( pad ); |
| } |
| |
| return q; |
| } |
| |
| |
| public int getLimit() { |
| return getLimit( DEFAULT_MAX_RESULTS ); |
| } |
| |
| |
| public int getLimit( int defaultMax ) { |
| if ( limit <= 0 ) { |
| return defaultMax > 0 ? defaultMax : DEFAULT_MAX_RESULTS; |
| } |
| return limit; |
| } |
| |
| |
| public void setLimit( int limit ) { |
| limitSet = true; |
| this.limit = limit; |
| } |
| |
| |
| public CounterQuery withLimit( int limit ) { |
| limitSet = true; |
| this.limit = limit; |
| return this; |
| } |
| |
| |
| public boolean isLimitSet() { |
| return limitSet; |
| } |
| |
| |
| public Long getStartTime() { |
| return startTime; |
| } |
| |
| |
| public void setStartTime( Long startTime ) { |
| this.startTime = startTime; |
| } |
| |
| |
| public CounterQuery withStartTime( Long startTime ) { |
| this.startTime = startTime; |
| return this; |
| } |
| |
| |
| public Long getFinishTime() { |
| return finishTime; |
| } |
| |
| |
| public void setFinishTime( Long finishTime ) { |
| this.finishTime = finishTime; |
| } |
| |
| |
| public CounterQuery withFinishTime( Long finishTime ) { |
| this.finishTime = finishTime; |
| return this; |
| } |
| |
| |
| public boolean isPad() { |
| return pad; |
| } |
| |
| |
| public void setPad( boolean pad ) { |
| this.pad = pad; |
| } |
| |
| |
| public CounterQuery withPad( boolean pad ) { |
| this.pad = pad; |
| return this; |
| } |
| |
| |
| public void setResolution( CounterResolution resolution ) { |
| this.resolution = resolution; |
| } |
| |
| |
| public CounterResolution getResolution() { |
| return resolution; |
| } |
| |
| |
| public CounterQuery withResolution( CounterResolution resolution ) { |
| this.resolution = resolution; |
| return this; |
| } |
| |
| |
| public List<String> getCategories() { |
| return categories; |
| } |
| |
| |
| public CounterQuery addCategory( String category ) { |
| if ( categories == null ) { |
| categories = new ArrayList<String>(); |
| } |
| categories.add( category ); |
| return this; |
| } |
| |
| |
| public void setCategories( List<String> categories ) { |
| this.categories = categories; |
| } |
| |
| |
| public CounterQuery withCategories( List<String> categories ) { |
| this.categories = categories; |
| return this; |
| } |
| |
| |
| public List<CounterFilterPredicate> getCounterFilters() { |
| return counterFilters; |
| } |
| |
| |
| public CounterQuery addCounterFilter( String counter ) { |
| CounterFilterPredicate p = CounterFilterPredicate.fromString( counter ); |
| if ( p == null ) { |
| return this; |
| } |
| if ( counterFilters == null ) { |
| counterFilters = new ArrayList<CounterFilterPredicate>(); |
| } |
| counterFilters.add( p ); |
| return this; |
| } |
| |
| |
| public void setCounterFilters( List<CounterFilterPredicate> counterFilters ) { |
| this.counterFilters = counterFilters; |
| } |
| |
| |
| public CounterQuery withCounterFilters( List<CounterFilterPredicate> counterFilters ) { |
| this.counterFilters = counterFilters; |
| return this; |
| } |
| } |