bundles/org.simantics.workbench.search/src/org/simantics/workbench/search/SearchQuery.java

   1 package org.simantics.workbench.search;
   2
   3 import java.io.File;
   4 import java.io.IOException;
   5 import java.net.URL;
   6 import java.net.URLDecoder;
   7 import java.net.URLEncoder;
   8 import java.util.Collections;
   9 import java.util.HashMap;
  10 import java.util.HashSet;
  11 import java.util.Map;
  12 import java.util.Set;
  13
  14 import org.simantics.db.layer0.genericrelation.IndexQueries;
  15
  16 public class SearchQuery {
  17
  18         private String originalQuery;
  19         private Map<String,String> searchFlags = new HashMap<String, String>();
  20         private Set<String> searchParams = new HashSet<String>();
  21
  22         public SearchQuery() {
  23         }
  24
  25         public SearchQuery(String originalQuery) {
  26                 this.originalQuery = originalQuery;
  27         }
  28
  29         public void setOriginalQuery(String originalQuery) {
  30                 this.originalQuery = originalQuery;
  31         }
  32
  33         public String getOriginalQuery() {
  34                 return originalQuery;
  35         }
  36
  37         public String getQuery(Set<String> supportedParams) {
  38                 if (originalQuery.trim().isEmpty())
  39                         return "";
  40                 String query = "";
  41                 int count = 0;
  42                 for (String key : searchFlags.keySet()) {
  43                         if (!supportedParams.contains(key))
  44                                 continue;
  45                         if (!"on".equals(searchFlags.get(key)))
  46                                 continue;
  47                         if (count > 0)
  48                                 query += " OR ";
  49 //                      String prefix = originalQuery.startsWith("*") ? "" : "*";
  50 //                      String suffix = originalQuery.endsWith("*") ? "" : "*";
  51 //                      query += key+":"+prefix+originalQuery+suffix;
  52                         query += key+":"+originalQuery;
  53                         count++;
  54                 }
  55                 return query;
  56         }
  57
  58         public String getQuery(String... supportedParams) {
  59                 Set<String> set = new HashSet<String>();
  60                 for (String s : supportedParams)
  61                         set.add(s);
  62                 return getQuery(set);
  63         }
  64
  65
  66
  67         public void setSearchFlag(String key, String value) {
  68                 searchFlags.put(key, value);
  69         }
  70
  71         public void setSearchParam(String key) {
  72                 searchParams.add(key);
  73         }
  74
  75         public Map<String, String> getSearchFlags() {
  76                 return Collections.unmodifiableMap(searchFlags);
  77         }
  78
  79         public Set<String> getSearchParams() {
  80                 return Collections.unmodifiableSet(searchParams);
  81         }
  82
  83         public boolean getBooleanFlag(String key) {
  84                 if ("on".equals(searchFlags.get(key)))
  85                         return true;
  86                 return false;
  87         }
  88
  89         public boolean getBooleanParam(String key) {
  90                 if (searchParams.contains(key))
  91                         return true;
  92                 return false;
  93         }
  94
  95         @Override
  96         public String toString() {
  97                 return originalQuery;
  98         }
  99
 100         public SearchQuery withOriginalQuery(String query) {
 101                 SearchQuery ret = new SearchQuery(query);
 102                 ret.searchFlags = new HashMap<String, String>(searchFlags);
 103                 ret.searchParams = new HashSet<String>(searchParams);
 104                 return ret;
 105         }
 106
 107         public SearchQuery escaped(boolean escapeWildcards) {
 108                 return withOriginalQuery( IndexQueries.escape( originalQuery, escapeWildcards ) );
 109         }
 110
 111         /**
 112          * @param uppercase <code>true</code> for uppercased query, <code>false</code>
 113          *                  for lowercased query
 114          * @return a clone of this query with the query string in lower or uppercase
 115          */
 116         public SearchQuery withForcedCase(boolean uppercase) {
 117                 return withOriginalQuery(uppercase ? originalQuery.toUpperCase() : originalQuery.toLowerCase());
 118         }
 119
 120         /**
 121          * @param uppercase       <code>true</code> for uppercased query,
 122          *                        <code>false</code> for lowercased query
 123          * @param escapeWildcards passed to {@link #escaped(boolean)}
 124          * @return a clone of this query with the query string escaped and in lower or
 125          *         uppercase
 126          */
 127         public SearchQuery escapedWithForcedCase(boolean uppercase, boolean escapeWildcards) {
 128                 return withForcedCase(uppercase).escaped(escapeWildcards);
 129         }
 130
 131         public static URL encode(File file, SearchQuery query) throws IOException {
 132                 URL url = file.toURI().toURL();
 133                 String s = url.toString() + "?search=" + URLEncoder.encode(query.getOriginalQuery(), "UTF-8");
 134                 Map<String, String> flags = query.getSearchFlags();
 135                 for (String key : flags.keySet()) {
 136                         s += "&"+key+"="+flags.get(key);
 137                 }
 138
 139                 for (String param : query.getSearchParams()) {
 140                         s += "&"+param;
 141                 }
 142
 143                 url = new URL(s);
 144                 return url;
 145         }
 146
 147     public static SearchQuery decode(URL url) throws IOException{
 148          String query = url.getQuery();
 149          SearchQuery searchQuery = new SearchQuery();
 150          if (query != null) {
 151              for (String arg : query.split("&")) {
 152                  String[] keyvalue = arg.split("=");
 153                  if ("search".equals(keyvalue[0])) {
 154                     if (keyvalue.length == 2)
 155                          searchQuery.setOriginalQuery(URLDecoder.decode(keyvalue[1], "UTF-8"));
 156                  } else if (keyvalue.length == 2){
 157                          searchQuery.setSearchFlag(URLDecoder.decode(keyvalue[0], "UTF-8"), URLDecoder.decode(keyvalue[1], "UTF-8"));
 158                  } else if (keyvalue.length == 1) {
 159                          searchQuery.setSearchParam(URLDecoder.decode(keyvalue[0], "UTF-8"));
 160                  }
 161              }
 162          }
 163          return searchQuery;
 164     }
 165
 166
 167
 168 }