[Sandbox-commits] r343 - in wikengo_core-wikitty: wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr

5 Jan 2010

Author: kmorin
Date: 2010-01-05 10:32:25 +0100 (Tue, 05 Jan 2010)
New Revision: 343

Modified:
   wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java
   wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java
   wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java
   wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Element.java
   wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Search.java
   wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyExtensionStorageJDBC.java
   wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyStorageJDBC.java
   wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/Restriction2Solr.java
   wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/WikittySearchEngineSolr.java
Log:
- don't remember what I did before holydays... should have commit before leaving but forgot...

Modified: wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java
===================================================================

--- wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -180,7 +180,7 @@
      * @return
      */
     public WikittyExtension restoreExtension(String id) {
-        WikittyExtension result = getExtensionStorage().restore(id);
+        WikittyExtension result = getExtensionStorage().restore(WikittyExtension.computeName(id), WikittyExtension.computeVersion(id));
         return result;
     }
 

Modified: wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -77,10 +77,12 @@
 
     /**
      * Restore one extension from storage, if not found an exception is throw
-     * @param id extension id to restore
+     * @param name extension name to restore
+     * @param version extension version to restore
      * @return
      */
-    public WikittyExtension restore(String id) throws WikittyException;
+    WikittyExtension restore(String name, String version)
+            throws WikittyException;
 
     /**
      * Command update

Modified: wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -209,7 +209,8 @@
             return null;  //To change body of implemented methods use File | Settings | File Templates.
         }
 
-        public WikittyExtension restore(String id) throws WikittyException {
+        public WikittyExtension restore(String name, String version) throws WikittyException {
+            String id = WikittyExtension.computeId(name, version);
             WikittyExtension result = extensions.get(id);
             if (result == null) {
                 throw new WikittyException(String.format("No extension with id '%s'", id));
@@ -356,10 +357,14 @@
             throw new UnsupportedOperationException("Not supported yet.");
         }
 
-        public Map<String, Integer> findAllChildren(Wikitty w) {
+        public Integer findNodeCount(Wikitty w) {
             throw new UnsupportedOperationException("Not supported yet.");
         }
 
+        public Map<String, Integer> findAllChildrenCount(Wikitty w) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
     }
 
     /**

Modified: wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Element.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Element.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Element.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -16,8 +16,6 @@
  *##%*/
 package org.sharengo.wikitty.search;
 
-import org.sharengo.wikitty.FieldType;
-
 import java.io.Serializable;
 
 /**
@@ -32,25 +30,28 @@
     /** Represent a element on id */
     public static String ELT_ID = "elt_id";
 
-	// serialVersionUID is used for serialization.
-	private static final long serialVersionUID = 1L;
+    /** Represent type to search an element */
+    public static enum ElementType {NUMERIC, STRING, WIKITTY, BOOLEAN, TEXT, DATE};
 
-	protected String name;
+    // serialVersionUID is used for serialization.
+    private static final long serialVersionUID = 1L;
 
-	public Element() {
-		super();
-	}
+    protected String name;
 
+    public Element() {
+        super();
+    }
+
     public Element(String name) {
-        this.name = name.replace(" ", FieldType.WORD_SEPARATOR);
+        this.name = name;
     }
 
-	public String getName() {
-		return name;
-	}
+    public String getName() {
+        return name;
+    }
 
-	public void setName(String name) {
-		this.name = name.replace(" ", FieldType.WORD_SEPARATOR);
-	}
+    public void setName(String name) {
+        this.name = name;
+    }
 
 }

Modified: wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Search.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Search.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-api/src/main/java/org/sharengo/wikitty/search/Search.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -13,23 +13,29 @@
 
 /**
  * Helper to create a criteria with a restriction
+ *
+ * Element :
+ * <extensionName>.<fieldName>[.<fieldType>] : search on an extension and field with specific type (optionnal)
+ * Criteria.ALL_EXTENSIONS.<fieldName>.<fieldType> : search on all extension and field name with specific type
+ *
+ * <fieldType> specify seach on field as NUMERIC, STRING, WIKITTY, BOOLEAN, TEXT
  */
 public class Search {
 
     static private Log log = LogFactory.getLog(Search.class);
 
-	public enum KIND {
-		AND, OR
-	}
-	
-	KIND kind = KIND.AND;
-	List<Restriction> restrictions;
+    public enum KIND {
+        AND, OR, NOT
+    }
+
+    KIND kind = KIND.AND;
+    List<Restriction> restrictions;
     List<Search> subSearchs;
-	
-	public Search() {
-		restrictions = new ArrayList<Restriction>();
+
+    public Search() {
+        restrictions = new ArrayList<Restriction>();
         subSearchs = new ArrayList<Search>();
-	}
+    }
 
     /**
      * Create Search query with field in wikitty argument
@@ -42,7 +48,7 @@
         result.kind = KIND.AND;
         // result object must have same extension that wikitty example
         for (String extName : wikitty.getExtensionNames()) {
-			result.eq(Element.ELT_EXTENSION, extName);
+            result.eq(Element.ELT_EXTENSION, extName);
         }
 
         for (String fqfieldName : wikitty.fieldNames()) {
@@ -65,133 +71,150 @@
         return result;
     }
 
-	public static Search query() {
-		Search search = new Search();
-		search.kind = KIND.AND;
-		return search;
-	}
+    public static Search query() {
+        Search search = new Search();
+        search.kind = KIND.AND;
+        return search;
+    }
 
     public static Search query(KIND kind) {
-		Search search = new Search();
-		search.kind = kind;
-		return search;
-	}
-	
+        Search search = new Search();
+        search.kind = kind;
+        return search;
+    }
+
     /**
      * Create new query on existant criteria to add new constraint to existant
      * criteria
      * @param criteria
      * @return
      */
-	public static Search query(Criteria criteria) {
-		Search search = query();
+    public static Search query(Criteria criteria) {
+        Search search = query();
         search.restrictions.add(criteria.getRestriction());
-		return search;
-	}
-	
-	private static Element elt(String element) {
-		Element elm = new Element();
-		elm.setName(element);
-		return elm;
-	}
-	
-	protected Search handle( Restriction dto ) {
-		restrictions.add( dto );
-		return this;
-	}
+        return search;
+    }
 
-	public Search contains(String element, Collection<String> values) {
-		return handle( RestrictionHelper.contains(elt(element),
+    private static Element elt(String element) {
+        Element elm = new Element();
+        elm.setName(element);
+        return elm;
+    }
+
+    protected Search handle( Restriction dto ) {
+        restrictions.add( dto );
+        return this;
+    }
+
+    public Search contains(String element, Collection<String> values) {
+        return handle( RestrictionHelper.contains(elt(element),
                 new ArrayList<String>(values)) );
-	}
+    }
 
-	public Search eq(String element, String value) {
-		return handle( RestrictionHelper.eq(elt(element), value) );
-	}
-	
-	public Search neq(String element, String value) {
-		return handle( RestrictionHelper.neq(elt(element), value) );
-	}
+    public Search eq(String element, String value) {
+        return handle( RestrictionHelper.eq(elt(element), value) );
+    }
 
-	public Search gt(String element, String value) {
-		return handle( RestrictionHelper.great(elt(element), value) );
-	}
-	
-	public Search ge(String element, String value) {
-		return handle( RestrictionHelper.greatEq(elt(element), value) );
-	}
-	
-	public Search lt(String element, String value) {
-		return handle( RestrictionHelper.less(elt(element), value) );
-	}
-	
-	public Search le(String element, String value) {
-		return handle( RestrictionHelper.lessEq(elt(element), value) );
-	}
-	
-	public Search bw(String element, String lowerValue, String upperValue) {
-		return handle( RestrictionHelper.between(elt(element), lowerValue, upperValue) );
-	}
-	
-        public Search sw(String element, String value) {
-		return handle( RestrictionHelper.start(elt(element), value) );
-	}
+    public Search neq(String element, String value) {
+        return handle( RestrictionHelper.neq(elt(element), value) );
+    }
 
-	public Search nsw(String element, String value) {
-		return handle( RestrictionHelper.not(
+    public Search gt(String element, String value) {
+        return handle( RestrictionHelper.great(elt(element), value) );
+    }
+
+    public Search ge(String element, String value) {
+        return handle( RestrictionHelper.greatEq(elt(element), value) );
+    }
+
+    public Search lt(String element, String value) {
+        return handle( RestrictionHelper.less(elt(element), value) );
+    }
+
+    public Search le(String element, String value) {
+        return handle( RestrictionHelper.lessEq(elt(element), value) );
+    }
+
+    public Search bw(String element, String lowerValue, String upperValue) {
+        return handle( RestrictionHelper.between(elt(element), lowerValue, upperValue) );
+    }
+
+    public Search sw(String element, String value) {
+        return handle( RestrictionHelper.start(elt(element), value) );
+    }
+
+    public Search nsw(String element, String value) {
+        return handle( RestrictionHelper.not(
                         RestrictionHelper.start(elt(element), value)) );
-	}
-	
-	public Search ew(String element, String value) {
-		return handle( RestrictionHelper.end(elt(element), value) );
-	}
+    }
 
+    public Search ew(String element, String value) {
+        return handle( RestrictionHelper.end(elt(element), value) );
+    }
+
     public Search notew(String element, String value) {
-		return handle( RestrictionHelper.not(
+        return handle( RestrictionHelper.not(
                         RestrictionHelper.end(elt(element), value)) );
-	}
+    }
 
     public Search keyword(String value) {
         return handle(RestrictionHelper.keyword(value));
     }
 
-	public Search or() {
-		Search search = Search.query(KIND.OR);
+    public Search not() {
+        Search not = Search.query(KIND.NOT);
+        subSearchs.add(not);
+
+        Search search = Search.query(kind);
+        not.subSearchs.add(search);
+
+        return search;
+    }
+
+    public Search or() {
+        Search search = Search.query(KIND.OR);
         subSearchs.add(search);
-		return search;
-	}
-	
-	public Search and() {
-		Search search = Search.query(KIND.AND);
+        return search;
+    }
+
+    public Search and() {
+        Search search = Search.query(KIND.AND);
         subSearchs.add(search);
-		return search;
-	}
+        return search;
+    }
 
-	public Search associated(String foreignFieldName) {
-		Search search = new SubSearch( foreignFieldName, this );
-		return search;
-	}
-	
+    public Search associated(String foreignFieldName) {
+        Search search = new SubSearch( foreignFieldName, this );
+        return search;
+    }
+
     /**
      * return unnamed criteria
      * @return new criteria
      */
-	public Criteria criteria(String name) {
-		Criteria criteria = new Criteria(name);
-		Restriction result = getRestrictions();
+    public Criteria criteria(String name) {
+        Criteria criteria = new Criteria(name);
+        Restriction result = getRestrictions();
         criteria.setRestriction(result);
-		return criteria;
-	}
-	
+        return criteria;
+    }
+
     protected Restriction getRestrictions() throws UnsupportedOperationException {
         Restriction result;
         if (restrictions.isEmpty() && subSearchs.isEmpty()) {
             result = RestrictionHelper.rFalse();
+
         } else if (restrictions.size() == 1 && subSearchs.isEmpty()) {
             result = restrictions.remove(0);
+
         } else if (subSearchs.size() == 1 && restrictions.isEmpty()) {
             Search subSearch = subSearchs.get(0);
             result = subSearch.getRestrictions();
+
+            if(kind == KIND.NOT) {
+                result = RestrictionHelper.not(result);
+            }
+
         } else {
             List<Restriction> allRestrictions = new ArrayList<Restriction>(restrictions);
             for (Search subSearch : subSearchs) {
@@ -214,10 +237,9 @@
 
     /**
      * return criteria with name
-     * @param name name of criteria
      * @return new criteria
      */
-	public Criteria criteria() {
-		return criteria(null);
-	}
-}
+    public Criteria criteria() {
+        return criteria(null);
+    }
+}
\ No newline at end of file

Modified: wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyExtensionStorageJDBC.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyExtensionStorageJDBC.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyExtensionStorageJDBC.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -278,7 +278,7 @@
                     String extName = adminResultSet.getString(COL_NAME);
                     String extVersion = getLastVersion(extName);
                     String extId = WikittyExtension.computeId(extName, extVersion);
-                    result.add(restore(extId));
+                    result.add(restore(WikittyExtension.computeName(extId), WikittyExtension.computeVersion(extId)));
                 }
             } else {
                 adminResultSet = statement.executeQuery(
@@ -287,7 +287,7 @@
                 adminResultSet.beforeFirst();
                 while (adminResultSet.next()) {
                     String extId = adminResultSet.getString(COL_ID);
-                    result.add(restore(extId));
+                    result.add(restore(WikittyExtension.computeName(extId), WikittyExtension.computeVersion(extId)));
                 }
             }
             closeConnection(con);
@@ -340,7 +340,8 @@
     }
 
     @Override
-    public WikittyExtension restore(String id) throws WikittyException {
+    public WikittyExtension restore(String name, String version) throws WikittyException {
+        String id = WikittyExtension.computeId(name, version);
         WikittyExtension result = extensionCache.get(id);
         if (result == null) {
             Connection con = null;

Modified: wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyStorageJDBC.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyStorageJDBC.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyStorageJDBC.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -593,7 +593,7 @@
         result.setVersion(version);
         if (extensionList != null && !"".equals(extensionList)) {
             for (String ext : extensionList.split(",")) {
-                WikittyExtension extension = extensionStorage.restore(ext);
+                WikittyExtension extension = extensionStorage.restore(WikittyExtension.computeName(ext), WikittyExtension.computeVersion(ext));
                 result.addExtension(extension);
             }
         }

Modified: wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/Restriction2Solr.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/Restriction2Solr.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/Restriction2Solr.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -8,6 +8,7 @@
 import org.apache.solr.client.solrj.SolrServer;
 import org.apache.solr.client.solrj.SolrServerException;
 import org.apache.solr.client.solrj.response.QueryResponse;
+import org.apache.solr.client.solrj.util.ClientUtils;
 import org.apache.solr.common.SolrDocument;
 import org.apache.solr.common.SolrDocumentList;
 import org.sharengo.wikitty.WikittyException;
@@ -34,21 +35,16 @@
 /**
  * @author "Nicolas Chapurlat" <nicolas.chapurlat@logica.com>
  * @author "Guillaume Dufrêne" <dufrene@argia.fr>
- * 
+ *
  * This class is used to parse Restriction to create lucene request on
  * content. Every operators describe in RestrictionName is handle. Parsing may
  * throw exception when restriction parameters are incorrect.
  */
 public class Restriction2Solr {
-	
-	private static final int MAX_SUBQUERY_RESULT = 100;
 
-    /** use to permit client to modify fieldname during query generation */
-    static public interface FieldModifier {
-        public String convertToSolr(String fieldname);
-        public String convertToField(String solrName);
-    }
-    final static protected FieldModifier dummyFieldModifier = new FieldModifier() {
+    private static final int MAX_SUBQUERY_RESULT = 100;
+
+    final static protected WikittySearchEngineSolr.FieldModifier dummyFieldModifier = new WikittySearchEngineSolr.FieldModifier() {
         public String convertToSolr(String fieldname) {
             return fieldname;
         }
@@ -57,331 +53,323 @@
         }
     };
 
-    protected FieldModifier fieldModifer;
+    protected WikittySearchEngineSolr.FieldModifier fieldModifer;
 
     public Restriction2Solr() {
         this(dummyFieldModifier);
     }
 
-    public Restriction2Solr(FieldModifier fieldModifer) {
+    public Restriction2Solr(WikittySearchEngineSolr.FieldModifier fieldModifer) {
         this.fieldModifer = fieldModifer;
     }
 
     public String toSolr(Restriction restriction) {
-    	return toSolr(restriction, null);
+        return toSolr(restriction, null);
     }
-    
-	public String toSolr(Restriction restriction, SolrServer solr)
-			throws WikittyException {
-		// ParameterValidator.checkNullParameter(restriction, "restriction");
-		switch (restriction.getName()) {
-		case TRUE:
-			return true2solr();
-		case FALSE:
-			return false2solr();
-		case NOT:
-			Not not = (Not) restriction;
-			return not2solr(not);
-		case AND:
-			And and = (And) restriction;
-			return and2solr(and);
-		case OR:
-			Or or = (Or) restriction;
-			return or2solr(or);
-		case EQUALS:
-			Equals eq = (Equals) restriction;
-			return eq2solr(eq);
-		case NOT_EQUALS:
-			NotEquals neq = (NotEquals) restriction;
-			return neq2solr(neq);
-		case LESS:
-			Less less = (Less) restriction;
-			return less2solr(less);
-		case LESS_OR_EQUAL:
-			LessOrEqual lessEq = (LessOrEqual) restriction;
-			return lessEq2solr(lessEq);
-		case GREATER:
-			Greater great = (Greater) restriction;
-			return great2solr(great);
-		case GREATER_OR_EQUAL:
-			GreaterOrEqual greatEq = (GreaterOrEqual) restriction;
-			return greatEq2solr(greatEq);
-		case BETWEEN:
-			Between between = (Between) restriction;
-			return between2solr(between);
-		case CONTAINS:
-			Contains contains = (Contains) restriction;
-			return contains2solr(contains);
-		case IN:
-			In in = (In) restriction;
-			return in2solr(in);
-		case STARTS_WITH:
-			StartsWith start = (StartsWith) restriction;
-			return start2solr(start);
-		case ENDS_WITH:
-			EndsWith end = (EndsWith) restriction;
-			return end2solr(end);
-		case ASSOCIATED:
-			AssociatedRestriction associated = (AssociatedRestriction) restriction;
-			return associated2solr(associated, solr);
+
+    public String toSolr(Restriction restriction, SolrServer solr)
+            throws WikittyException {
+        // ParameterValidator.checkNullParameter(restriction, "restriction");
+        switch (restriction.getName()) {
+        case TRUE:
+            return true2solr();
+        case FALSE:
+            return false2solr();
+        case NOT:
+            Not not = (Not) restriction;
+            return not2solr(not);
+        case AND:
+            And and = (And) restriction;
+            return and2solr(and);
+        case OR:
+            Or or = (Or) restriction;
+            return or2solr(or);
+        case EQUALS:
+            Equals eq = (Equals) restriction;
+            return eq2solr(eq);
+        case NOT_EQUALS:
+            NotEquals neq = (NotEquals) restriction;
+            return neq2solr(neq);
+        case LESS:
+            Less less = (Less) restriction;
+            return less2solr(less);
+        case LESS_OR_EQUAL:
+            LessOrEqual lessEq = (LessOrEqual) restriction;
+            return lessEq2solr(lessEq);
+        case GREATER:
+            Greater great = (Greater) restriction;
+            return great2solr(great);
+        case GREATER_OR_EQUAL:
+            GreaterOrEqual greatEq = (GreaterOrEqual) restriction;
+            return greatEq2solr(greatEq);
+        case BETWEEN:
+            Between between = (Between) restriction;
+            return between2solr(between);
+        case CONTAINS:
+            Contains contains = (Contains) restriction;
+            return contains2solr(contains);
+        case IN:
+            In in = (In) restriction;
+            return in2solr(in);
+        case STARTS_WITH:
+            StartsWith start = (StartsWith) restriction;
+            return start2solr(start);
+        case ENDS_WITH:
+            EndsWith end = (EndsWith) restriction;
+            return end2solr(end);
+        case ASSOCIATED:
+            AssociatedRestriction associated = (AssociatedRestriction) restriction;
+            return associated2solr(associated, solr);
         case KEYWORD:
             Keyword keyword = (Keyword) restriction;
             return keyword2solr(keyword);
-		default:
-			throw new WikittyException("this kind of restriction is not supported : "
-							+ restriction.getName().toString());
-		}
-	}
+        default:
+            throw new WikittyException("this kind of restriction is not supported : "
+                            + restriction.getName().toString());
+        }
+    }
 
-	private String in2solr(In in) {
-		boolean first = true;
-		String result = in.getElement().getName() + ":[";
-		for( String value : in.getValue() ) {
-			if ( !first ) { result += ", "; first = false; }
-			result += value;
-		}
-		result +="]";
-		return result;
-	}
+    private String in2solr(In in) {
+        boolean first = true;
+        String result = in.getElement().getName() + ":[";
+        for( String value : in.getValue() ) {
+            if ( !first ) { result += ", "; first = false; }
+            result += value;
+        }
+        result +="]";
+        return result;
+    }
 
-	private String associated2solr(AssociatedRestriction associated, SolrServer solr) throws WikittyException {
-		String subQuery = toSolr( associated.getRestriction() );
-		SolrQuery query = new SolrQuery(WikittySearchEngineSolr.SOLR_QUERY_PARSER + subQuery);
+    private String associated2solr(AssociatedRestriction associated, SolrServer solr) throws WikittyException {
+        String subQuery = toSolr( associated.getRestriction() );
+        SolrQuery query = new SolrQuery(WikittySearchEngineSolr.SOLR_QUERY_PARSER + subQuery);
         query.setRows(MAX_SUBQUERY_RESULT);
         QueryResponse resp = null;
         try {
-			resp = solr.query(query);
-		} catch (SolrServerException e) {
-			throw new WikittyException("Unable to execute associative query on " + associated.getElement().getName(), e);
-		}
+            resp = solr.query(query);
+        } catch (SolrServerException e) {
+            throw new WikittyException("Unable to execute associative query on " + associated.getElement().getName(), e);
+        }
         SolrDocumentList solrResults = resp.getResults();
-        
+
         Restriction generatedRestriction = null;
         long size = solrResults.size();
         if ( size == 0 ) {
-        	throw new WikittyException("Associated " + associated.getElement().getName() + " do not retrieved any result");
+            throw new WikittyException("Associated " + associated.getElement().getName() + " do not retrieved any result");
         }
         if ( size == 1 ) {
-        	generatedRestriction = RestrictionHelper.eq( associated.getElement(), (String) solrResults.get(0).getFieldValue(WikittySearchEngineSolr.SOLR_ID) );
+            generatedRestriction = RestrictionHelper.eq( associated.getElement(), (String) solrResults.get(0).getFieldValue(WikittySearchEngineSolr.SOLR_ID) );
         } else {
-	        List<String> ids = new ArrayList<String>(solrResults.size());
-	        for (SolrDocument doc : solrResults) {
-	            String id = (String) doc.getFieldValue(WikittySearchEngineSolr.SOLR_ID);
-	            ids.add(id);
-	        }
-			generatedRestriction = new In(associated.getElement(), ids);
+            List<String> ids = new ArrayList<String>(solrResults.size());
+            for (SolrDocument doc : solrResults) {
+                String id = (String) doc.getFieldValue(WikittySearchEngineSolr.SOLR_ID);
+                ids.add(id);
+            }
+            generatedRestriction = new In(associated.getElement(), ids);
         }
         Restriction parent = associated.getParentRestrictionDto();
         And and;
         if ( parent instanceof And ) {
-        	and = (And) parent;
-        	and.getRestrictions().add( generatedRestriction );
+            and = (And) parent;
+            and.getRestrictions().add( generatedRestriction );
         } else {
-        	and = RestrictionHelper.and( Arrays.asList(new Restriction[]{ associated.getParentRestrictionDto(), generatedRestriction }) );
+            and = RestrictionHelper.and( Arrays.asList(new Restriction[]{ associated.getParentRestrictionDto(), generatedRestriction }) );
         }
-		return toSolr(and);
-	}
+        return toSolr(and);
+    }
 
-	private String not2solr(Not not) throws WikittyException {
-		if (not.getRestriction() == null) {
-			throw new WikittyException( "not.restriction" );
-		}
-		return "( *:* - " + toSolr(not.getRestriction()) + " )";
-	}
+    private String not2solr(Not not) throws WikittyException {
+        if (not.getRestriction() == null) {
+            throw new WikittyException( "not.restriction" );
+        }
+        return "( *:* - " + toSolr(not.getRestriction()) + " )";
+    }
 
-	private String and2solr(And and) throws WikittyException {
-		if (and.getRestrictions() == null) {
-			throw new WikittyException( "and.restrictions is null" );
-		}
-		if (and.getRestrictions().size() < 2) {
-			throw new WikittyException(	"AND is an operator that handle 2 operand at least");
-		}
-		boolean first = true;
-		StringBuffer result = new StringBuffer();
-		for (Restriction restriction : and.getRestrictions()) {
-			if (first) {
-				result.append("( ").append(toSolr(restriction));
-				first = false;
-			} else {
-				result.append(" AND ").append(toSolr(restriction));
-			}
-		}
-		return result.append(" )").toString();
-	}
+    private String and2solr(And and) throws WikittyException {
+        if (and.getRestrictions() == null) {
+            throw new WikittyException( "and.restrictions is null" );
+        }
+        if (and.getRestrictions().size() < 2) {
+            throw new WikittyException(    "AND is an operator that handle 2 operand at least");
+        }
+        boolean first = true;
+        StringBuffer result = new StringBuffer();
+        for (Restriction restriction : and.getRestrictions()) {
+            if (first) {
+                result.append("( ").append(toSolr(restriction));
+                first = false;
+            } else {
+                result.append(" AND ").append(toSolr(restriction));
+            }
+        }
+        return result.append(" )").toString();
+    }
 
-	private String or2solr(Or or) throws WikittyException {
-		if (or.getRestrictions() == null) {
-			throw new WikittyException("or.restrictions is null");
-		}
-		if (or.getRestrictions().size() < 2) {
-			throw new WikittyException("OR is an operator that handle 2 operand at least");
-		}
-		boolean first = true;
-		StringBuffer result = new StringBuffer();
-		for (Restriction restriction : or.getRestrictions()) {
-			if (first) {
-				result.append("( ");
-				first = false;
-			} else {
-				result.append(" OR ");
-			}
-			result.append(toSolr(restriction));
-		}
-		return result.append(" )").toString();
-	}
+    private String or2solr(Or or) throws WikittyException {
+        if (or.getRestrictions() == null) {
+            throw new WikittyException("or.restrictions is null");
+        }
+        if (or.getRestrictions().size() < 2) {
+            throw new WikittyException("OR is an operator that handle 2 operand at least");
+        }
+        boolean first = true;
+        StringBuffer result = new StringBuffer();
+        for (Restriction restriction : or.getRestrictions()) {
+            if (first) {
+                result.append("( ");
+                first = false;
+            } else {
+                result.append(" OR ");
+            }
+            result.append(toSolr(restriction));
+        }
+        return result.append(" )").toString();
+    }
 
-	private String eq2solr(Equals eq) throws WikittyException {
-		return element2solr(eq.getElement()) + ":" + value2solr(eq.getValue());
-	}
+    private String eq2solr(Equals eq) throws WikittyException {
+        return element2solr(eq.getElement()) + ":" + value2solr(eq.getValue());
+    }
 
-	private String neq2solr(NotEquals neq)
-			throws WikittyException {
-		return "-" + element2solr(neq.getElement()) + ":"
-				+ value2solr(neq.getValue());
-	}
+    private String neq2solr(NotEquals neq)
+            throws WikittyException {
+        return "-" + element2solr(neq.getElement()) + ":"
+                + value2solr(neq.getValue());
+    }
 
-	private String less2solr(Less less) throws WikittyException {
-		return element2solr(less.getElement()) + ":{* TO "
-				+ value2solr(less.getValue()) + "}";
-	}
+    private String less2solr(Less less) throws WikittyException {
+        return element2solr(less.getElement()) + ":{* TO "
+                + value2solr(less.getValue()) + "}";
+    }
 
-	private String lessEq2solr(LessOrEqual lessEq)
-			throws WikittyException {
-		return element2solr(lessEq.getElement()) + ":[* TO "
-				+ value2solr(lessEq.getValue()) + "]";
-	}
+    private String lessEq2solr(LessOrEqual lessEq)
+            throws WikittyException {
+        return element2solr(lessEq.getElement()) + ":[* TO "
+                + value2solr(lessEq.getValue()) + "]";
+    }
 
-	private String great2solr(Greater great)
-			throws WikittyException {
-		return element2solr(great.getElement()) + ":{"
-				+ value2solr(great.getValue()) + " TO *}";
-	}
+    private String great2solr(Greater great)
+            throws WikittyException {
+        return element2solr(great.getElement()) + ":{"
+                + value2solr(great.getValue()) + " TO *}";
+    }
 
-	private String greatEq2solr(GreaterOrEqual greatEq)
-			throws WikittyException {
-		return element2solr(greatEq.getElement()) + ":["
-				+ value2solr(greatEq.getValue()) + " TO *]";
-	}
+    private String greatEq2solr(GreaterOrEqual greatEq)
+            throws WikittyException {
+        return element2solr(greatEq.getElement()) + ":["
+                + value2solr(greatEq.getValue()) + " TO *]";
+    }
 
-	private String between2solr(Between between)
-			throws WikittyException {
-		if (between.getElement() == null) {
-			throw new WikittyException("contains.element");
-		}
-		if (between.getMin() == null) {
-			throw new WikittyException("contains.min");
-		}
-		if (between.getMax() == null) {
-			throw new WikittyException("contains.max");
-		}
-		return element2solr(between.getElement()) + ":["
-				+ value2solr(between.getMin()) + " TO "
-				+ value2solr(between.getMax()) + "]";
-	}
+    private String between2solr(Between between)
+            throws WikittyException {
+        if (between.getElement() == null) {
+            throw new WikittyException("contains.element");
+        }
+        if (between.getMin() == null) {
+            throw new WikittyException("contains.min");
+        }
+        if (between.getMax() == null) {
+            throw new WikittyException("contains.max");
+        }
+        return element2solr(between.getElement()) + ":["
+                + value2solr(between.getMin()) + " TO "
+                + value2solr(between.getMax()) + "]";
+    }
 
-	private String contains2solr(Contains contains)
-			throws WikittyException {
-		if (contains.getElement() == null) {
-			throw new WikittyException("contains.element");
-		}
-		if (contains.getValue() == null) {
-			throw new WikittyException("contains.values");
-		}
-		if (contains.getValue().size() < 1) {
-			throw new WikittyException("CONTAINS is an operator that handle 1 operand at least");
-		}
+    private String contains2solr(Contains contains)
+            throws WikittyException {
+        if (contains.getElement() == null) {
+            throw new WikittyException("contains.element");
+        }
+        if (contains.getValue() == null) {
+            throw new WikittyException("contains.values");
+        }
+        if (contains.getValue().size() < 1) {
+            throw new WikittyException("CONTAINS is an operator that handle 1 operand at least");
+        }
 
         String operand = "";
-		StringBuffer result = new StringBuffer();
+        StringBuffer result = new StringBuffer();
         result.append("(");
-		for (String value : contains.getValue()) {
+        for (String value : contains.getValue()) {
             result.append(operand);
-			result.append(element2solr(contains.getElement()))
-					.append(":").append(value2solr(value));
+            result.append(element2solr(contains.getElement()))
+                    .append(":").append(value2solr(value));
             operand = " OR ";
-		}
+        }
         result.append(")");
-		return result.toString();
-	}
+        return result.toString();
+    }
 
-	private String start2solr(StartsWith start)
-			throws WikittyException {
-		return element2solr(start.getElement()) + ":"
-				+ value2solr(start.getValue(), true, false);
-	}
+    private String start2solr(StartsWith start)
+            throws WikittyException {
+        return element2solr(start.getElement()) + ":"
+                + value2solr(start.getValue(), true, false);
+    }
 
-	private String end2solr(EndsWith end) {
-		return element2solr(end.getElement()) + ":"	+ value2solr(end.getValue());
-	}
+    private String end2solr(EndsWith end) {
+        return element2solr(end.getElement()) + ":"    + value2solr(end.getValue());
+    }
 
-	private String true2solr() {
-		return "( *:* )";
-	}
+    private String true2solr() {
+        return "( *:* )";
+    }
 
-	private String false2solr() {
-		return "( *:* - *:* )";
-	}
+    private String false2solr() {
+        return "( *:* - *:* )";
+    }
 
     private String keyword2solr(Keyword keyword) {
         return value2solr(keyword.getValue());
     }
 
-	private String value2solr(String value) {
-		return value2solr(value, false, false);
-	}
+    private String value2solr(String value) {
+        return value2solr(value, false, false);
+    }
 
-	private String value2solr(String value, boolean starOnEnd,
-			boolean revert) {
-		String result;
-		if (value != null) {
-			if (value.equals("*")) {
-				return "*";
-			}
+    private String value2solr(String value, boolean starOnEnd,
+            boolean revert) {
+        String result;
+        if (value != null) {
+            if (value.equals("*")) {
+                return "*";
+            }
 
-			if (revert) {
-				result = Restriction2Solr.escapeValue(reverse(value));
-			} else {
-				result = Restriction2Solr.escapeValue(value);
-			}
-		} else {
-			result = "";
-		}
-		if (starOnEnd) {
-			result += "*";
-		}
-		if (result.contains(" ")) {
-			result = "\"" + result + "\"";
-		}
-		return result;
-	}
-
-	private String element2solr(Element element) throws WikittyException {
-        String result = element.getName();
-        if(Element.ELT_EXTENSION.equals(result)) {
-            result = WikittySearchEngineSolr.SOLR_EXTENSIONS;
-        } else if(Element.ELT_ID.equals(result)) {
-            result = WikittySearchEngineSolr.SOLR_ID;
+            if (revert) {
+                result = Restriction2Solr.escapeValue(reverse(value));
+            } else {
+                result = Restriction2Solr.escapeValue(value);
+            }
         } else {
-            result = element.getName();
+            result = "";
         }
+        if (starOnEnd) {
+            result += "*";
+        }
+        if (result.contains(" ")) {
+            result = "\"" + result + "\"";
+        }
+        return result;
+    }
+
+    private String element2solr(Element element) throws WikittyException {
+        String result = element.getName();
         result = fieldModifer.convertToSolr(result);
         return result;
-	}
+    }
 
-	private static String escapeValue(String value) {
-		final String LUCENE_REPLACE_PATTERN = "\\+" + "|-" + "|&&" + "|\\|"
-				+ "|!" + "|\\(|\\)" + "|\\[|\\]" + "|\\{|\\}" + "|\"" + "|:";
-		return value.replaceAll(LUCENE_REPLACE_PATTERN, "\\\\$0");
-	}
+    private static String escapeValue(String value) {
+        final String LUCENE_REPLACE_PATTERN = "\\+" + "|-" + "|&&" + "|\\|"
+                + "|!" + "|\\(|\\)" + "|\\[|\\]" + "|\\{|\\}" + "|\"" + "|:";
+        return value.replaceAll(LUCENE_REPLACE_PATTERN, "\\\\$0");
+    }
 
-	private String reverse(String source) {
-		int i, len = source.length();
-		StringBuffer dest = new StringBuffer(len);
+    private String reverse(String source) {
+        int i, len = source.length();
+        StringBuffer dest = new StringBuffer(len);
 
-		for (i = (len - 1); i >= 0; i--) {
-			dest.append(source.charAt(i));
+        for (i = (len - 1); i >= 0; i--) {
+            dest.append(source.charAt(i));
         }
-		return dest.toString();
-	}
+        return dest.toString();
+    }
 }
-

Modified: wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/WikittySearchEngineSolr.java
===================================================================
--- wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/WikittySearchEngineSolr.java	2009-12-24 13:33:17 UTC (rev 342)
+++ wikengo_core-wikitty/wikengo_core-wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/WikittySearchEngineSolr.java	2010-01-05 09:32:25 UTC (rev 343)
@@ -1,16 +1,16 @@
 /* *##%
  * Copyright (c) 2009 poussin. All rights reserved.
- * 
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *##%*/
@@ -58,6 +58,7 @@
 import org.sharengo.wikitty.WikittyExtensionStorage;
 import org.sharengo.wikitty.WikittySearchEngine;
 import org.sharengo.wikitty.WikittyTransaction;
+import org.sharengo.wikitty.search.Element;
 import org.sharengo.wikitty.search.Search;
 
 /**
@@ -70,6 +71,7 @@
  */
 public class WikittySearchEngineSolr implements WikittySearchEngine {
 
+
     /** to use log facility, just put in your code: log.info(\"...\"); */
     static private Log log = LogFactory.getLog(WikittySearchEngineSolr.class);
 
@@ -111,7 +113,13 @@
         }
     }
 
-    static protected class TypeFieldModifer implements Restriction2Solr.FieldModifier {
+    /** use to permit client to modify fieldname during query generation */
+    static public interface FieldModifier {
+        public String convertToSolr(String fieldname);
+        public String convertToField(String solrName);
+    }
+
+    static protected class TypeFieldModifer implements FieldModifier {
         protected WikittyExtensionStorage extensionStorage;
         public TypeFieldModifer(WikittyExtensionStorage extensionStorage) {
             this.extensionStorage = extensionStorage;
@@ -121,39 +129,42 @@
             String result = fqfieldname;
             String[] searchField = fqfieldname.split("\\.");
 
-            if (searchField.length == 2) {
+            if (Element.ELT_EXTENSION.equals(fqfieldname)) {
+                result = SOLR_EXTENSIONS;
+
+            } else if (Element.ELT_ID.equals(fqfieldname)) {
+                result = SOLR_ID;
+
+            } else if (searchField.length >= 2) {
                 String extName = searchField[0];
                 String fieldName = searchField[1];
 
-                String version = extensionStorage.getLastVersion(extName);
-                if (version != null) { // not valid extension is version == null
-                    WikittyExtension ext = extensionStorage.restore(
-                            WikittyExtension.computeId(extName, version));
-                    FieldType type = ext.getFieldType(fieldName.replace(" ", "_"));
-                    if (type != null) { // type can be null if extension version differ
-                        result = WikittySearchEngineSolr.getSolrFieldName(
-                                fqfieldname, type);
+                if (Criteria.ALL_EXTENSIONS.equals(extName)) {
+                    fqfieldname = SOLR_ALL_EXTENSIONS + "." + fieldName;
+                }
+
+                if (searchField.length >= 3) {
+                    String fieldNameType = searchField[2];
+
+                    if (Element.ElementType.TEXT.name().equals(fieldNameType)) {
+                        result = extName + "." + fieldName + "_s_t";
                     } else {
-                        log.debug(String.format(
-                                "Field '%s' could not be found in '%s'",
-                                fqfieldname, extName));
+                        TYPE  type = FieldType.TYPE.valueOf(fieldNameType);
+                        result = WikittySearchEngineSolr.getSolrFieldName(fqfieldname, type);
                     }
-                } else {
-                    log.warn("No version for extension " + extName);
+                    return result;
                 }
-            }
 
-            if (searchField.length == 3) {
-                String extName = searchField[0];
-                String fieldName = searchField[1];
-                String fieldType = searchField[2];
-
-                if(Criteria.ALL_EXTENSIONS.equals(extName)) {
-                    TYPE type = FieldType.TYPE.valueOf(fieldType);
-                    String solrFieldName = SOLR_ALL_EXTENSIONS + "." + fieldName;
-                    result = WikittySearchEngineSolr.getSolrFieldName(solrFieldName, type);
-                } else {
-                    log.warn("All extension not found " + extName);
+                // Search type of field in extension
+                String version = extensionStorage.getLastVersion(extName);
+                if (version != null) { // not valid extension is version == null
+                    WikittyExtension ext = extensionStorage.restore(extName, version);
+                    FieldType fieldType = ext.getFieldType(fieldName);
+                    if (fieldType != null) { // type can be null if extension version differ
+                        TYPE type = fieldType.getType();
+                        result = WikittySearchEngineSolr.getSolrFieldName(fqfieldname, type);
+                        return result;
+                    }
                 }
             }
 
@@ -161,10 +172,12 @@
         }
 
         public String convertToField(String solrName) {
-            String fieldname = solrName.replaceAll("(_b$)|(_dt$)|(_t$)|(_l$)", "");
-            return fieldname;
+            String fieldName = solrName.replaceAll("(_b$)|(_dt$)|(_s$)|(_s_t$)|(_d$)", "");
+            if(SOLR_EXTENSIONS.equals(fieldName)) {
+                fieldName = Element.ELT_EXTENSION;
+            }
+            return fieldName;
         }
-
     }
 
     protected static class ReindexChildTreeNode extends HashSet<String> {
@@ -230,7 +243,7 @@
     protected TypeFieldModifer fieldModifier;
 
     public WikittySearchEngineSolr(WikittyExtensionStorage extensionStorage) {
-        this(extensionStorage, null);    
+        this(extensionStorage, null);
     }
 
     public WikittySearchEngineSolr(WikittyExtensionStorage extensionStorage, String dataDir) {
@@ -280,7 +293,7 @@
             Collection<Wikitty> wikitties) {
         List<Command> result = new ArrayList<Command>(wikitties.size());
         ReindexChildTreeNode reindexChildTreeNode = ReindexChildTreeNode.getReindexChildTreeNode(transaction);
-        
+
         for (Wikitty w : wikitties) {
 
             if(w.hasExtension(TreeNode.EXT_TREENODE)) {
@@ -294,12 +307,12 @@
                 SolrDocument treeNodeDoc = findById(treeNodeId);
                 if(treeNodeDoc != null) {
                     Collection oldChildren = treeNodeDoc.
-                            getFieldValues(TreeNode.FQ_FIELD_CHILDREN + "_t");
+                            getFieldValues(TreeNode.FQ_FIELD_CHILDREN + "_s");
                     if(oldChildren != null) {
                         reindexChildTreeNode.addAll(oldChildren);
                     }
                 }
-                
+
             }
 
             result.add(new CommandSolr(w));
@@ -330,7 +343,7 @@
         } catch (Exception eee) {
             throw new WikittyException(eee);
         }
-        
+
         return result;
     }
 
@@ -360,7 +373,7 @@
                 solrServer.add(doc);
             }
             solrServer.commit();
-            
+
             // no specific result needed
             UpdateResponse result = new UpdateResponse();
             return result;
@@ -380,15 +393,15 @@
             int firstIndex = criteria.getFirstIndex();
             int endIndex = criteria.getEndIndex();
 
-	        query.setStart(firstIndex);
-	        int nbRows;
-	        if (endIndex == -1) {
-	            // WARNING It is necessary to substract 'start' otherwise, there is a capacity overlow in solR
-	            nbRows = Integer.MAX_VALUE - firstIndex;
-	        } else {
-	            nbRows = endIndex - firstIndex + 1;
-	        }
-	        query.setRows(nbRows);
+            query.setStart(firstIndex);
+            int nbRows;
+            if (endIndex == -1) {
+                // WARNING It is necessary to substract 'start' otherwise, there is a capacity overlow in solR
+                nbRows = Integer.MAX_VALUE - firstIndex;
+            } else {
+                nbRows = endIndex - firstIndex + 1;
+            }
+            query.setRows(nbRows);
 
             // Add sorting
             List<String> sortAscending = criteria.getSortAscending();
@@ -398,7 +411,7 @@
                     query.setSortField(tranform, SolrQuery.ORDER.asc);
                 }
             }
-            
+
             List<String> sortDescending = criteria.getSortDescending();
             if(sortDescending != null) {
                 for (String sort : sortDescending) {
@@ -415,11 +428,11 @@
             // use to map query string to criteria facet name
             Map<String, String> facetQueryToName = new HashMap<String, String>();
 
-	        if ((facetField != null && !facetField.isEmpty())
+            if ((facetField != null && !facetField.isEmpty())
                     || (facetCriteria != null && !facetCriteria.isEmpty())) {
-	            query.setFacet(true);
-	            query.setFacetMinCount(1);
-	            // query.setFacetLimit(8); // no limit actualy
+                query.setFacet(true);
+                query.setFacetMinCount(1);
+                // query.setFacetLimit(8); // no limit actualy
 
                 // field facetisation
                 if (facetField != null) {
@@ -438,12 +451,12 @@
                         query.addFacetQuery(queryFacet);
                     }
                 }
-	        }
+            }
 
-	        QueryResponse resp = solrServer.query(query);
-	        SolrDocumentList solrResults = resp.getResults();
+            QueryResponse resp = solrServer.query(query);
+            SolrDocumentList solrResults = resp.getResults();
 
-	        Map<String, List<FacetTopic>> facets = new HashMap<String, List<FacetTopic>>();
+            Map<String, List<FacetTopic>> facets = new HashMap<String, List<FacetTopic>>();
             if (facetField != null && !facetField.isEmpty()) {
                 for (FacetField facet : resp.getFacetFields()) {
                     String facetName = fieldModifier.convertToField(facet.getName());
@@ -476,20 +489,20 @@
                 }
             }
 
-	        List<String> ids = new ArrayList<String>(solrResults.size());
-	        for (SolrDocument doc : solrResults) {
-	            String id = (String) doc.getFieldValue(SOLR_ID);
-	            ids.add(id);
-	        }
+            List<String> ids = new ArrayList<String>(solrResults.size());
+            for (SolrDocument doc : solrResults) {
+                String id = (String) doc.getFieldValue(SOLR_ID);
+                ids.add(id);
+            }
 
             int numFound = (int)resp.getResults().getNumFound();
             PagedResult<String> result = new PagedResult<String>(
                     firstIndex, numFound, queryString, facets, ids);
 
-	        return result;
-		} catch (SolrServerException e) {
-			throw new WikittyException(e);
-		}
+            return result;
+        } catch (SolrServerException e) {
+            throw new WikittyException(e);
+        }
     }
 
     public Integer findNodeCount(Wikitty w) {
@@ -510,16 +523,17 @@
         return numFound;
     }
 
+
     public Map<String, Integer> findAllChildrenCount(Wikitty w) {
         String wikittyId = w.getId();
-        
+
         String parent = w.getFieldAsWikitty(TreeNode.EXT_TREENODE, TreeNode.FIELD_PARENT);
         if(parent == null) {
             parent = TREENODE_ROOT;
         } else {
             parent = TREENODE_PREFIX + parent;
         }
-        
+
         // Find count with facet, if the node not contain recurcively content,
         // the node not found with facet
         Criteria criteria = Search.query().eq(parent, wikittyId).criteria()
@@ -565,42 +579,44 @@
 
         SolrInputDocument doc = new SolrInputDocument();
         String id = w.getId();
-        doc.addField(SOLR_ID,id);
+        doc.addField(SOLR_ID, id);
 
         for (String name : w.getExtensionNames()) {
             doc.addField(SOLR_EXTENSIONS, name);
         }
 
         for (String fqfieldName : w.fieldNames()) {
-            FieldType type = w.getFieldType(fqfieldName);
-            //	do not index wikitty field reference
-//            if (type.getType() == FieldType.TYPE.WIKITTY) {
-//                continue;
-//            }
-            String solrFqFieldName = getSolrFieldName(fqfieldName, type );
-            String[] extAndName = solrFqFieldName.split("\\.");
-            String solrFieldName = SOLR_ALL_EXTENSIONS + "." + extAndName[1];
-            if (type.isCollection()) {
-                Collection collection = (Collection) w.getFqField(fqfieldName);
-                if (collection != null) {
-	                for (Object objectValue : collection) {
-	                    if (objectValue != null) {
-	                        // String value = WikittyUtil.toString(type, objectValue);
-	                    	Object value = objectValue;
-	                        doc.addField(solrFqFieldName, value);
-	                        doc.addField(solrFieldName, value);
-	                    }
-	                }
+            FieldType fieldType = w.getFieldType(fqfieldName);
+            TYPE type = fieldType.getType();
+            String solrFqFieldName = getSolrFieldName(fqfieldName, type);
+
+            String[] solrFieldName = solrFqFieldName.split("\\.");
+            String solrAllFieldName = SOLR_ALL_EXTENSIONS + "." + solrFieldName[1];
+
+            Object objectValue = w.getFqField(fqfieldName);
+            if(objectValue != null) {
+                if (fieldType.isCollection()) {
+                    Collection collectionValue = (Collection) objectValue;
+                    for (Object itemValue : collectionValue) {
+                        if (itemValue != null) {
+                            doc.addField(solrFqFieldName, itemValue);
+                            doc.addField(solrAllFieldName, itemValue);
+
+                            log.debug("index field " + solrFqFieldName + " with value '" + itemValue + "'");
+                        }
+                    }
+                } else {
+                    doc.addField(solrFqFieldName, objectValue);
+                    doc.addField(solrAllFieldName, objectValue);
+
+                    // Store as text field
+                    if(type == TYPE.STRING) {
+                        doc.addField(solrFqFieldName + "_t", objectValue);
+                        doc.addField(solrAllFieldName + "_t", objectValue);
+                    }
+
+                    log.debug("index field " + solrFqFieldName + " with value '" + objectValue + "'");
                 }
-            } else {
-                Object objectValue = w.getFqField(fqfieldName);
-                if (objectValue != null) {
-                    // String value = WikittyUtil.toString(type, objectValue);
-                	Object value = objectValue;
-                    log.debug("index field " + solrFqFieldName + " with value '" + value + "'");
-                    doc.addField(solrFqFieldName, value);
-                    doc.addField(solrFieldName, value);
-                }
             }
         }
         return doc;
@@ -615,11 +631,11 @@
         doc.setField(TREENODE_CHILD, childId);
 
         // Find all node contain child
-        SolrQuery query = new SolrQuery(SOLR_QUERY_PARSER + TreeNode.FQ_FIELD_CHILDREN + "_t:" + childId);
+        SolrQuery query = new SolrQuery(SOLR_QUERY_PARSER + TreeNode.FQ_FIELD_CHILDREN + "_s:" + childId);
         QueryResponse response = solrServer.query(query);
         SolrDocumentList updateDocs = response.getResults();
 
-        List<String> paths = new ArrayList<String>();
+        Map<String, String> paths = new HashMap<String, String>();
         for (Iterator<SolrDocument> iterator = updateDocs.iterator();
                 iterator.hasNext();) {
             SolrDocument solrDocument = iterator.next();
@@ -631,70 +647,23 @@
             String childParent = treeNodeId;
             String parent = parentMap.get(childParent);
             while (parent != null) {
-                if(!paths.contains(parent)) {
+                String parentPath = paths.get(childParent);
+                if(parentPath == null) {
                     doc.addField(TREENODE_PREFIX + parent, childParent);
-                    paths.add(parent);
+                    paths.put(childParent, parent);
                 }
 
                 childParent = parent;
                 parent = parentMap.get(childParent);
             }
-            doc.addField(TREENODE_ROOT, childParent);
-        }
-        
-        return doc;
-    }
 
-    /**
-     * Update all document depend a deleted node in tree
-     */
-    public void updateTreeNodeDocument(Map<String, SolrInputDocument> documents, String nodeId) throws SolrServerException {
-        SolrQuery query = new SolrQuery(SOLR_QUERY_PARSER + TREENODE_PREFIX + nodeId + ":*");
-        QueryResponse response = solrServer.query(query);
-        SolrDocumentList updateDocs = response.getResults();
-
-        for (Iterator<SolrDocument> iterator = updateDocs.iterator(); iterator.hasNext();) {
-            SolrDocument solrDocument = iterator.next();
-            
-            String documentId = (String) solrDocument.getFieldValue(SOLR_ID);
-            SolrInputDocument alreadyDone = documents.get(documentId);
-
-            if (alreadyDone == null) {
-                SolrInputDocument doc = updateTreeNodeDocument(solrDocument, nodeId);
-                documents.put(documentId, doc);
-            } else {
-                // Copy other field after node
-                String parent = (String) alreadyDone.getFieldValue(TREENODE_PREFIX + nodeId);
-                if (parent != null) {
-                    // Recreate doc a sub node is deleted
-                    SolrInputDocument doc = updateTreeNodeDocument(solrDocument, nodeId);
-                    documents.put(documentId, doc);
-                }
+            String parentPath = paths.get(childParent);
+            if(parentPath == null) {
+                doc.addField(TREENODE_ROOT, childParent);
+                paths.put(childParent, TREENODE_ROOT);
             }
         }
-    }
 
-    /**
-     * Re-create a new document without node deleted, from age document
-     */
-    public SolrInputDocument updateTreeNodeDocument(SolrDocument solrDocument, String nodeId) {
-        String documentId = (String) solrDocument.getFieldValue(SOLR_ID);
-
-        SolrInputDocument doc = new SolrInputDocument();
-        doc.setField(SOLR_ID, documentId);
-        doc.setField(TREENODE_CHILD, solrDocument.getFieldValue(TREENODE_CHILD));
-        
-        // Copy other field after node
-        String parent = (String) solrDocument.getFieldValue(TREENODE_PREFIX + nodeId);
-        if (parent != null) {
-            String childParent = (String) solrDocument.getFieldValue(parent);
-            while (childParent != null) {
-                doc.setField(parent, childParent);
-                parent = TREENODE_PREFIX + childParent;
-                childParent = (String) solrDocument.getFieldValue(parent);
-            }
-        }
-
         return doc;
     }
 
@@ -719,12 +688,6 @@
         return null;
     }
 
-    static public String getSolrFieldName(String fqfieldName, FieldType fieldType) {
-        TYPE type = fieldType.getType();
-        String result = getSolrFieldName(fqfieldName, type);
-        return result;
-	}
-
     public static String getSolrFieldName(String fqfieldName, TYPE type) {
         switch (type) {
             case BOOLEAN:
@@ -732,11 +695,11 @@
             case DATE:
                 return fqfieldName + "_dt";
             case STRING:
-                return fqfieldName + "_t";
+                return fqfieldName + "_s";
             case NUMERIC:
                 return fqfieldName + "_d";
             default:
                 return fqfieldName;
         }
     }
-}
+}
\ No newline at end of file

    

kmorin＠users.nuiton.org