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         public static URL encode(File file, SearchQuery query) throws IOException {
 112                 URL url = file.toURI().toURL();
 113                 String s = url.toString() + "?search=" + URLEncoder.encode(query.getOriginalQuery(), "UTF-8");
 114                 Map<String, String> flags = query.getSearchFlags();
 115                 for (String key : flags.keySet()) {
 116                         s += "&"+key+"="+flags.get(key);
 117                 }
 118
 119                 for (String param : query.getSearchParams()) {
 120                         s += "&"+param;
 121                 }
 122
 123                 url = new URL(s);
 124                 return url;
 125         }
 126
 127     public static SearchQuery decode(URL url) throws IOException{
 128          String query = url.getQuery();
 129          SearchQuery searchQuery = new SearchQuery();
 130          if (query != null) {
 131              for (String arg : query.split("&")) {
 132                  String[] keyvalue = arg.split("=");
 133                  if ("search".equals(keyvalue[0])) {
 134                     if (keyvalue.length == 2)
 135                          searchQuery.setOriginalQuery(URLDecoder.decode(keyvalue[1], "UTF-8"));
 136                  } else if (keyvalue.length == 2){
 137                          searchQuery.setSearchFlag(URLDecoder.decode(keyvalue[0], "UTF-8"), URLDecoder.decode(keyvalue[1], "UTF-8"));
 138                  } else if (keyvalue.length == 1) {
 139                          searchQuery.setSearchParam(URLDecoder.decode(keyvalue[0], "UTF-8"));
 140                  }
 141              }
 142          }
 143          return searchQuery;
 144     }
 145
 146
 147
 148 }