bpel-api/src/main/java/org/apache/ode/bpel/common/InstanceFilter.java - ode - Git at Google

 /*
  * 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.ode.bpel.common;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.apache.ode.bpel.pmapi.InvalidRequestException;
 import org.apache.ode.utils.ISO8601DateParser;
 import org.apache.ode.utils.RelativeDateParser;

 import java.io.Serializable;
 import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.StringTokenizer;

 /**
  * Holds a filter that will get interpreted when listing processe instances. The
  * semantic of the filtering is somewhat different than the one used in the
  * ProcessQuery class. Here we're introducing a pseudo process querying
  * language.
  */
 public class InstanceFilter extends Filter<InstanceFilter.Criteria> implements Serializable {
     protected static Logger LOG = LoggerFactory.getLogger(InstanceFilter.class);

     private static final long serialVersionUID = 9999;

     /** If set, will filter on the instance id (IID) and select all matching instances */
     private List<String> iids;

     /** If set, will filter on the process id (PID) and select all matching process definitions */
     private List<String> pids;

     /** If set, the PID filter will work negatively */
     private boolean arePidsNegative;

     /** If set, will filter on the process name (accepts ending with wildcard) */
     private String nameFilter;

     /** If set, will filter on the process name (accepts ending with wildcard) */
     private String namespaceFilter;

     /**
      * If set, will filter on the instance status. Status being exclusive,
      * statuses are joined with an 'or'.
      */
     private List<String> statusFilter;

     /**
      * If set, will filter on the process started date. Prefixed with a comparison
      * operator (<, >, <=, >=, =). We're keeping a string and note converting to
      * a java date as ISO string dates are much easier and quicker to manipulate.
      * It's possible to have more than one date filter to handle the 'between'
      * case.
      */
     private List<String> startedDateFilter;

     /** If set, will filter on the process last active date. */
     private List<String> lastActiveDateFilter;

     private Map<String, String> propertyValuesFilter;

     /**
      * Orders to use when sorting the result (no particular order if not set).
      * Currently /supported keys are:
      * <ul>
      * <li>pid</li>
      * <li>name</li>
      * <li>namespace</li>
      * <li>version</li>
      * <li>status</li>
      * <li>started</li>
      * <li>last-active</li>
      * </ul>
      * Each key can be prefixed with a + or - sign for ascending or descending
      * orders (ascending if no sign specified)..
      */
     public List<String> orders;

     private int limit;

     /**
      * Known criteria (and a means to process them).
      */
     enum Criteria {
         IID {
             void process(InstanceFilter filter, String key, String op, String value) {
                 filter.iids = parse(value);
             }
         },
         PID {
             void process(InstanceFilter filter, String key, String op, String value) {
                 filter.pids = parse(value);
                 filter.arePidsNegative = "<>".equals(op);
             }
         },
         NAME {
             void process(InstanceFilter filter, String key, String op, String value) {
                 filter.nameFilter = value;
             }
         },
         NAMESPACE {
             void process(InstanceFilter filter, String key, String op, String value) {
                 filter.namespaceFilter = value;
             }
         },
         STATUS {
             void process(InstanceFilter filter, String key, String op, String value) {
                 filter.statusFilter = parse(value);
             }
         },
         STARTED {
             void process(InstanceFilter filter, String key, String op, String value) {
                 if (filter.startedDateFilter == null)
                     filter.startedDateFilter = new ArrayList<String>();
                 filter.startedDateFilter.add(op + value);
             }
         },
         LAST_ACTIVE {
             void process(InstanceFilter filter, String key, String op, String value) {
                 if (filter.lastActiveDateFilter == null)
                     filter.lastActiveDateFilter = new ArrayList<String>();
                 filter.lastActiveDateFilter.add(op + value);
             }
         },
         PROPERTY {
             void process(InstanceFilter filter, String key, String op, String value) {
                 if (filter.propertyValuesFilter == null)
                     filter.propertyValuesFilter = new HashMap<String, String>(5);
                 filter.propertyValuesFilter.put(key.substring(1, key.length()), value);
             }
         };

         abstract void process(InstanceFilter filter, String key, String op, String value);
     }

     enum OrderKeys {
         PID, NAME, NAMESPACE, VERSION, STATUS, STARTED, LAST_ACTIVE;
     }

     public enum StatusKeys {
         ACTIVE, SUSPENDED, ERROR, COMPLETED, TERMINATED, FAILED, FAULTED;
     }

     /**
      * Initializes properly the InstanceFilter attributes by pre-parsing the
      * filter and orderKeys strings and setting the limit. A limit inferior than
      * or equal to 0 is ignored.
      *
      * @param filter
      * @param orderKeys
      */
     public InstanceFilter(String filter, String orderKeys, int limit) {
         init(filter);

         // Some additional validation on status values
         if (statusFilter != null) {
             for (String status : statusFilter) {
                 try {
                     StatusKeys.valueOf(status.toUpperCase());
                 } catch (IllegalArgumentException e) {
                     throw new InvalidRequestException(
                             "The status you're using in your filter isn't valid, "
                                     + "only the active, suspended, error, completed, terminated and faulted status are "
                                     + "valid. " + e.toString());
                 }
             }
         }
         // Some additional validation on date format value
         if (startedDateFilter != null) {
             for (String ddf : startedDateFilter) {
                 try {
                     parseDateExpression(getDateWithoutOp(ddf));
                 } catch (ParseException e) {
                     throw new InvalidRequestException(
                             "Couldn't parse one of the filter date, please make "
                                     + "sure it follows the ISO-8601 date or date/time standard (yyyyMMddhhmmss). "
                                     + e.toString());
                 }
             }
         }
         if (lastActiveDateFilter != null) {
             for (String ddf : lastActiveDateFilter) {
                 try {
                     parseDateExpression(getDateWithoutOp(ddf));
                 } catch (ParseException e) {
                     throw new InvalidRequestException(
                             "Couldn't parse one of the filter date, please make "
                                     + "sure it follows the ISO-8601 date or date/time standard (yyyyMMddhhmmss). "
                                     + e.toString());
                 }
             }
         }

         if (orderKeys != null && orderKeys.length() > 0) {
             orders = new ArrayList<String>(3);
             for (StringTokenizer orderKeysTok = new StringTokenizer(orderKeys, " "); orderKeysTok
                     .hasMoreTokens();) {
                 String orderKey = orderKeysTok.nextToken();
                 try {
                     String justKey = orderKey;
                     if (justKey.startsWith("-") || justKey.startsWith("+"))
                         justKey = orderKey.substring(1, justKey.length());
                     OrderKeys.valueOf(justKey.replaceAll("-", "_").toUpperCase());
                     orders.add(orderKey);
                 } catch (IllegalArgumentException e) {
                     throw new InvalidRequestException(
                             "One of the ordering keys isn't valid, processes can only "
                                     + "be sorted by pid, name, namespace, version, status, started and last-active "
                                     + "date." + e.toString());

                 }
             }
         }
         if(limit<0) {
             throw new IllegalArgumentException("Limit should be greater or equal to 0.");
         }
         this.limit = limit;
     }

     public InstanceFilter(String filter) {
         this(filter, null, Integer.MAX_VALUE);
     }

     private Date parseDateExpression(String date) throws ParseException {
         if( date.toLowerCase().startsWith("-")  && date.length() > 1 ) {
             return RelativeDateParser.parseRelativeDate(date.substring(1));
         } else {
             return ISO8601DateParser.parse(date);
         }
     }

     /**
      * Converts the status filter value as given by a filter ('active',
      * 'suspended', ...) to an instance state as defined in the ProcessState
      * class.
      *
      * @return one of the STATE_XX constant in ProcessState
      */
     public List<Short> convertFilterState() {
         List<Short> result = new ArrayList<Short>(5);
         short noState = 200;
         for (String status : statusFilter) {
             if (StatusKeys.ACTIVE.toString().equalsIgnoreCase(status)) {
                 result.add(ProcessState.STATE_NEW);
                 result.add(ProcessState.STATE_ACTIVE);
                 result.add(ProcessState.STATE_READY);
             } else if (StatusKeys.SUSPENDED.toString().equalsIgnoreCase(status)) {
                 result.add(ProcessState.STATE_SUSPENDED);
             } else if (StatusKeys.ERROR.toString().equalsIgnoreCase(status)) {
                 result.add(noState); // Error instance state doesn't exist yet
             } else if (StatusKeys.COMPLETED.toString().equalsIgnoreCase(status)) {
                 result.add(ProcessState.STATE_COMPLETED_OK);
             } else if (StatusKeys.TERMINATED.toString().equalsIgnoreCase(status)) {
                 result.add(ProcessState.STATE_TERMINATED);
             } else if (StatusKeys.FAILED.toString().equalsIgnoreCase(status)) {
                 result.add(ProcessState.STATE_COMPLETED_WITH_FAULT);
             } else {
                 result.add(noState); // Non existent state
             }
         }
         return result;
     }

     public String getNameFilter() {
         return nameFilter;
     }

     public String getNamespaceFilter() {
         return namespaceFilter;
     }

     public List<String> getStatusFilter() {
         return statusFilter;
     }

     public List<String> getStartedDateFilter() {
         return startedDateFilter;
     }

     public List<String> getLastActiveDateFilter() {
         return lastActiveDateFilter;
     }

     public Map<String, String> getPropertyValuesFilter() {
         return propertyValuesFilter;
     }

     public List<String> getOrders() {
         return orders;
     }

     public List<String> getPidFilter() {
         return pids;
     }

     public boolean arePidsNegative() {
         return arePidsNegative;
     }

     public List<String> getIidFilter() {
         return iids;
     }

     public static void main(String[] args) {
         InstanceFilter instf = new InstanceFilter(
                 "name = dtc* namespace=http://www.intalio.com* "
                         + "status=active|terminated started>=2005-11-29T15:15:19 started<2005-11-29T15:15:20 last-active < 2005-11-30 "
                         + "${http://ode.org/}order-id= 12 $shipping-id=aa45fz", "name started", 50);
         System.out.println(instf);
     }

     @Override
     protected Criteria parseKey(String keyVal) {
         if (keyVal.startsWith("$")) return Criteria.PROPERTY;
         else return Criteria.valueOf(keyVal);
     }

     @Override
     protected Criteria[] getFilterKeys() {
         return Criteria.values();
     }

     @Override
     protected void process(Criteria key, Restriction<String> rest) {
         key.process(this, rest.originalKey, rest.op, rest.value);
     }

     /**
      * @return the limit
      */
     public int getLimit() {
         return limit;
     }


     public String toString() {
         StringBuffer buf = new StringBuffer();
         buf.append("InstanceFilter {");
         buf.append("iids="+iids);
         if( !arePidsNegative ) {
             buf.append(",pids="+pids);
         } else {
             buf.append(",-pids="+pids);
         }
         buf.append(",name="+nameFilter);
         buf.append(",namespace="+namespaceFilter);
         buf.append(",status="+statusFilter);
         buf.append(",startedDate="+startedDateFilter);
         buf.append(",lastActiveDate="+lastActiveDateFilter);
         buf.append(",propertyValues="+propertyValuesFilter);
         buf.append(",orders="+orders);
         buf.append(",limit="+limit);
         buf.append("}");
         return buf.toString();
     }

     private static List<String> parse(String pipeDelimited) {
         List<String> list = new ArrayList<String>();
         StringTokenizer tok = new StringTokenizer(pipeDelimited, "|");
         while (tok.hasMoreTokens()) {
             list.add(tok.nextToken());
         }
         return list;
     }
 }
	/*
	* 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.ode.bpel.common;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.apache.ode.bpel.pmapi.InvalidRequestException;
	import org.apache.ode.utils.ISO8601DateParser;
	import org.apache.ode.utils.RelativeDateParser;

	import java.io.Serializable;
	import java.text.ParseException;
	import java.util.ArrayList;
	import java.util.Date;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.StringTokenizer;

	/**
	* Holds a filter that will get interpreted when listing processe instances. The
	* semantic of the filtering is somewhat different than the one used in the
	* ProcessQuery class. Here we're introducing a pseudo process querying
	* language.
	*/
	public class InstanceFilter extends Filter<InstanceFilter.Criteria> implements Serializable {
	protected static Logger LOG = LoggerFactory.getLogger(InstanceFilter.class);

	private static final long serialVersionUID = 9999;

	/** If set, will filter on the instance id (IID) and select all matching instances */
	private List<String> iids;

	/** If set, will filter on the process id (PID) and select all matching process definitions */
	private List<String> pids;

	/** If set, the PID filter will work negatively */
	private boolean arePidsNegative;

	/** If set, will filter on the process name (accepts ending with wildcard) */
	private String nameFilter;

	/** If set, will filter on the process name (accepts ending with wildcard) */
	private String namespaceFilter;

	/**
	* If set, will filter on the instance status. Status being exclusive,
	* statuses are joined with an 'or'.
	*/
	private List<String> statusFilter;

	/**
	* If set, will filter on the process started date. Prefixed with a comparison
	* operator (<, >, <=, >=, =). We're keeping a string and note converting to
	* a java date as ISO string dates are much easier and quicker to manipulate.
	* It's possible to have more than one date filter to handle the 'between'
	* case.
	*/
	private List<String> startedDateFilter;

	/** If set, will filter on the process last active date. */
	private List<String> lastActiveDateFilter;

	private Map<String, String> propertyValuesFilter;

	/**
	* Orders to use when sorting the result (no particular order if not set).
	* Currently /supported keys are:
	* <ul>
	* <li>pid</li>
	* <li>name</li>
	* <li>namespace</li>
	* <li>version</li>
	* <li>status</li>
	* <li>started</li>
	* <li>last-active</li>
	* </ul>
	* Each key can be prefixed with a + or - sign for ascending or descending
	* orders (ascending if no sign specified)..
	*/
	public List<String> orders;

	private int limit;

	/**
	* Known criteria (and a means to process them).
	*/
	enum Criteria {
	IID {
	void process(InstanceFilter filter, String key, String op, String value) {
	filter.iids = parse(value);
	}
	},
	PID {
	void process(InstanceFilter filter, String key, String op, String value) {
	filter.pids = parse(value);
	filter.arePidsNegative = "<>".equals(op);
	}
	},
	NAME {
	void process(InstanceFilter filter, String key, String op, String value) {
	filter.nameFilter = value;
	}
	},
	NAMESPACE {
	void process(InstanceFilter filter, String key, String op, String value) {
	filter.namespaceFilter = value;
	}
	},
	STATUS {
	void process(InstanceFilter filter, String key, String op, String value) {
	filter.statusFilter = parse(value);
	}
	},
	STARTED {
	void process(InstanceFilter filter, String key, String op, String value) {
	if (filter.startedDateFilter == null)
	filter.startedDateFilter = new ArrayList<String>();
	filter.startedDateFilter.add(op + value);
	}
	},
	LAST_ACTIVE {
	void process(InstanceFilter filter, String key, String op, String value) {
	if (filter.lastActiveDateFilter == null)
	filter.lastActiveDateFilter = new ArrayList<String>();
	filter.lastActiveDateFilter.add(op + value);
	}
	},
	PROPERTY {
	void process(InstanceFilter filter, String key, String op, String value) {
	if (filter.propertyValuesFilter == null)
	filter.propertyValuesFilter = new HashMap<String, String>(5);
	filter.propertyValuesFilter.put(key.substring(1, key.length()), value);
	}
	};

	abstract void process(InstanceFilter filter, String key, String op, String value);
	}

	enum OrderKeys {
	PID, NAME, NAMESPACE, VERSION, STATUS, STARTED, LAST_ACTIVE;
	}

	public enum StatusKeys {
	ACTIVE, SUSPENDED, ERROR, COMPLETED, TERMINATED, FAILED, FAULTED;
	}

	/**
	* Initializes properly the InstanceFilter attributes by pre-parsing the
	* filter and orderKeys strings and setting the limit. A limit inferior than
	* or equal to 0 is ignored.
	*
	* @param filter
	* @param orderKeys
	*/
	public InstanceFilter(String filter, String orderKeys, int limit) {
	init(filter);

	// Some additional validation on status values
	if (statusFilter != null) {
	for (String status : statusFilter) {
	try {
	StatusKeys.valueOf(status.toUpperCase());
	} catch (IllegalArgumentException e) {
	throw new InvalidRequestException(
	"The status you're using in your filter isn't valid, "
	+ "only the active, suspended, error, completed, terminated and faulted status are "
	+ "valid. " + e.toString());
	}
	}
	}
	// Some additional validation on date format value
	if (startedDateFilter != null) {
	for (String ddf : startedDateFilter) {
	try {
	parseDateExpression(getDateWithoutOp(ddf));
	} catch (ParseException e) {
	throw new InvalidRequestException(
	"Couldn't parse one of the filter date, please make "
	+ "sure it follows the ISO-8601 date or date/time standard (yyyyMMddhhmmss). "
	+ e.toString());
	}
	}
	}
	if (lastActiveDateFilter != null) {
	for (String ddf : lastActiveDateFilter) {
	try {
	parseDateExpression(getDateWithoutOp(ddf));
	} catch (ParseException e) {
	throw new InvalidRequestException(
	"Couldn't parse one of the filter date, please make "
	+ "sure it follows the ISO-8601 date or date/time standard (yyyyMMddhhmmss). "
	+ e.toString());
	}
	}
	}

	if (orderKeys != null && orderKeys.length() > 0) {
	orders = new ArrayList<String>(3);
	for (StringTokenizer orderKeysTok = new StringTokenizer(orderKeys, " "); orderKeysTok
	.hasMoreTokens();) {
	String orderKey = orderKeysTok.nextToken();
	try {
	String justKey = orderKey;
	if (justKey.startsWith("-") \|\| justKey.startsWith("+"))
	justKey = orderKey.substring(1, justKey.length());
	OrderKeys.valueOf(justKey.replaceAll("-", "_").toUpperCase());
	orders.add(orderKey);
	} catch (IllegalArgumentException e) {
	throw new InvalidRequestException(
	"One of the ordering keys isn't valid, processes can only "
	+ "be sorted by pid, name, namespace, version, status, started and last-active "
	+ "date." + e.toString());

	}
	}
	}
	if(limit<0) {
	throw new IllegalArgumentException("Limit should be greater or equal to 0.");
	}
	this.limit = limit;
	}

	public InstanceFilter(String filter) {
	this(filter, null, Integer.MAX_VALUE);
	}

	private Date parseDateExpression(String date) throws ParseException {
	if( date.toLowerCase().startsWith("-") && date.length() > 1 ) {
	return RelativeDateParser.parseRelativeDate(date.substring(1));
	} else {
	return ISO8601DateParser.parse(date);
	}
	}

	/**
	* Converts the status filter value as given by a filter ('active',
	* 'suspended', ...) to an instance state as defined in the ProcessState
	* class.
	*
	* @return one of the STATE_XX constant in ProcessState
	*/
	public List<Short> convertFilterState() {
	List<Short> result = new ArrayList<Short>(5);
	short noState = 200;
	for (String status : statusFilter) {
	if (StatusKeys.ACTIVE.toString().equalsIgnoreCase(status)) {
	result.add(ProcessState.STATE_NEW);
	result.add(ProcessState.STATE_ACTIVE);
	result.add(ProcessState.STATE_READY);
	} else if (StatusKeys.SUSPENDED.toString().equalsIgnoreCase(status)) {
	result.add(ProcessState.STATE_SUSPENDED);
	} else if (StatusKeys.ERROR.toString().equalsIgnoreCase(status)) {
	result.add(noState); // Error instance state doesn't exist yet
	} else if (StatusKeys.COMPLETED.toString().equalsIgnoreCase(status)) {
	result.add(ProcessState.STATE_COMPLETED_OK);
	} else if (StatusKeys.TERMINATED.toString().equalsIgnoreCase(status)) {
	result.add(ProcessState.STATE_TERMINATED);
	} else if (StatusKeys.FAILED.toString().equalsIgnoreCase(status)) {
	result.add(ProcessState.STATE_COMPLETED_WITH_FAULT);
	} else {
	result.add(noState); // Non existent state
	}
	}
	return result;
	}

	public String getNameFilter() {
	return nameFilter;
	}

	public String getNamespaceFilter() {
	return namespaceFilter;
	}

	public List<String> getStatusFilter() {
	return statusFilter;
	}

	public List<String> getStartedDateFilter() {
	return startedDateFilter;
	}

	public List<String> getLastActiveDateFilter() {
	return lastActiveDateFilter;
	}

	public Map<String, String> getPropertyValuesFilter() {
	return propertyValuesFilter;
	}

	public List<String> getOrders() {
	return orders;
	}

	public List<String> getPidFilter() {
	return pids;
	}

	public boolean arePidsNegative() {
	return arePidsNegative;
	}

	public List<String> getIidFilter() {
	return iids;
	}

	public static void main(String[] args) {
	InstanceFilter instf = new InstanceFilter(
	"name = dtc* namespace=http://www.intalio.com* "
	+ "status=active\|terminated started>=2005-11-29T15:15:19 started<2005-11-29T15:15:20 last-active < 2005-11-30 "
	+ "${http://ode.org/}order-id= 12 $shipping-id=aa45fz", "name started", 50);
	System.out.println(instf);
	}

	@Override
	protected Criteria parseKey(String keyVal) {
	if (keyVal.startsWith("$")) return Criteria.PROPERTY;
	else return Criteria.valueOf(keyVal);
	}

	@Override
	protected Criteria[] getFilterKeys() {
	return Criteria.values();
	}

	@Override
	protected void process(Criteria key, Restriction<String> rest) {
	key.process(this, rest.originalKey, rest.op, rest.value);
	}

	/**
	* @return the limit
	*/
	public int getLimit() {
	return limit;
	}


	public String toString() {
	StringBuffer buf = new StringBuffer();
	buf.append("InstanceFilter {");
	buf.append("iids="+iids);
	if( !arePidsNegative ) {
	buf.append(",pids="+pids);
	} else {
	buf.append(",-pids="+pids);
	}
	buf.append(",name="+nameFilter);
	buf.append(",namespace="+namespaceFilter);
	buf.append(",status="+statusFilter);
	buf.append(",startedDate="+startedDateFilter);
	buf.append(",lastActiveDate="+lastActiveDateFilter);
	buf.append(",propertyValues="+propertyValuesFilter);
	buf.append(",orders="+orders);
	buf.append(",limit="+limit);
	buf.append("}");
	return buf.toString();
	}

	private static List<String> parse(String pipeDelimited) {
	List<String> list = new ArrayList<String>();
	StringTokenizer tok = new StringTokenizer(pipeDelimited, "\|");
	while (tok.hasMoreTokens()) {
	list.add(tok.nextToken());
	}
	return list;
	}
	}