{
}
JSONObject subObj = convertExpl(detail);
import org.json.JSONException;
import org.json.JSONObject;
<<<<<<< HEAD
import static com.sensei.search.client.servlet.SenseiSearchServletParams.*;
public class DefaultSenseiJSONServlet extends AbstractSenseiRestServlet
{
/**
*
*/
private static final long serialVersionUID = 1L;
private static Logger logger = Logger.getLogger(DefaultSenseiJSONServlet.class);
public static JSONObject convertExpl(Explanation expl)
throws JSONException
{
JSONObject jsonObject = null;
if (expl != null)
{
jsonObject = new JSONObject();
float val = expl.getValue();
jsonObject.put("value", val);
String descr = expl.getDescription();
jsonObject.put("description", descr == null ? "" : descr);
Explanation[] details = expl.getDetails();
if (details != null)
{
JSONArray detailArray = new JSONArray();
for (Explanation detail : details)
{
if (subObj != null)
{
detailArray.put(subObj);
}
}
jsonObject.put("details", detailArray);
}
}
return jsonObject;
}
public static JSONObject convert(Map facetValueMap, SenseiRequest req)
throws JSONException
{
JSONObject resMap = new JSONObject();
if (facetValueMap != null)
{
Set> entrySet = facetValueMap.entrySet();
for (Entry entry : entrySet)
{
String fieldname = entry.getKey();
BrowseSelection sel = req.getSelection(fieldname);
HashSet selectedVals = new HashSet();
if (sel != null)
{
String[] vals = sel.getValues();
if (vals != null && vals.length > 0)
{
selectedVals.addAll(Arrays.asList(vals));
}
}
FacetAccessible facetAccessible = entry.getValue();
List facetList = facetAccessible.getFacets();
ArrayList facets = new ArrayList();
for (BrowseFacet f : facetList)
{
String fval = f.getValue();
if (fval != null && fval.length() > 0)
{
JSONObject fv = new JSONObject();
fv.put("count", f.getFacetValueHitCount());
fv.put("value", fval);
fv.put("selected", selectedVals.remove(fval));
facets.add(fv);
}
}
if (selectedVals.size() > 0)
{
// selected vals did not make it in top n
for (String selectedVal : selectedVals)
{
if (selectedVal != null && selectedVal.length() > 0)
{
BrowseFacet selectedFacetVal = facetAccessible.getFacet(selectedVal);
JSONObject fv = new JSONObject();
fv.put("count", selectedFacetVal == null ? 0 : selectedFacetVal.getFacetValueHitCount());
String fval = selectedFacetVal == null ? selectedVal : selectedFacetVal.getValue();
fv.put("value", fval);
fv.put("selected", true);
facets.add(fv);
}
}
// we need to sort it
FacetSpec fspec = req.getFacetSpec(fieldname);
assert fspec != null;
FacetSortSpec sortSpec = fspec.getOrderBy();
if (FacetSortSpec.OrderHitsDesc.equals(sortSpec))
{
Collections.sort(facets, new Comparator()
{
@Override
public int compare(JSONObject o1, JSONObject o2)
{
try
{
int c1 = o1.getInt("count");
int c2 = o2.getInt("count");
int val = c2 - c1;
if (val == 0)
{
String s1 = o1.getString("value");
String s2 = o1.getString("value");
val = s1.compareTo(s2);
}
return val;
}
catch (Exception e)
{
logger.error(e.getMessage(), e);
return 0;
}
}
});
}
else if (FacetSortSpec.OrderValueAsc.equals(sortSpec))
{
Collections.sort(facets, new Comparator()
{
@Override
public int compare(JSONObject o1, JSONObject o2)
{
try
{
String s1 = o1.getString("value");
String s2 = o1.getString("value");
return s1.compareTo(s2);
}
catch (Exception e)
{
logger.error(e.getMessage(), e);
return 0;
}
}
});
}
else
{
throw new IllegalStateException(fieldname + " sorting is not supported");
}
}
resMap.put(fieldname, facets);
}
}
return resMap;
}
@Override
protected String buildResultString(SenseiRequest req, SenseiResult res)
throws Exception
{
return buildJSONResultString(req, res);
}
public static String buildJSONResultString(SenseiRequest req, SenseiResult res)
throws Exception
JSONObject jsonObj = buildJSONResult(req, res);
return jsonObj.toString();
}
public static JSONObject buildJSONResult(SenseiRequest req, SenseiResult res)
throws Exception
{
JSONObject jsonObj = new JSONObject();
int totalDocs = res.getTotalDocs();
int numHits = res.getNumHits();
jsonObj.put(PARAM_RESULT_TOTALDOCS, totalDocs);
jsonObj.put(PARAM_RESULT_NUMHITS, numHits);
jsonObj.put(PARAM_RESULT_PARSEDQUERY, res.getParsedQuery());
SenseiHit[] hits = res.getSenseiHits();
JSONArray hitArray = new JSONArray();
jsonObj.put(PARAM_RESULT_HITS, hitArray);
for (SenseiHit hit : hits)
{
long uid = hit.getUID();
float score = hit.getScore();
Map fieldMap = hit.getFieldValues();
JSONObject hitObj = new JSONObject();
hitObj.put(PARAM_RESULT_HIT_UID, String.valueOf(uid));
hitObj.put(PARAM_RESULT_HIT_SCORE, score);
if (fieldMap != null)
{
Set> entries = fieldMap.entrySet();
for (Entry entry : entries)
{
String key = entry.getKey();
String[] vals = entry.getValue();
JSONArray valArray = new JSONArray();
for (String val : vals)
{
valArray.put(val);
}
hitObj.put(key, valArray);
}
}
Document doc = hit.getStoredFields();
if (doc != null)
{
JSONObject storedData = new JSONObject();
List fields = doc.getFields();
for (Fieldable field : fields)
{
String name = field.name();
String val = field.stringValue();
storedData.put("name", name);
storedData.put("val", val);
}
hitObj.put("stored", storedData);
}
Explanation expl = hit.getExplanation();
if (expl != null)
{
hitObj.put(PARAM_RESULT_HIT_EXPLANATION, convertExpl(expl));
}
hitArray.put(hitObj);
}
jsonObj.put(PARAM_RESULT_TIME, res.getTime());
jsonObj.put(PARAM_RESULT_FACETS, convert(res.getFacetMap(), req));
return jsonObj;
}
public static SenseiQuery buildSenseiQuery(DataConfiguration params)
{
SenseiQuery sq = null;
String query = params.getString(PARAM_QUERY, null);
JSONObject qjson = new JSONObject();
if (query != null && query.length() > 0)
{
try
{
qjson.put("query", query);
}
catch (Exception e)
{
logger.error(e.getMessage(), e);
}
}
try
{
String[] qparams = params.getStringArray(PARAM_QUERY_PARAM);
for (String qparam : qparams)
{
qparam = qparam.trim();
if (qparam.length() == 0) continue;
String[] parts = qparam.split(":");
if (parts.length == 2)
{
qjson.put(parts[0], parts[1]);
}
}
}
catch (JSONException jse)
{
logger.error(jse.getMessage(), jse);
}
sq = new SenseiJSONQuery(qjson);
return sq;
}
@Override
protected SenseiRequest buildSenseiRequest(DataConfiguration params)
throws Exception
{
return convertSenseiRequest(params);
}
public static SenseiRequest convertSenseiRequest(DataConfiguration params)
{
int offset = params.getInt(PARAM_OFFSET, 0);
int count = params.getInt(PARAM_COUNT, 10);
SenseiRequest senseiReq = new SenseiRequest();
senseiReq.setOffset(offset);
senseiReq.setCount(count);
senseiReq.setQuery(buildSenseiQuery(params));
senseiReq.setShowExplanation(params.getBoolean(PARAM_SHOW_EXPLAIN, false));
senseiReq.setFetchStoredFields(params.getBoolean(PARAM_FETCH_STORED, false));
convertSortParam(senseiReq, params);
convertSelectParam(senseiReq, params);
convertFacetParam(senseiReq, params);
convertInitParams(senseiReq, params);
return senseiReq;
}
private static void convertInitParams(SenseiRequest senseiReq, DataConfiguration params)
{
Map facetParamMap = RequestConverter.parseParamConf(params, PARAM_DYNAMIC_INIT);
Set> facetEntries = facetParamMap.entrySet();
for (Entry facetEntry : facetEntries)
{
String facetName = facetEntry.getKey();
Configuration facetConf = facetEntry.getValue();
Iterator paramsIter = facetConf.getKeys();
while (paramsIter.hasNext())
{
String paramName = (String)paramsIter.next();
Configuration paramConf = (Configuration)facetConf.getProperty(paramName);
String type = paramConf.getString(PARAM_DYNAMIC_TYPE);
List vals = paramConf.getList(PARAM_DYNAMIC_VAL);
try
{
FacetHandlerInitializerParam param;
String[] attrVals = vals.toArray(new String[0]);
if (attrVals.length == 0 || attrVals[0].length() == 0)
{
logger.warn(String.format("init param has no values: facet: {0} type '{1}' ", facetName, type));
continue;
}
// TODO: smarter dispatching, factory, generics
if (type.equalsIgnoreCase("boolean"))
{
param = createBooleanInitParam(paramName, attrVals);
}
else if (type.equalsIgnoreCase("string"))
{
param = createStringInitParam(paramName, attrVals);
}
else if (type.equalsIgnoreCase("int"))
{
param = createIntInitParam(paramName, attrVals);
}
else if (type.equalsIgnoreCase("bytearray"))
{
param = createByteArrayInitParam(paramName, paramConf.getString(PARAM_DYNAMIC_VAL));
}
else if (type.equalsIgnoreCase("long"))
{
param = createLongInitParam(paramName, attrVals);
}
else if (type.equalsIgnoreCase("double"))
{
param = createDoubleInitParam(paramName, attrVals);
}
else
{
logger.warn(String.format("Unknown init param name '{0}' type '{1}' for facet: {2} ", paramName, type, facetName));
continue;
}
senseiReq.setFacetHandlerInitializerParam(facetName, param);
}
catch (Exception e)
{
logger.warn(String.format("Failed to parse init param name '{0}' type '{1}' for facetName", paramName, type, facetName));
}
}
}
}
private static FacetHandlerInitializerParam createBooleanInitParam(String name, String[] paramVals)
{
DefaultFacetHandlerInitializerParam param = new DefaultFacetHandlerInitializerParam();
boolean[] vals = new boolean[paramVals.length];
int i = 0;
for (String paramVal : paramVals ) {
vals[i] = Boolean.parseBoolean(paramVal);
}
param.putBooleanParam(name, vals);
return param;
}
private static FacetHandlerInitializerParam createStringInitParam(String name, String[] paramVals)
{
DefaultFacetHandlerInitializerParam param = new DefaultFacetHandlerInitializerParam();
param.putStringParam(name, Arrays.asList(paramVals));
return param;
}
private static FacetHandlerInitializerParam createIntInitParam(String name, String[] paramVals)
{
DefaultFacetHandlerInitializerParam param = new DefaultFacetHandlerInitializerParam();
int[] vals = new int[paramVals.length];
int i = 0;
for (String paramVal : paramVals ) {
vals[i] = Integer.parseInt(paramVal);
}
param.putIntParam(name, vals);
return param;
}
private static FacetHandlerInitializerParam createByteArrayInitParam(String name, String paramVal)
throws UnsupportedEncodingException
{
DefaultFacetHandlerInitializerParam param = new DefaultFacetHandlerInitializerParam();
byte[] val = paramVal.getBytes("UTF-8");
param.putByteArrayParam(name, val);
return param;
}
private static FacetHandlerInitializerParam createLongInitParam(String name, String[] paramVals)
{
DefaultFacetHandlerInitializerParam param = new DefaultFacetHandlerInitializerParam();
long[] vals = new long[paramVals.length];
int i = 0;
for (String paramVal : paramVals ) {
vals[i] = Long.parseLong(paramVal);
}
param.putLongParam(name, vals);
return param;
}
private static FacetHandlerInitializerParam createDoubleInitParam(String name, String[] paramVals)
{
DefaultFacetHandlerInitializerParam param = new DefaultFacetHandlerInitializerParam();
double[] vals = new double[paramVals.length];
int i = 0;
for (String paramVal : paramVals ) {
vals[i] = Double.parseDouble(paramVal);
}
param.putDoubleParam(name, vals);
return param;
}
private static void convertSortParam(SenseiRequest senseiReq, DataConfiguration params)
{
String[] sortStrings = params.getStringArray(PARAM_SORT);
if (sortStrings != null && sortStrings.length > 0)
{
ArrayList sortFieldList = new ArrayList(sortStrings.length);
for (String sortString : sortStrings)
{
sortString = sortString.trim();
if (sortString.length() == 0) continue;
SortField sf;
String[] parts = sortString.split(":");
if (parts.length == 2)
{
boolean reverse = PARAM_SORT_DESC.equals(parts[1]);
sf = new SortField(parts[0], SortField.CUSTOM, reverse);
}
else if (parts.length == 1)
{
if (PARAM_SORT_SCORE.equals(parts[0]))
{
sf = SortField.FIELD_SCORE;
}
else
{
sf = new SortField(parts[0], SortField.CUSTOM, false);
}
}
else
{
throw new IllegalArgumentException("invalid sort string: " + sortString);
}
logger.info("added sort: " + sf);
sortFieldList.add(sf);
}
senseiReq.setSort(sortFieldList.toArray(new SortField[sortFieldList.size()]));
}
}
private static void convertFacetParam(SenseiRequest senseiReq, DataConfiguration params)
{
Map facetParamMap = RequestConverter.parseParamConf(params, PARAM_FACET);
Set> entries = facetParamMap.entrySet();
for (Entry entry : entries)
{
String name = entry.getKey();
Configuration conf = entry.getValue();
FacetSpec fspec = new FacetSpec();
fspec.setExpandSelection(conf.getBoolean(PARAM_FACET_EXPAND, false));
fspec.setMaxCount(conf.getInt(PARAM_FACET_MAX, 10));
fspec.setMinHitCount(conf.getInt(PARAM_FACET_MINHIT, 1));
FacetSpec.FacetSortSpec orderBy;
String orderString = conf.getString(PARAM_FACET_ORDER, PARAM_FACET_ORDER_HITS);
if (PARAM_FACET_ORDER_HITS.equals(orderString))
{
orderBy = FacetSpec.FacetSortSpec.OrderHitsDesc;
}
else if (PARAM_FACET_ORDER_VAL.equals(orderString))
{
orderBy = FacetSpec.FacetSortSpec.OrderValueAsc;
}
else
{
throw new IllegalArgumentException("invalid order string: " + orderString);
}
fspec.setOrderBy(orderBy);
senseiReq.setFacetSpec(name, fspec);
}
}
private static void convertSelectParam(SenseiRequest senseiReq, DataConfiguration params)
{
Map selectParamMap = RequestConverter.parseParamConf(params, PARAM_SELECT);
Set> entries = selectParamMap.entrySet();
for (Entry entry : entries)
{
String name = entry.getKey();
Configuration conf = entry.getValue();
BrowseSelection sel = new BrowseSelection(name);
String[] vals = conf.getStringArray(PARAM_SELECT_VAL);
for (String val : vals)
{
if (val.trim().length() > 0)
{
sel.addValue(val);
}
}
vals = conf.getStringArray(PARAM_SELECT_NOT);
for (String val : vals)
{
if (val.trim().length() > 0)
{
sel.addNotValue(val);
}
}
String op = conf.getString(PARAM_SELECT_OP, PARAM_SELECT_OP_OR);
ValueOperation valOp;
if (PARAM_SELECT_OP_OR.equals(op))
{
valOp = ValueOperation.ValueOperationOr;
}
else if (PARAM_SELECT_OP_AND.equals(op))
{
valOp = ValueOperation.ValueOperationAnd;
}
else
{
throw new IllegalArgumentException("invalid selection operation: " + op);
sel.setSelectionOperation(valOp);
=======
import com.browseengine.bobo.api.BrowseFacet;
import com.browseengine.bobo.api.BrowseSelection;
import com.browseengine.bobo.api.FacetAccessible;
import com.browseengine.bobo.api.FacetSpec;
import com.browseengine.bobo.api.BrowseSelection.ValueOperation;
import com.browseengine.bobo.api.FacetSpec.FacetSortSpec;
import com.sensei.search.req.SenseiHit;
import com.sensei.search.req.SenseiJSONQuery;
import com.sensei.search.req.SenseiQuery;
import com.sensei.search.req.SenseiRequest;
import com.sensei.search.req.SenseiResult;
import com.sensei.search.req.SenseiSystemInfo;
import com.sensei.search.util.RequestConverter;
>>>>>>> 995a54af36c6a2afd3945761e5cea46f1ca6a0ba
String[] selectPropStrings = conf.getStringArray(PARAM_SELECT_PROP);
if (selectPropStrings != null && selectPropStrings.length > 0) |