com.holonplatform.vaadin7.internal.data.container.ContainerUtils Maven / Gradle / Ivy

/*
 * Copyright 2016-2017 Axioma srl.
 * 
 * Licensed 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 com.holonplatform.vaadin7.internal.data.container;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;

import com.holonplatform.core.Expression.InvalidExpressionException;
import com.holonplatform.core.Path;
import com.holonplatform.core.property.PathProperty;
import com.holonplatform.core.query.PathExpression;
import com.holonplatform.core.query.QueryExpression;
import com.holonplatform.core.query.QueryFilter;
import com.holonplatform.vaadin7.data.ItemDataSource.Configuration;
import com.vaadin.data.Container;
import com.vaadin.data.Container.Filter;
import com.vaadin.data.util.filter.And;
import com.vaadin.data.util.filter.Between;
import com.vaadin.data.util.filter.Compare.Equal;
import com.vaadin.data.util.filter.Compare.Greater;
import com.vaadin.data.util.filter.Compare.GreaterOrEqual;
import com.vaadin.data.util.filter.Compare.Less;
import com.vaadin.data.util.filter.Compare.LessOrEqual;
import com.vaadin.data.util.filter.IsNull;
import com.vaadin.data.util.filter.Like;
import com.vaadin.data.util.filter.Not;
import com.vaadin.data.util.filter.Or;
import com.vaadin.data.util.filter.SimpleStringFilter;

/**
 * Container-related utility class
 * 
 * @since 3.2.0
 */
public final class ContainerUtils implements Serializable {

	private static final long serialVersionUID = 2795000649734188846L;

	/*
	 * Empty private constructor: this class is intended only to provide constants ad utility methods.
	 */
	private ContainerUtils() {
	}

	/**
	 * Convert a {@link Container} filters collection into a {@link QueryFilter}.
	 * @param configuration Container configuration
	 * @param filters Filters to convert
	 * @return QueryFilter
	 * @throws InvalidExpressionException Failed to convert a filter into a QueryFilter
	 */
	public static Optional convertContainerFilters(Configuration configuration,
			Collection filters) throws InvalidExpressionException {
		if (filters != null && !filters.isEmpty()) {
			List qfs = new ArrayList<>(filters.size());
			for (Filter filter : filters) {
				QueryFilter qf = convertContainerFilter(configuration, filter).orElseThrow(
						() -> new InvalidExpressionException("Failed to convert Container Filter: unknown filter type: "
								+ filter.getClass().getName()));
				qfs.add(qf);
			}
			return QueryFilter.allOf(qfs);
		}
		return Optional.empty();
	}

	/**
	 * Convert a {@link Container} filter into a {@link QueryFilter}.
	 * @param configuration Container configuration
	 * @param filter Filter to convert
	 * @return QueryFilter
	 * @throws InvalidExpressionException Failed to convert given filter into a QueryFilter
	 */
	public static Optional convertContainerFilter(Configuration configuration, Filter filter)
			throws InvalidExpressionException {
		if (filter != null) {
			if (filter instanceof IsNull) {
				Object propertyId = ((IsNull) filter).getPropertyId();
				return Optional.of(QueryFilter.isNull(getQueryExpression(propertyId, configuration)));
			} else if (filter instanceof SimpleStringFilter) {
				SimpleStringFilter sf = (SimpleStringFilter) filter;
				Object propertyId = sf.getPropertyId();
				String value = sf.getFilterString();
				if (sf.isOnlyMatchPrefix()) {
					return Optional.of(QueryFilter.startsWith(getQueryExpression(propertyId, configuration), value,
							sf.isIgnoreCase()));
				} else {
					return Optional.of(QueryFilter.contains(getQueryExpression(propertyId, configuration), value,
							sf.isIgnoreCase()));
				}
			} else if (filter instanceof Equal) {
				return Optional.of(QueryFilter.eq(getQueryExpression(((Equal) filter).getPropertyId(), configuration),
						((Equal) filter).getValue()));
			} else if (filter instanceof Greater) {
				return Optional.of(QueryFilter.gt(getQueryExpression(((Greater) filter).getPropertyId(), configuration),
						((Greater) filter).getValue()));
			} else if (filter instanceof GreaterOrEqual) {
				return Optional.of(
						QueryFilter.goe(getQueryExpression(((GreaterOrEqual) filter).getPropertyId(), configuration),
								((GreaterOrEqual) filter).getValue()));
			} else if (filter instanceof Less) {
				return Optional.of(QueryFilter.lt(getQueryExpression(((Less) filter).getPropertyId(), configuration),
						((Less) filter).getValue()));
			} else if (filter instanceof LessOrEqual) {
				return Optional
						.of(QueryFilter.loe(getQueryExpression(((LessOrEqual) filter).getPropertyId(), configuration),
								((LessOrEqual) filter).getValue()));
			} else if (filter instanceof Like) {
				String value = ((Like) filter).getValue();
				if (value == null)
					value = "";
				if (value.startsWith("%") && value.endsWith("%")) {
					return Optional
							.of(QueryFilter.contains(getQueryExpression(((Like) filter).getPropertyId(), configuration),
									value.substring(1, value.length() - 1), !((Like) filter).isCaseSensitive()));
				} else if (value.startsWith("%")) {
					return Optional.of(
							QueryFilter.startsWith(getQueryExpression(((Like) filter).getPropertyId(), configuration),
									value.substring(1), !((Like) filter).isCaseSensitive()));
				} else if (value.endsWith("%")) {
					return Optional
							.of(QueryFilter.endsWith(getQueryExpression(((Like) filter).getPropertyId(), configuration),
									value.substring(0, value.length() - 1), !((Like) filter).isCaseSensitive()));
				}
			} else if (filter instanceof Between) {
				Object from = ((Between) filter).getStartValue();
				Object to = ((Between) filter).getEndValue();
				return Optional.of(QueryFilter
						.between(getQueryExpression(((Between) filter).getPropertyId(), configuration), from, to));
			} else if (filter instanceof Not) {
				return convertContainerFilter(configuration, ((Not) filter).getFilter()).map(f -> QueryFilter.not(f));
			} else if (filter instanceof And) {
				final List qfs = new ArrayList<>();
				((And) filter).getFilters().forEach(c -> {
					convertContainerFilter(configuration, c).ifPresent(f -> qfs.add(f));
				});
				return QueryFilter.allOf(qfs);
			} else if (filter instanceof Or) {
				final List qfs = new ArrayList<>();
				((Or) filter).getFilters().forEach(c -> {
					convertContainerFilter(configuration, c).ifPresent(f -> qfs.add(f));
				});
				return QueryFilter.anyOf(qfs);
			}
		}
		return Optional.empty();
	}

	/**
	 * Validate given propertyId checking if suitable to participate in a filter expression.
	 * @param  Expression type
	 * @param propertyId Property id
	 * @param configuration Container configuration
	 * @return Query expression
	 * @throws InvalidExpressionException If property id is not a {@link QueryExpression} or no QueryExpression can be
	 *         retrieved by name using container properties
	 */
	@SuppressWarnings("unchecked")
	public static  QueryExpression getQueryExpression(Object propertyId, Configuration configuration)
			throws InvalidExpressionException {
		if (propertyId != null) {
			if (propertyId instanceof QueryExpression) {
				return (QueryExpression) propertyId;
			} else {
				String propertyName = (propertyId instanceof String) ? (String) propertyId : propertyId.toString();
				PathExpression property = getPathByName(propertyName, configuration);
				if (property != null) {
					return property;
				}
				throw new InvalidExpressionException("Invalid query clause property: " + propertyId);
			}
		}
		return null;
	}

	/**
	 * Try to get a {@link PathExpression} using path name from container properties.
	 * @param  Expression type
	 * @param propertyName Property name
	 * @param configuration Container configuration
	 * @return {@link PathExpression} with given name, or null if not found
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private static  PathExpression getPathByName(String propertyName, Configuration configuration) {
		if (propertyName != null && configuration != null) {
			for (Object property : configuration.getProperties()) {
				String name = (property instanceof Path) ? ((Path) property).getName() : property.toString();
				if (propertyName.equals(name)) {
					if (property instanceof PathExpression) {
						return (PathExpression) property;
					} else {
						return PathProperty.create(name, configuration.getPropertyType(property));
					}
				}
			}
		}
		return null;
	}

}