solr/core/src/java/org/apache/solr/rest/schema/FieldTypeXmlAdapter.java

/*
 * 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.solr.rest.schema;

import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.solr.common.SolrException;
import org.apache.solr.common.SolrException.ErrorCode;
import org.apache.solr.common.params.CommonParams;
import org.apache.solr.schema.IndexSchema;
import org.apache.solr.schema.SimilarityFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * Utility class for converting a JSON definition of a FieldType into the
 * XML format expected by the FieldTypePluginLoader.
 */
public class FieldTypeXmlAdapter {
  
  public static Node toNode(Map<String,?> json) {
    DocumentBuilder docBuilder;
    try {
      docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
    } catch (ParserConfigurationException e) {
      throw new SolrException(ErrorCode.SERVER_ERROR, e);
    }
    
    Document doc = docBuilder.newDocument();    
    Element fieldType = doc.createElement(IndexSchema.FIELD_TYPE);
    appendAttrs(fieldType, json);
    
    // transform the analyzer definitions into XML elements
    Element analyzer = transformAnalyzer(doc, json, "analyzer", null);
    if (analyzer != null)
      fieldType.appendChild(analyzer);

    analyzer = transformAnalyzer(doc, json, "indexAnalyzer", "index");
    if (analyzer != null)
      fieldType.appendChild(analyzer);

    analyzer = transformAnalyzer(doc, json, "queryAnalyzer", "query");
    if (analyzer != null)
      fieldType.appendChild(analyzer);

    analyzer = transformAnalyzer(doc, json, "multiTermAnalyzer", "multiterm");
    if (analyzer != null)
      fieldType.appendChild(analyzer);

    Element similarity = transformSimilarity(doc, json, "similarity");
    if (similarity != null)
      fieldType.appendChild(similarity);
        
    return fieldType;
  }

  @SuppressWarnings("unchecked")
  protected static Element transformSimilarity(Document doc, Map<String,?> json, String jsonFieldName) {
    Object jsonField = json.get(jsonFieldName);
    if (jsonField == null)
      return null; // it's ok for this field to not exist in the JSON map

    if (!(jsonField instanceof Map))
      throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid fieldType definition! Expected JSON object for "+
          jsonFieldName+" not a "+jsonField.getClass().getName());

    Element similarity = doc.createElement("similarity");
    Map<String,?> config = (Map<String,?>)jsonField;
    similarity.setAttribute(SimilarityFactory.CLASS_NAME, (String)config.remove(SimilarityFactory.CLASS_NAME));
    for (Map.Entry<String,?> entry : config.entrySet()) {
      Object val = entry.getValue();
      if (val != null) {
        Element child = doc.createElement(classToXmlTag(val.getClass()));
        child.setAttribute(CommonParams.NAME, entry.getKey());
        child.setTextContent(entry.getValue().toString());
        similarity.appendChild(child);
      }
    }
    return similarity;
  }

  /** Convert types produced by noggit's ObjectBuilder (Boolean, Double, Long, String) to plugin param XML tags. */
  protected static String classToXmlTag(Class<?> clazz) {
    switch (clazz.getSimpleName()) {
      case "Boolean": return "bool";
      case "Double":  return "double";
      case "Long":    return "long";
      case "String":  return "str";
    }
    throw new SolrException(ErrorCode.BAD_REQUEST, "Unsupported object type '" + clazz.getSimpleName() + "'");
  }
  
  @SuppressWarnings("unchecked")
  protected static Element transformAnalyzer(Document doc, Map<String,?> json, String jsonFieldName, String analyzerType) {
    Object jsonField = json.get(jsonFieldName);
    if (jsonField == null)
      return null; // it's ok for this field to not exist in the JSON map
    
    if (!(jsonField instanceof Map))
      throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid fieldType definition! Expected JSON object for "+
         jsonFieldName+" not a "+jsonField.getClass().getName());
    
    return createAnalyzerElement(doc, analyzerType, (Map<String,?>)jsonField);    
  }
  
  @SuppressWarnings("unchecked")
  protected static Element createAnalyzerElement(Document doc, String type, Map<String,?> analyzer) {
    Element analyzerElem = appendAttrs(doc.createElement("analyzer"), analyzer);
    if (type != null)
      analyzerElem.setAttribute("type", type);

    List<Map<String,?>> charFilters = (List<Map<String,?>>)analyzer.get("charFilters");
    Map<String,?> tokenizer = (Map<String,?>)analyzer.get("tokenizer");
    List<Map<String,?>> filters = (List<Map<String,?>>)analyzer.get("filters");

    if (analyzer.get("class") == null) {
      if (charFilters != null)
        appendFilterElements(doc, analyzerElem, "charFilter", charFilters);

      if (tokenizer == null)
        throw new SolrException(ErrorCode.BAD_REQUEST, "Analyzer must define a tokenizer!");

      if (tokenizer.get("class") == null)
        throw new SolrException(ErrorCode.BAD_REQUEST, "Every tokenizer must define a class property!");

      analyzerElem.appendChild(appendAttrs(doc.createElement("tokenizer"), tokenizer));

      if (filters != null)
        appendFilterElements(doc, analyzerElem, "filter", filters);

    } else { // When analyzer class is specified: char filters, tokenizers, and filters are disallowed
      if (charFilters != null)
        throw new SolrException
            (ErrorCode.BAD_REQUEST, "An analyzer with a class property may not define any char filters!");

      if (tokenizer != null)
        throw new SolrException
            (ErrorCode.BAD_REQUEST, "An analyzer with a class property may not define a tokenizer!");

      if (filters != null)
        throw new SolrException
            (ErrorCode.BAD_REQUEST, "An analyzer with a class property may not define any filters!");
    }
    
    return analyzerElem;
  }
  
  protected static void appendFilterElements(Document doc, Element analyzer, String filterName, List<Map<String,?>> filters) {
    for (Map<String,?> next : filters) {
      String filterClass = (String)next.get("class");
      if (filterClass == null)
        throw new SolrException(ErrorCode.BAD_REQUEST, 
            "Every "+filterName+" must define a class property!");      
      analyzer.appendChild(appendAttrs(doc.createElement(filterName), next));
    }    
  }
  
  protected static Element appendAttrs(Element elm, Map<String,?> json) {
    for (Map.Entry<String,?> entry : json.entrySet()) {
      Object val = entry.getValue();
      if (val != null && !(val instanceof Map))
        elm.setAttribute(entry.getKey(), val.toString());
    }
    return elm;
  }
}