View Javadoc

1   package com.atlassian.user.search.query;
2   
3   import java.util.List;
4   import java.util.Iterator;
5   
6   public abstract class AbstractEntityQueryParser implements EntityQueryParser
7   {
8       protected void validateQuery(Query query) throws EntityQueryException
9       {
10          if (query instanceof MembershipQuery)
11              throw new IllegalArgumentException("Membership queries are illegal until we verify they can be performed on" +
12                      " all LDAP system (i.e. the membership attribute must support substring matching");
13  
14          if (query == null)
15              throw new IllegalArgumentException("Null arg.");
16  
17          if (!(query instanceof BooleanQuery))
18              return;
19  
20          validateBooleanToQueryType((BooleanQuery) query, null);
21      }
22  
23      /**
24       * Ensures that the {@link BooleanQuery} combines queries of a singular type {@link UserQuery}, {@link GroupQuery}, or
25       * {@link MembershipQuery}.
26       */
27      protected void validateBooleanToQueryType(BooleanQuery query, String queryClassName) throws EntityQueryException
28      {
29          List queries = query.getQueries();
30          Iterator queryIter = queries.iterator();
31  
32          while (queryIter.hasNext())
33          {
34              Query foundQuery = (Query) queryIter.next();
35  
36              if (foundQuery instanceof BooleanQuery)
37              {
38                  validateBooleanToQueryType((BooleanQuery) foundQuery, queryClassName);
39                  return;
40              }
41  
42              if (queryClassName == null) //identify the type of query which the BooleanQuery is restricted to
43              {
44                  queryClassName = matchQueryToQueryType(foundQuery);
45              }
46          }
47      }
48  
49      protected String matchQueryToQueryType(Query query1)
50      {
51          String queryClassName = null;
52  
53          if (query1 instanceof UserQuery)
54              queryClassName = UserQuery.class.getName();
55          else if (query1 instanceof GroupQuery)
56              queryClassName = GroupQuery.class.getName();
57          else if (query1 instanceof MembershipQuery)
58              queryClassName = MembershipQuery.class.getName();
59  
60          return queryClassName;
61      }
62  
63      /**
64       * The 'defining query' lets us know which EntityClass we are querying.
65       */
66      protected Query identifyDefiningQuery(BooleanQuery q)
67      {
68          if (q instanceof MembershipQuery)
69              return q;
70  
71          Iterator iter = q.getQueries().iterator();
72          TermQuery foundQuery = null;
73  
74          while (iter.hasNext())
75          {
76              Query query = (Query) iter.next();
77              if (query instanceof TermQuery)
78              {
79                  foundQuery = (TermQuery) query;
80                  break;
81              }
82              else if (query instanceof BooleanQuery)
83                  return identifyDefiningQuery((BooleanQuery) query);
84          }
85  
86          return foundQuery;
87      }
88  }