Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * #%L
    * Wikitty :: api
    * %%
    * Copyright (C) 2012 CodeLutin, Benjamin Poussin
    * %%
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU Lesser 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 Lesser Public License for more details.
   * 
   * You should have received a copy of the GNU General Lesser Public 
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * #L%
   */
  package org.nuiton.wikitty;
  
  import java.util.Arrays;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
Wikitty client is object used in client side to access WikittyService. It is used to transform wikitty object used by WikittyService into business objects used by applications. It also manage securityToken for WikittyService. All method that need securityToken and WikittyService must be in this class and not in WikittyUtil

Author(s):
poussin
Version:
$Revision$
Since:
3.3 Last update: $Date$ by : $Author$
  
  public class WikittyClient {

    
to use log facility, just put in your code: log.info(\"...\");
  
      final static private TimeLog timeLog = new TimeLog(WikittyClient.class);
  
      protected ApplicationConfig config = null;
    
Delegated wikitty service.
  
      protected WikittyServiceEnhanced wikittyService;

    
 
     protected String securityToken;

    
Empty constructor (uninitialized wikittyService).
 
     protected WikittyClient() {
     }

    
Creation du client, le wikittyService est instancier grace au information trouve dans la configuration.

Parameters:
config
 
     public WikittyClient(ApplicationConfig config) {
         this(config, WikittyServiceFactory.buildWikittyService(config));
     }

    
Creation du client en forcant le wikittyService

Parameters:
config
wikittyService
 
     public WikittyClient(ApplicationConfig configWikittyService wikittyService) {
         this(configwikittyServicenull);
     }

    
Creation du client en forcant le wikittyService

Parameters:
config
wikittyService
securityToken
 
     public WikittyClient(ApplicationConfig configWikittyService wikittyServiceString securityToken) {
         if (config != null) {
             this. = config;
             long timeToLogInfo = config.getOptionAsInt(.
                     .getKey());
             long timeToLogWarn = config.getOptionAsInt(.
                     .getKey());
             .setTimeToLogInfo(timeToLogInfo);
             .setTimeToLogWarn(timeToLogWarn);
 
         }
         setWikittyService(wikittyService);
         setSecurityToken(securityToken);
     }
 
     static public TimeLog getTimeTrace() {
         return ;
     }
 
     static public Map<StringTimeLog.CallStatgetCallCount() {
         return .getCallCount();
     }
 
         WikittyExtensionMigrationRegistry result =
                 .getObject(WikittyExtensionMigrationRegistry.class);
         return result;
     }
 
     public void login(String loginString password) {
         long start = TimeLog.getTime();
         String result = .login(loginpassword);
         setSecurityToken(result);
         
         .log(start"login");
     }
 
     public void logout() {
         long start = TimeLog.getTime();
         
         .log(start"logout");
     }
 
     public String getSecurityToken(String userId) {
         long start = TimeLog.getTime();
         String result = .getToken(userId);
         .log(start"logout");
         return result;
     }
 
     public String getSecurityToken() {
         return ;
     }
 
     public void setSecurityToken(String securityToken) {
         this. = securityToken;
     }

    
get current wikittyUser logged or null if no user logged

Returns:
null if no user logged
 
     public WikittyUser getUser() {
         WikittyUser result = getUser(WikittyUser.class);
         return result;
     }

    
get current logged user wikitty object

Parameters:
clazz Business class used as User in your application, this extension should be require WikittyUser.
Returns:
null if no user logged
 
     public <E extends BusinessEntity> E getUser(Class<E> clazz) {
         E result = null;
         if ( != null) {
             //Get the token
             Wikitty securityTokenWikitty = restore();
             if (securityTokenWikitty != null) {
                 //Get the user
                 String userId = WikittyTokenHelper.getUser(securityTokenWikitty);
                 result = restore(clazzuserId);
             }
         }
         return result;
     }
 
     public WikittyService getWikittyService() {
         return .getDelegate();
     }
 
     public void setWikittyService(WikittyService wikittyService) {
         this. = new WikittyServiceEnhanced(wikittyService);
     }
 
     public ApplicationConfig getConfig() {
         return ;
     }
 
     ////////////////////////////////////////////////////////////////////////////
     //
     // STORE
     //
     ////////////////////////////////////////////////////////////////////////////
 
     public Wikitty store(Wikitty w) {
         long start = TimeLog.getTime();
         WikittyEvent resp = .store(w);
         // update object
         resp.update(w);
 
         // on recharge les preload, comme demande au moment du restore initial
         preload(Collections.singletonList(w));
 
         .log(start"store");
         return w;
     }
 
     public <E extends BusinessEntity> E store(E e) {
         Wikitty w = ((BusinessEntityImpl)e).getWikitty();
         store(w);
         return e;
     }
 
     public <E extends BusinessEntity> E[] store(E e1, E e2, E... eN) {
         List<E> es = new ArrayList<E>(eN.length + 2);
         Collections.addAll(ese1e2);
         Collections.addAll(eseN);
 
         List<E> list = store(es);
 
         E[] result = list.toArray((E[])Array.newInstance(
                 eN.getClass().getComponentType(), list.size()));
         return result;
     }
 
     public Wikitty[] store(Wikitty w1Wikitty w2Wikitty... wN) {
         List<Wikittyws = new ArrayList<Wikitty>(wN.length + 2);
         Collections.addAll(wsw1w2);
         Collections.addAll(wswN);
 
         List<WikittyresultList = storeWikitty(ws);
         Wikitty[] result = resultList.toArray(new Wikitty[resultList.size()]);
         return result;
     }

    
Store to WikittyService objects.

Parameters:
<E> object type
objets list
Returns:
updated objects list
 
     public <E extends BusinessEntityList<E> store(List<E> objets) {
         long start = TimeLog.getTime();
         // prepare data to send to service
         List<Wikittywikitties = new ArrayList<Wikitty>(objets.size());
         for (E e : objets) {
             if (e == null) {
                 wikitties.add(null);
             } else {
                 Wikitty w = ((BusinessEntityImpl)e).getWikitty();
                 wikitties.add(w);
             }
         }
 
         storeWikitty(wikitties);
 
         .log(start"store<list>");
         return objets;
     }
 
     public  List<WikittystoreWikitty(List<Wikittywikitties) {
         long start = TimeLog.getTime();
 
         // call the service with Wikitty
         WikittyEvent resp = .store(wikitties);
 
         // update object
         for (Wikitty w : wikitties) {
             resp.update(w);
         }
         // on recharge les preload, comme demande au moment du restore initial
         preload(wikitties);
 
         .log(start"storeWikitty<list>");
         return wikitties;
     }
 
     ////////////////////////////////////////////////////////////////////////////
     //
     // RESTORE
     //
     ////////////////////////////////////////////////////////////////////////////
 
     protected Set<WikittygetWikittyForPreload(Map<StringWikittyavailable,
             Wikitty wFieldType typeString fqField) {
 
         Set<Wikittyresult = new HashSet<Wikitty>();
         
         // contient tous les ids a recuperer
         Set<Stringids = new HashSet<String>();
         if (type.isCollection()) {
             ids.addAll((Collection)w.getFqField(fqField));
         } else {
             ids.add((String)w.getFqField(fqField));
         }
 
         // on prend tout ce que l'on peut depuis available
         Collection<StringavailableIds = CollectionUtils.intersection(idsavailable.keySet());
         for (String id : availableIds) {
             result.add(available.get(id));
         }
 
         // et on on fait un restore sur les reste
         ids.removeAll(availableIds);
         Set<Wikittyrestored = restore(ids);
         // on met les objets restore dans available pour la prochaine fois
         for (Wikitty wikitty : restored) {
             if (wikitty != null) {
                 available.put(wikitty.getWikittyId(), wikitty);
             }
         }
         result.addAll(restored);
         
         return result;
     }

    
Load one wikitty with specified preloadPattern (with only ',').

Parameters:
w current wikitty to load
available available wikitty (restored)
loaded already loaded wikitties + field couple
preloadPattern pattern used to load
Returns:
return w with preloaded link
 
     protected void preload(Wikitty wMap<StringWikittyavailable,
             Set<StringloadedString preloadPattern) {
         // s'il reste encore des champs a precharger
         String pattern = StringUtils.substringBefore(preloadPattern",");
         if (StringUtils.isNotBlank(pattern)) {
             pattern = pattern.trim();
             // on enleve la tete qui va etre traitee maintenant, et le reste
             // par recursion (nextPattern)
             String nextPattern = StringUtils.substringAfter(preloadPattern",");
 
             String wid = w.getWikittyId();
             for (String fqField : w.fieldNames()) {
                 // si le couple wid + fqField n'a pas encore ete traite on le fait
                 if (!loaded.contains(wid + "+" + fqField)) {
                     FieldType type = w.getFieldType(fqField);
                     // si le champs est bien de type Wikitty et qu'il respecte
                     // le pattern demande, on le traite
                     if (type.getType() == .
                             && Pattern.matches(patternfqField)) {
                         // on marque le champs comme ayant ete traite, vu qu'on
                         // est en cours (pour eviter les boucles infinies
                         // qui peuvent arriver si une extension declare un champs
                         // pointant sur lui meme
                         loaded.add(wid + "+" + fqField);
                         // on recupere le(s) wikitty(ies) du lien
                         Set<Wikittylinks = getWikittyForPreload(availablewtypefqField);
                         for (Wikitty link : links) {
                             if (link != null) {
                                 // on ajoute ce wikitty dans le preload du wikitty pere
                                 w.addPreloaded(link);
                                 // si le wikitty a pu etre recupere on fait la suite
                                 // sur lui (nextPattern)
                                 preload(linkavailableloadednextPattern);
                                 // et on preload aussi pour ses extensions
                                 preload(linkavailableloaded);
                             }
                         }
                     }
                 }
             }
         }
     }

    
Preload recursivement le wikitty, en fonction de sa chaine preloadPattern et des tags values des extensions qu'il a..

Parameters:
w le wikitty a precharger
available la liste des wikitty deja disponible sans restore explicite
loaded la liste de couple wid + fqfield deja traite
 
     protected void preload(Wikitty wMap<StringWikittyavailable,
             Set<Stringloaded) {
         if (w != null) {
             for (String p : w.getAllPreloadPattern()) {
                 preload(wavailableloadedp);
             }
         }
     }

    
Ajoute le preloadPattern comme chaine de preload dans chaque wikitty et fait le prechargement sur chaque wikitty. En sortie de methode les wikitty sont tous precharge comme souhaite.

Parameters:
wikitties la liste des wikitties a precharger
preloadPattern la liste des patterns de prechargement a faire
 
     public void preload(Collection<WikittywikittiesString ... preloadPattern) {
         String patterns = StringUtils.join(preloadPattern";");
         Map<StringWikittyavailable = new HashMap<StringWikitty>();
         for (Wikitty w : wikitties) {
             if (w != null) {
                 available.put(w.getWikittyId(), w);
                 if (StringUtils.isNotBlank(patterns)) {
                     // lorsqu'on apelle la methode pour le store, le preloadPattern
                     // est vide mais il ne faut pas perdre ce qu'il y avait avant
                     // dans le wikitty. Donc on ne fait le set que si patterns
                     // n'est pas vide
                     w.setPreloadPattern(patterns);
                 }
             }
         }
         Set<Stringloaded = new HashSet<String>();
         
         for (Wikitty w : wikitties) {
             if (w != null) {
                 preload(wavailableloaded);
             }
         }
     }
    
    
Restore wikitty entity with specified id or null if entity can't be be found.

Parameters:
id entity ids if null return is empty list
preload patterns des liens qu'il faut precharger par exemple: "Company.employee, Employee.person", "Company.address, Address.*"
Returns:
wikitty entity with specified id or null if entity can't be found
 
     public List<Wikittyrestore(List<StringidString ... preload) {
         long start = TimeLog.getTime();
 
         List<Wikittyresult;
         if (id == null) {
             result = new ArrayList<Wikitty>();
         } else {
             result = .restore(id);
             preload(resultpreload);
         }
 
         .log(start"restore<list>");
         return result;
     }

    
Restore wikitty entity with specified id or null if entity can't be found.

Parameters:
id entity id
Returns:
wikitty entity with specified id or null if entity can't be found
 
     public Wikitty restore(String idString ... preload) {
         long start = TimeLog.getTime();
         Wikitty result = null;
         if (id != null) {
             result = restore(Collections.singletonList(id), preload).get(0);
         }
 
         .log(start"restore");
         return result;
     }

    
Restore wikitty entity with specified id or null if entity can't be be found, or checkExtension is true and wikitty don't match extension wanted.

Parameters:
<E> object type
clazz entity class
id entity ids if null return is empty list
checkExtension if true check that Wikitty result has all extension
Returns:
wikitty entity with specified id or null if entity can't be found or if one wikitty don't have extension wanted by E type
 
     public <E extends BusinessEntityList<E> restore(Class<E> clazz,
             List<Stringidboolean checkExtensionString ... preload) {
         long start = TimeLog.getTime();
         List<E> result = new ArrayList<E>();
 
         if (id != null) {
             List<Wikittywikitties = restore(idpreload);
 
             Collection<StringbusinessExtension = null;
             if (checkExtension) {
                 // Recuperation de la liste des extensions du BusinessEntity resultats
                 BusinessEntityImpl sample =
                         (BusinessEntityImpl) WikittyUtil.newInstance(clazz);
                 businessExtension = sample.getExtensionNames();
             }
 
             for (Wikitty w : wikitties) {
                 E dto = null;
                 if (!checkExtension ||
                         // on ne check pas les extensions ou ...
                         CollectionUtils.subtract(
                         businessExtensionw.getExtensionNames()).isEmpty()) {
                         // ... on a retrouve toutes les extensions du wikitty dans l'objet
                         // on le prend dans les resultats
                         dto = WikittyUtil.newInstance(clazzw);
                 } // sinon on ne prend pas l'objet
                 
                 // add entity to result after checkExtension
                 result.add(dto);
             }
         }
         .log(start"restore<list>");
         return result;
     }

    
Restore wikitty entity with specified id or null if entity can't be found.

Parameters:
<E> object type
clazz entity class
id entity id
Returns:
wikitty entity with specified id or null if entity can't be found
 
     public <E extends BusinessEntity> E restore(Class<E> clazzString id,
             String ... preload) {
         E result = restore(clazzidfalsepreload);
         return result;
     }

    
Restore wikitty entity with specified id or null if entity can't be found.

Parameters:
<E> object type
clazz entity class
id entity id
checkExtension if true check that Wikitty result has all extension declared in clazz
Returns:
wikitty entity with specified id or null if entity can't be found
 
     public <E extends BusinessEntity> E restore(Class<E> clazzString id,
             boolean checkExtensionString ... preload) {
         long start = TimeLog.getTime();
         E result = null;
         if (id != null) {
             result = restore(clazz, Collections.singletonList(id),
                     checkExtensionpreload).get(0);
         }
 
         .log(start"restore<Business>");
         return result;
     }
 
     public <E extends BusinessEntityList<E> restore(Class<E> clazz,
             List<StringidString ... preload) {
         List<E> result = restore(clazzidfalsepreload);
         return result;
     }
 
     public Set<Wikittyrestore(Set<StringidString ... preload) {
         ArrayList<Stringlist = null;
         if (id != null) {
             list = new ArrayList<String>(id);
         }
         List<WikittyresultList = restore(listpreload);
         Set<Wikittyresult = new LinkedHashSet<Wikitty>(resultList);
         return result;
     }
 
     public <E extends BusinessEntitySet<E> restore(Class<E> clazz
             Set<StringidString ... preload) {
         Set<E> result = restore(clazzidfalsepreload);
         return result;
     }
 
     public <E extends BusinessEntitySet<E> restore(Class<E> clazzSet<Stringid,
             boolean checkExtensionString ... preload) {
         ArrayList<Stringlist = null;
         if (id != null) {
             list = new ArrayList<String>(id);
         }
         List<E> resultList = restore(clazzlistcheckExtensionpreload);
         Set<E> result = new LinkedHashSet<E>(resultList);
         return result;
     }
 
     ////////////////////////////////////////////////////////////////////////////
     //
     // DETELE
     //
     ////////////////////////////////////////////////////////////////////////////
 
     public void delete(String id) {
         long start = TimeLog.getTime();
         .delete(id);
 
         .log(start"delete");
     }
 
     public <E extends BusinessEntityvoid delete(E object) {
         long start = TimeLog.getTime();
         if (object != null) {
             String id = object.getWikittyId();
             .delete(id);
         }
         .log(start"delete(BusinessEntity)");
     }
 
     public void delete(Collection<Stringids) {
         long start = TimeLog.getTime();
         .delete(ids);
         
         .log(start"delete<list>");
     }
 
     public <E extends BusinessEntityvoid delete(List<E> objets) {
         long start = TimeLog.getTime();
         
         // prepare data to send to service
         List<Stringids = new ArrayList<String>(objets.size());
         for (E e : objets) {
             if (e != null) {
                 String id = e.getWikittyId();
                 ids.add(id);
             }
         }
 
         // call the service with Wikitty
         .delete(ids);
 
         .log(start"delete<list<BusinessEntity>>");
     }
 
     ///////////////////////////////////////////////////////////////////////////
     //
     // FIND (ALL) BY EXEMPLE <E>
     //
     ///////////////////////////////////////////////////////////////////////////
 
    
Null field are not used in search request.

Parameters:
e sample wikitty
first
limit
fieldFacet
Returns:
 
     public <E extends BusinessEntityImplWikittyQueryResult<E> findAllByExample(E e,
             int firstint limitElementField ... fieldFacet) {
         long start = TimeLog.getTime();
 
         WikittyQuery query = new WikittyQueryMaker().wikitty(e).end()
                 .setOffset(first).setLimit(limit)
                 .setFacetField(fieldFacet);
 
         WikittyQueryResult<E> result =
                 findAllByQuery((Class<E>)e.getClass(),
                 Collections.singletonList(query), false).get(0);
         
         .log(start"findAllByExample<limit>");
         return result;
     }

    
Null field are not used in search request.

Parameters:
e sample wikitty
Returns:
 
     public <E extends BusinessEntityImpl> E findByExample(E e) {
         long start = TimeLog.getTime();
         WikittyQuery query = new WikittyQueryMaker().wikitty(e).end();
 
         WikittyQueryResult<E> queryResult =
                 findAllByQuery((Class<E>)e.getClass(),
                 Collections.singletonList(query), true).get(0);
 
         E result = queryResult.peek();
         
         .log(start"findByExample");
         return result;
     }
 
     ///////////////////////////////////////////////////////////////////////////
     //
     // FIND ALL BY QUERY <E>
     //
     ///////////////////////////////////////////////////////////////////////////
 
    
Cette method doit etre l'unique methode finalement utilise par toutes les methodes find avec un cast vers clazz Search object that correspond to criteria and that have all extension needed by BusinessEntity (clazz), if clazz is BusinessEntity class. If one criteria is empty, find all extensions for this criteria else if criteria is null return null.

Parameters:
<E> object type Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[]
clazz entity class, can be null for no conversion
queries criterias
limitToFirst if true limit result to first result (first = 0, limit = 1)
Returns:
paged result
 
     protected <E> List<WikittyQueryResult<E>> findAllByQuery(
             Class<E> clazzList<WikittyQueryqueriesboolean limitToFirst) {
         List<WikittyQueryResult<Map<String, E>>> tmp =
                 findAllByQueryAsMap(clazzquerieslimitToFirst);
 
         List<WikittyQueryResult<E>> result = new ArrayList<WikittyQueryResult<E>>(tmp.size());
         for (WikittyQueryResult p : tmp) {
             result.add(p.convertMapToSimple());
 //            result.add(castTo(clazz, p));
         }
 
         return result;
     }

    
Cette method doit etre l'unique methode finalement utilise par toutes les methodes find avec un cast vers clazz Search object that correspond to criteria and that have all extension needed by BusinessEntity (clazz), if clazz is BusinessEntity class. If one criteria is empty, find all extensions for this criteria else if criteria is null return null.

Parameters:
<E> object type Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[]
clazz entity class, can be null for no conversion
queries criterias
limitToFirst if true limit result to first result (first = 0, limit = 1)
Returns:
paged result
 
     protected <E> List<WikittyQueryResult<Map<String, E>>> findAllByQueryAsMap(
             Class<E> clazzList<WikittyQueryqueriesboolean limitToFirst) {
         long start = TimeLog.getTime();
         List<WikittyQueryResult<Map<String, E>>> result = null;
         List<WikittyQueryserviceQueries;
         if (queries != null) {
             if (clazz != null && BusinessEntity.class.isAssignableFrom(clazz)) {
                 // on demande un business entity donc on modifie
                 // les criteres pour ajouter les contraintes sur les
                 // extensions
 
                 // newInstance only return BusinessEntityWikittyImpl
                 BusinessEntityImpl sample =
                         (BusinessEntityImpl) WikittyUtil.newInstance((Class<BusinessEntity>)clazz);
 
                 Wikitty wikitty = sample.getWikitty();
                 Collection<Stringextensions = wikitty.getExtensionNames();
 
                 serviceQueries = new ArrayList<WikittyQuery>(queries.size());
                 for (WikittyQuery criteria : queries) {
 
                     // on ajoute la condition sur les extensions dans le critere
                     // du coup, pour ne pas modifier le critere qui vient en parametre
                     // il faut creer un nouveau critere ...
                     WikittyQuery serviceQuery = null;
                     if (criteria == null) {
                         serviceQuery = new WikittyQueryMaker()
                                 .extContainsAll(extensions).end();
                     } else {
                         serviceQuery = criteria.copy();
                         WikittyQueryMaker queryMaker;
                         if (serviceQuery.getCondition() instanceof Select) {
                             // si la condition commence par un select
                             // alors il faut modifier la condition du select
                             Select select = (Select)serviceQuery.getCondition();
                             queryMaker = new WikittyQueryMaker()
                                     .select(select.getFunction())
                                     .and().condition(select.getSubCondition())
                                     .extContainsAll(extensions);
 
                         } else {
                             // sinon on modifie directement la condition
                             queryMaker = new WikittyQueryMaker()
                                     .and().condition(serviceQuery.getCondition())
                                     .extContainsAll(extensions);
                         }
                         // utilisation de cette nouvelle contrainte sur le nouvel objet
                         serviceQuery.setCondition(queryMaker.getCondition());
                     }
 
                     // ajout de ce criteria dans la liste de tous les criteres
                     serviceQueries.add(serviceQuery);
                 }
             } else {
                 // on ne demande pas un business entity donc on ne modifie
                 // pas les criteres
                 serviceQueries = queries;
             }
 
             if (limitToFirst) {
                 for (WikittyQuery query : serviceQueries) {
                     // FIXME, il faudrait faire des copies pour ne pas modifier les querys de l'utilisateur
 
                     // si on a un SELECT, il ne faut pas modifier l'offset ni le limit,
                     // car il peut y avoir des methods d'agregats qui ont besoin de toutes les donnees
                     if (!(query.getCondition() instanceof Select)) {
                         query.setOffset(0);
                         query.setLimit(1);
                     }
                     // lorsqu'on limit au premier, c'est qu'on utilise la methode
                     // pour retourne seulement un objet et pas un WikittyQueryResult
                     // on n'a donc pas a calculer les facets
                     query.setFacetExtension(false);
                     query.setFacetField();
                     query.setFacetQuery();
                 }
             }
 
             List<WikittyQueryResult<Map<StringObject>>> pagedResult =
                     findAllByQueryAsMap(serviceQueries);
 
             result = new ArrayList<WikittyQueryResult<Map<String, E>>>(pagedResult.size());
             for (WikittyQueryResult p : pagedResult) {
                 result.add((WikittyQueryResult<Map<String, E>>)castToMap(clazzp));
             }
         }
         .log(start"findAllByQuery<Map<String, E>>(List, limitToFirst)");
         return result;
     }

    
Search object that correspond to criteria and that have all extension needed by BusinessEntity (clazz), if clazz is BusinessEntity class. If one criteria is empty, find all extensions for this criteria else if criteria is null return null.

Parameters:
<E> object type Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[]
clazz entity class
queries queries
Returns:
paged result
 
     public <E> List<WikittyQueryResult<E>> findAllByQuery(
             Class<E> clazzList<WikittyQueryqueries) {
         long start = TimeLog.getTime();
         List<WikittyQueryResult<E>> result = findAllByQuery(clazzqueriesfalse);
         .log(start"findAllByQuery<E>(List)");
         return result;
     }

    
Search object that correspond to criteria and that have all extension needed by BusinessEntity (clazz), if clazz is BusinessEntity class. If one criteria is empty, find all extensions for this criteria else if criteria is null return null.

Parameters:
<E> object type Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[]
clazz entity class
query query
Returns:
paged result
 
     public <E> WikittyQueryResult<E> findAllByQuery(
             Class<E> clazzWikittyQuery query) {
         long start = TimeLog.getTime();
         WikittyQueryResult<E> result = findAllByQuery(clazz,
                 Collections.singletonList(query), false).get(0);
         .log(start"findAllByQuery<E>(One)");
         return result;
     }

    
/** Search object that correspond to criteria and that have all extension needed by BusinessEntity (clazz), if clazz is BusinessEntity class. If one criteria is empty, find all extensions for this criteria else if criteria is null return null.

Parameters:
<E> object type Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[]
clazz entity class
q1 query 1
q2 query 2
otherQueries otherQueries
Returns:
paged result
 
     public <E> WikittyQueryResult<E>[] findAllByQuery(
             Class<E> clazzWikittyQuery q1WikittyQuery q2WikittyQuery... otherQueries) {
         long start = TimeLog.getTime();
         List<WikittyQueryqueries = new ArrayList<WikittyQuery>(otherQueries.length + 2);
         Collections.addAll(queriesq1q2);
         Collections.addAll(queriesotherQueries);
 
         List<WikittyQueryResult<E>> resultList = findAllByQuery(clazzqueriesfalse);
         WikittyQueryResult<E>[] result = resultList.toArray(new WikittyQueryResult[queries.size()]);
         .log(start"findAllByQuery<Business>(Varargs)");
         return result;
     }
 
     ///////////////////////////////////////////////////////////////////////////
     //
     // FIND BY CRITERIA <E>
     //
     ///////////////////////////////////////////////////////////////////////////
 
     public <E> List<E> findByQuery(Class<E> clazzList<WikittyQueryqueries) {
         long start = TimeLog.getTime();
 
         List<WikittyQueryResult<E>> queryResult =
                 findAllByQuery(clazzqueriestrue);
         List<E> result = new ArrayList<E>(queryResult.size());
         for (WikittyQueryResult<E> r : queryResult) {
             if (r.size() > 0) {
                 result.add(r.peek());
             } else {
                 result.add(null);
             }
         }
 
         .log(start"findByQuery<E>(List)");
         return result;
     }
 
     public <E> E findByQuery(Class<E> clazzWikittyQuery query) {
         long start = TimeLog.getTime();
         E result = null;
         if (query != null) {
             result = findByQuery(clazz, Collections.singletonList(query)).get(0);
         }
         .log(start"findByQuery<E>(One)");
         return result;
     }
 
     public <E> E[] findByQuery(
             Class<E> clazzWikittyQuery q1WikittyQuery q2WikittyQuery... otherQueries) {
         long start = TimeLog.getTime();
 
         List<WikittyQueryqueries = new ArrayList<WikittyQuery>(otherQueries.length + 2);
         Collections.addAll(queriesq1q2);
         Collections.addAll(queriesotherQueries);
 
         List<E> resultList = findByQuery(clazzqueries);
         E[] result = resultList.toArray((E[])Array.newInstance(clazzresultList.size()));
 
         .log(start"findByQuery<E>(Varargs)");
         return result;
     }
 
     ///////////////////////////////////////////////////////////////////////////
     //
     // FIND ALL FIELD OR ID BY CRITERIA <String>
     //
     ///////////////////////////////////////////////////////////////////////////
 
    
Retourne les ids des wikitties qui correspondent au critere, chaque query passees en argument et retourne un WikittyQueryResult.

Parameters:
query
Returns:
 
         long start = TimeLog.getTime();
         List<WikittyQueryResult<String>> result = null;
        if (query != null) {
            result = findAllByQuery(String.classquery);
        }
        .log(start"findAllByQuery(List)");
        return result;
    }

    
Cette method est la seul a reellement faire un appel a findAllByQuery du wikitty service.

Parameters:
query
Returns:
        long start = TimeLog.getTime();
        List<WikittyQueryResult<Map<StringObject>>> result = null;
        if (query != null) {
            result = .findAllByQuery(query);
        }
        .log(start"findAllByQuery(List)");
        return result;
    }
        long start = TimeLog.getTime();
        WikittyQueryResult<Stringresult = null;
        if (query != null) {
            result = findAllByQuery(Collections.singletonList(query)).get(0);
        }
        .log(start"findAllByQuery(One)");
        return result;
    }
        long start = TimeLog.getTime();
        WikittyQueryResult<Map<StringObject>> result = null;
        if (query != null) {
            result = findAllByQueryAsMap(Collections.singletonList(query)).get(0);
        }
        .log(start"findAllByQuery(One)");
        return result;
    }
            WikittyQuery c1WikittyQuery c2WikittyQuery ... otherCriteria) {
        long start = TimeLog.getTime();
        List<WikittyQuerycriterias = new ArrayList<WikittyQuery>(otherCriteria.length + 2);
        Collections.addAll(criteriasc1c2);
        Collections.addAll(criteriasotherCriteria);
        List<WikittyQueryResult<String>> resultList = findAllByQuery(criterias);
        WikittyQueryResult<String>[] result = resultList.toArray(new WikittyQueryResult[criterias.size()]);
        .log(start"findAllByCriteria(Varargs)");
        return result;
    }
            WikittyQuery c1WikittyQuery c2WikittyQuery ... otherCriteria) {
        long start = TimeLog.getTime();
        List<WikittyQuerycriterias = new ArrayList<WikittyQuery>(otherCriteria.length + 2);
        Collections.addAll(criteriasc1c2);
        Collections.addAll(criteriasotherCriteria);
        List<WikittyQueryResult<Map<StringObject>>> resultList = findAllByQueryAsMap(criterias);
        WikittyQueryResult<Map<StringObject>>[] result = resultList.toArray(new WikittyQueryResult[criterias.size()]);
        .log(start"findAllByCriteria(Varargs)");
        return result;
    }
    ///////////////////////////////////////////////////////////////////////////
    //
    // FIND ID BY CRITERIA <String>
    //
    ///////////////////////////////////////////////////////////////////////////
    public List<StringfindByQuery(List<WikittyQueryquery) {
        long start = TimeLog.getTime();
        List<Stringresult = null;
        if (query != null) {
            List<WikittyQueryResult<String>> tmp = findAllByQuery(String.classquerytrue);
            result = new ArrayList<String>(tmp.size());
            for (WikittyQueryResult<Stringwqr : tmp) {
                if (wqr.size() == 0) {
                    result.add(null);
                } else {
                    result.add(wqr.peek());
                }
            }
        }
        .log(start"findByQuery(List)");
    	return result;
    }
    public List<Map<StringObject>> findByQueryAsMap(List<WikittyQueryquery) {
        long start = TimeLog.getTime();
        List<Map<StringObject>> result = null;
        if (query != null) {
            List<WikittyQueryResult<Map<StringObject>>> tmp = findAllByQuery(nullquerytrue);
            result = new ArrayList<Map<StringObject>>(tmp.size());
            for (WikittyQueryResult<Map<StringObject>> wqr : tmp) {
                if (wqr.size() == 0) {
                    result.add(null);
                } else {
                    result.add(wqr.peek());
                }
            }
        }
        .log(start"findByQuery(List)");
        return result;
    }
    public <E> List<Map<String, E>> findByQueryAsMap(Class<E> clazzList<WikittyQueryquery) {
        long start = TimeLog.getTime();
        List<Map<String, E>> result = null;
        if (query != null) {
            List<WikittyQueryResult<Map<String, E>>> tmp = findAllByQueryAsMap(clazzquerytrue);
            result = new ArrayList<Map<String, E>>(tmp.size());
            for (WikittyQueryResult<Map<String, E>> wqr : tmp) {
                if (wqr.size() == 0) {
                    result.add(null);
                } else {
                    result.add(wqr.peek());
                }
            }
        }
        .log(start"findByQuery(List)");
        return result;
    }
    public String findByQuery(WikittyQuery query) {
        long start = TimeLog.getTime();
        String result = null;
        if (query != null) {
            result = findByQuery(Collections.singletonList(query)).get(0);
        }
        .log(start"findByQuery(One)");
    	return result;
    }
    public Map<StringObjectfindByQueryAsMap(WikittyQuery query) {
        long start = TimeLog.getTime();
        Map<StringObjectresult = null;
        if (query != null) {
            result = findByQueryAsMap(Collections.singletonList(query)).get(0);
        }
        .log(start"findByQuery(One)");
        return result;
    }
    public <E> Map<String, E> findByQueryAsMap(Class<E> clazzWikittyQuery query) {
        long start = TimeLog.getTime();
        Map<String, E> result = null;
        if (query != null) {
            result = findByQueryAsMap(clazz, Collections.singletonList(query)).get(0);
        }
        .log(start"findByQuery(One)");
        return result;
    }
    public String[] findByQuery(
            WikittyQuery q1WikittyQuery q2WikittyQuery... otherQueries) {
        long start = TimeLog.getTime();
        List<WikittyQueryqueries = new ArrayList<WikittyQuery>(otherQueries.length + 2);
        Collections.addAll(queriesq1q2);
        Collections.addAll(queriesotherQueries);
        List<StringresultList = findByQuery(queries);
        String[] result = resultList.toArray(new String[queries.size()]);
        .log(start"findByQuery(Varargs)");
        return result;
    }
    public Map<StringObject>[] findByQueryAsMap(
            WikittyQuery q1WikittyQuery q2WikittyQuery... otherQueries) {
        long start = TimeLog.getTime();
        List<WikittyQueryqueries = new ArrayList<WikittyQuery>(otherQueries.length + 2);
        Collections.addAll(queriesq1q2);
        Collections.addAll(queriesotherQueries);
        List<Map<StringObject>> resultList = findByQueryAsMap(queries);
        Map<StringObject>[] result = resultList.toArray(new Map[queries.size()]);
        .log(start"findByQuery(Varargs)");
        return result;
    }
    ///////////////////////////////////////////////////////////////////////////
    //
    // FIND BY TREE NODE
    //
    ///////////////////////////////////////////////////////////////////////////

    
Recupere une portion d'arbre a partir de l'id passer en parametre. L'id doit etre celui d'un WikittyTreeNode. Ce WikittyTreeNode est alors le root de l'arbre retourne. Return Wikitty in result, those Wikitties have WikittyTreeNode extension

Parameters:
wikittyId root
depth profondeur de noeud a recuperer
count vrai si l'on veut le nombre de piece attaches sur le noeud (piece des enfants compris)
filter filter pour compter les pieces attachees
Returns:
treeNodeResult of wikitty
Since:
3.1
            String wikittyIdint depthboolean countWikittyQuery filter) {
        long start = TimeLog.getTime();
                wikittyIddepthcountfilter);
        WikittyQueryResultTreeNode<Wikittyresult = null;
        if (resultId != null) {
            RetrieveIdVisitor retrieveIdVisitor = new RetrieveIdVisitor();
            resultId.acceptVisitor(retrieveIdVisitor);
            List<Stringids = retrieveIdVisitor.getIds();
            List<Wikittywikitties = restore(ids);
            IdToObjectConverter<Wikittyconverter =
                    new IdToObjectConverter<Wikitty>(idswikitties);