| /* |
| * Copyright (c) 2020 Kentyou. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Kentyou - initial API and implementation |
| */ |
| package org.eclipse.sensinact.gateway.core.filtering; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.sensinact.gateway.common.bundle.Mediator; |
| |
| /** |
| * A FilteringCollection wraps a set of {@link FilteringAccessor}s, allowing on |
| * one hand to build the global LDAP formated String filter from the ones |
| * provided by each {@link FilteringAccessor}, on the other hand it can be used |
| * to apply all the filters, using the output of one as input of the next. |
| * |
| * @author <a href="mailto:christophe.munilla@cea.fr">Christophe Munilla</a> |
| */ |
| public class FilteringCollection { |
| private Iterable<FilteringAccessor> accessors; |
| private boolean hideFilter; |
| private String filterJsonDefinition; |
| |
| /** |
| * Constructor |
| * |
| * @param mediator |
| * the {@link Mediator} allowing the FilteringCollection to be |
| * instantiated to interact with the OSGi host environment |
| * @param hideFilter |
| * the boolean defining whether the JSON formated String describing |
| * the {@link FilteringAccessor}s wrapped by the FilteringCollection |
| * to be instantiated will defined as hidden |
| * @param filterDefinition |
| * the set of {@link FilteringDefinition}s from which the |
| * FilteringCollection to be instantiated will create the set of |
| * {@link FilteringAccessor}s |
| */ |
| public FilteringCollection(Mediator mediator, boolean hideFilter, FilteringDefinition... filterDefinition) { |
| if (filterDefinition == null || filterDefinition.length == 0) { |
| this.hideFilter = true; |
| this.accessors = null; |
| return; |
| } |
| int index = 0; |
| int length = filterDefinition.length; |
| |
| StringBuilder jsonFormatedFilterBuilder = new StringBuilder(); |
| jsonFormatedFilterBuilder.append("["); |
| |
| List<FilteringAccessor> accessors = new ArrayList<FilteringAccessor>(); |
| |
| int pos = 0; |
| |
| for (; index < length; index++) { |
| try { |
| accessors.add(new FilteringAccessor(mediator, filterDefinition[index])); |
| |
| if (pos > 0) { |
| jsonFormatedFilterBuilder.append(","); |
| } |
| jsonFormatedFilterBuilder.append(String.format("{\"type\":\"%s\",\"definition\":\"%s\"}", |
| filterDefinition[index].type, filterDefinition[index].filter)); |
| |
| pos++; |
| |
| } catch (RuntimeException e) { |
| mediator.error(e); |
| } |
| } |
| if (index != length) { |
| this.filterJsonDefinition = "[]"; |
| this.hideFilter = true; |
| this.accessors = null; |
| return; |
| } |
| jsonFormatedFilterBuilder.append("]"); |
| this.filterJsonDefinition = jsonFormatedFilterBuilder.toString(); |
| this.accessors = accessors; |
| } |
| |
| /** |
| * Builds and returns the global LDAP formated String filter from the ones |
| * provided by each registered {@link FilteringAccessor} |
| * |
| * @param ldapFilter |
| * the initial LDAP formated String filter from which to create the |
| * global one |
| * |
| * @return the global LDAP formated String filter |
| */ |
| public String composeLDAPFormatedFilter(String ldapFilter) { |
| String ldap = null; |
| int index = 0; |
| |
| StringBuilder ldapFormatedFilterBuilder = new StringBuilder(); |
| if (ldapFilter != null) { |
| ldap = ldapFilter.trim(); |
| if (!ldap.startsWith("(")) { |
| ldapFormatedFilterBuilder.append("("); |
| } |
| ldapFormatedFilterBuilder.append(ldap); |
| if (!ldap.endsWith(")")) { |
| ldapFormatedFilterBuilder.append(")"); |
| } |
| index++; |
| } |
| if (accessors == null) { |
| this.hideFilter = true; |
| return ldapFormatedFilterBuilder.toString(); |
| } |
| Iterator<FilteringAccessor> it = accessors.iterator(); |
| while (it.hasNext()) { |
| FilteringAccessor filteringAccessor = it.next(); |
| ldap = filteringAccessor.getLDAPComponent(); |
| if (ldap == null || (ldap = ldap.trim()).length() == 0) { |
| continue; |
| } |
| if (!ldap.startsWith("(")) { |
| ldapFormatedFilterBuilder.append("("); |
| } |
| ldapFormatedFilterBuilder.append(ldap); |
| if (!ldap.endsWith(")")) { |
| ldapFormatedFilterBuilder.append(")"); |
| } |
| if (index > 0) { |
| ldapFormatedFilterBuilder.insert(0, "(&"); |
| ldapFormatedFilterBuilder.append(")"); |
| } |
| index++; |
| } |
| return ldapFormatedFilterBuilder.toString(); |
| } |
| |
| /** |
| * Applies each {@link FilteringAccessor} in order, by using the output of one |
| * as input of the next, the first input being the specified initial String |
| * value. |
| * |
| * @param value |
| * the String value to be filtered |
| * |
| * @return the String result of the filtering process |
| */ |
| public String apply(String value) { |
| String result = value; |
| |
| if (accessors != null) { |
| Iterator<FilteringAccessor> it = accessors.iterator(); |
| while (it.hasNext()) { |
| FilteringAccessor filtering = it.next(); |
| result = filtering.apply(result); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Returns true if the the JSON formated String describing the |
| * {@link FilteringAccessor}s wrapped by this FilteringCollection is hidden; |
| * returns false otherwise |
| * |
| * @return |
| * <ul> |
| * <li>true if the the JSON formated String describing the wrapped |
| * {@link FilteringAccessor}s is hidden</li> |
| * <li>false otherwise</li> |
| * </ul> |
| */ |
| public boolean hideFilter() { |
| return this.hideFilter; |
| } |
| |
| /** |
| * Returns the global JSON formated String description of the filters provided |
| * by each registered {@link FilteringAccessor} |
| * |
| * @return the global JSON formated String filter |
| */ |
| public String filterJsonDefinition() { |
| return this.filterJsonDefinition; |
| } |
| } |