org.nuiton.wikitty.WikittyProxy Maven / Gradle / Ivy
The newest version!
/*
* #%L
* Wikitty :: api
* %%
* Copyright (C) 2009 - 2010 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
* .
* #L%
*/
package org.nuiton.wikitty;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.AbstractMap.SimpleEntry;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.nuiton.config.ApplicationConfig;
import org.nuiton.util.TimeLog;
import org.nuiton.wikitty.entities.BusinessEntity;
import org.nuiton.wikitty.entities.BusinessEntityImpl;
import org.nuiton.wikitty.entities.Wikitty;
import org.nuiton.wikitty.entities.WikittyExtension;
import org.nuiton.wikitty.entities.WikittyGroup;
import org.nuiton.wikitty.entities.WikittyUser;
import org.nuiton.wikitty.search.Criteria;
import org.nuiton.wikitty.search.PagedResult;
import org.nuiton.wikitty.search.Search;
import org.nuiton.wikitty.search.operators.Element;
import org.nuiton.wikitty.services.WikittyEvent;
import org.nuiton.wikitty.services.WikittySecurityUtil;
import org.nuiton.wikitty.services.WikittyServiceEnhanced;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.nuiton.wikitty.entities.WikittyTokenHelper;
import org.nuiton.wikitty.search.TreeNodeResult;
/**
* Wikitty proxy is used to transform wikitty object used by {@link WikittyService}
* into business objects used by applications.
*
* It also manage {@link #securityToken} for {@link org.nuiton.wikitty.services.WikittyServiceSecurity}.
*
* @author poussin
* @version $Revision$
*
* Last update: $Date$
* by : $Author$
* @deprecated since 3.3 use {@link WikittyClient}
*/
@Deprecated
public class WikittyProxy {
/** to use log facility, just put in your code: log.info(\"...\"); */
final static private Log log = LogFactory.getLog(WikittyProxy.class);
final static private TimeLog timeLog = new TimeLog(WikittyProxy.class);
/** Delegated wikitty service. */
protected WikittyServiceEnhanced wikittyService;
/**
* Security token.
*
* @see org.nuiton.wikitty.services.WikittyServiceSecurity#login(String, String)
*/
protected String securityToken;
/**
* Empty constructor (uninitialized wikittyService).
*/
public WikittyProxy() {
}
public WikittyProxy(ApplicationConfig config) {
if (config != null) {
long timeToLogInfo = config.getOptionAsInt(WikittyConfigOption.
WIKITTY_PROXY_TIME_TO_LOG_INFO.getKey());
long timeToLogWarn = config.getOptionAsInt(WikittyConfigOption.
WIKITTY_PROXY_TIME_TO_LOG_WARN.getKey());
timeLog.setTimeToLogInfo(timeToLogInfo);
timeLog.setTimeToLogWarn(timeToLogWarn);
}
}
/**
* Constructor with wikittyService.
*
* @param wikittyService wikitty service
*/
public WikittyProxy(WikittyService wikittyService) {
this();
setWikittyService(wikittyService);
}
public WikittyProxy(ApplicationConfig config, WikittyService wikittyService) {
this(config);
setWikittyService(wikittyService);
}
static public TimeLog getTimeTrace() {
return timeLog;
}
static public Map getCallCount() {
return timeLog.getCallCount();
}
public void login(String login, String password) {
long start = TimeLog.getTime();
String result = wikittyService.login(login, password);
setSecurityToken(result);
timeLog.log(start, "login");
}
public void logout() {
long start = TimeLog.getTime();
wikittyService.logout(securityToken);
timeLog.log(start, "logout");
}
public String getSecurityToken() {
return securityToken;
}
public void setSecurityToken(String securityToken) {
this.securityToken = securityToken;
}
/**
* get current wikittyUser logged or null if no user logged
* @return null if no user logged
*/
public WikittyUser getUser() {
WikittyUser result = getUser(WikittyUser.class);
return result;
}
/**
* get current logged user wikitty object
* @param clazz Business class used as User in your application,
* this extension should be require WikittyUser.
* @return null if no user logged
*/
public E getUser(Class clazz) {
E result = null;
if (securityToken != null) {
//Get the token
Wikitty securityTokenWikitty = restore(securityToken);
if (securityTokenWikitty != null) {
//Get the user
String userId = WikittyTokenHelper.getUser(securityTokenWikitty);
result = restore(clazz, userId);
}
}
return result;
}
public WikittyService getWikittyService() {
return wikittyService.getDelegate();
}
public void setWikittyService(WikittyService wikittyService) {
this.wikittyService = new WikittyServiceEnhanced(wikittyService);
}
/**
* Cast Business object to another Business Object
* If source don't have target extension, this extension is added
*
* @param source business entity source
* @param target business entity class wanted
* @return new instance of object wanted
*/
public E cast(BusinessEntity source, Class target) {
long start = TimeLog.getTime();
E result = WikittyUtil.newInstance(
securityToken, wikittyService, target, ((BusinessEntityImpl)source).getWikitty());
timeLog.log(start, "cast");
return result;
}
public E store(E e) {
Wikitty w = ((BusinessEntityImpl)e).getWikitty();
store(w);
return e;
}
public Wikitty store(Wikitty w) {
long start = TimeLog.getTime();
WikittyEvent resp = wikittyService.store(securityToken, w);
// update object
resp.update(w);
timeLog.log(start, "store");
return w;
}
// TODO poussin 20110420 je ne sais pas comment creer un tableau de E pour
// le retouner. Donc je retourne la liste au lieu d'un toArray sur celle-ci
public List store(E e1, E e2, E... eN) {
List es = new ArrayList(eN.length + 2);
Collections.addAll(es, e1, e2);
Collections.addAll(es, eN);
List result = store(es);
return result;
}
public Wikitty[] store(Wikitty w1, Wikitty w2, Wikitty... wN) {
List ws = new ArrayList(wN.length + 2);
Collections.addAll(ws, w1, w2);
Collections.addAll(ws, wN);
List resultList = storeWikitty(ws);
Wikitty[] result = resultList.toArray(new Wikitty[resultList.size()]);
return result;
}
/**
* Store to WikittyService objects.
*
* @param object type
* @param objets list
* @return updated objects list
*/
public List store(List objets) {
long start = TimeLog.getTime();
// prepare data to send to service
List wikitties = new ArrayList(objets.size());
for (E e : objets) {
if (e == null) {
wikitties.add(null);
} else {
Wikitty w = ((BusinessEntityImpl)e).getWikitty();
wikitties.add(w);
}
}
// call the service with Wikitty
WikittyEvent resp = wikittyService.store(securityToken, wikitties);
// update object
for (Wikitty w : wikitties) {
resp.update(w);
}
timeLog.log(start, "store");
return objets;
}
public List storeWikitty(List wikitties) {
long start = TimeLog.getTime();
// call the service with Wikitty
WikittyEvent resp = wikittyService.store(securityToken, wikitties);
// update object
for (Wikitty w : wikitties) {
resp.update(w);
}
timeLog.log(start, "storeWikitty");
return wikitties;
}
/**
* Restore wikitty entity with specified id or {@code null} if entity can't be found.
*
* @param object type
* @param clazz entity class
* @param id entity id
* @param checkExtension if true check that Wikitty result has all extension
* declared in clazz
* @return wikitty entity with specified id or {@code null} if entity can't be found
*/
public E restore(Class clazz, String id, boolean checkExtension) {
try {
long start = TimeLog.getTime();
E result = null;
if (id != null) {
HashSet extNames = null;
Wikitty wikitty = wikittyService.restore(securityToken, id);
if (wikitty != null) {
if (checkExtension) {
extNames = new HashSet(wikitty.getExtensionNames());
}
result = WikittyUtil.newInstance(
securityToken, wikittyService, clazz, wikitty);
if (checkExtension) {
// WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl
BusinessEntityImpl b = (BusinessEntityImpl) result;
Collection BusinessEntityStaticExtensions = b.getStaticExtensions();
for (WikittyExtension ext : BusinessEntityStaticExtensions) {
String extensionName = ext.getName();
if (!extNames.contains(extensionName)) {
// extension wanted by BusinessEntity (clazz)
// is not in wikitty, then wikitty is not good type
// for business
result = null;
break;
}
}
}
}
}
timeLog.log(start, "restore");
return result;
} catch (SecurityException eee) {
throw eee;
} catch (Exception eee) {
throw new WikittyException("Can't restore wikitty", eee);
}
}
/**
* Restore wikitty entity with specified id or {@code null} if entity can't be found.
*
* @param id entity id
* @return wikitty entity with specified id or {@code null} if entity can't be found
*/
public Wikitty restore(String id) {
long start = TimeLog.getTime();
Wikitty result = null;
if (id != null) {
result = wikittyService.restore(securityToken, id);
}
timeLog.log(start, "restore");
return result;
}
/**
* Restore wikitty entity with specified id or {@code null} if entity can't be found.
*
* @param object type
* @param clazz entity class
* @param id entity id
* @return wikitty entity with specified id or {@code null} if entity can't be found
*/
public E restore(Class clazz, String id) {
E result = restore(clazz, id, false);
return result;
}
/**
* Restore wikitty entity with specified id or {@code null} if entity can't be be found.
*
* @param id entity ids if null return is empty list
* @return wikitty entity with specified id or {@code null} if entity can't be found
*/
public List restore(List id) {
long start = TimeLog.getTime();
List result;
if (id == null) {
result = new ArrayList();
} else {
result = wikittyService.restore(securityToken, id);
}
timeLog.log(start, "restoreWikitty");
return result;
}
/**
* Restore wikitty entity with specified id or {@code null} if entity
* can't be be found.
*
* @param object type
* @param clazz entity class
* @param id entity ids if null return is empty list
* @param checkExtension if true check that Wikitty result has all extension
* @return wikitty entity with specified id or {@code null} if entity
* can't be found or if one wikitty don't have extension wanted by E type
*/
public List restore(
Class clazz, List id, boolean checkExtension) {
long start = TimeLog.getTime();
List result = new ArrayList();
if (id != null) {
List wikitties = wikittyService.restore(securityToken, id);
for (Wikitty w : wikitties) {
HashSet extNames = null;
if (checkExtension) {
extNames = new HashSet(w.getExtensionNames());
}
E dto = WikittyUtil.newInstance(
securityToken, wikittyService, clazz, w);
if (checkExtension) {
// WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl
BusinessEntityImpl b = (BusinessEntityImpl) dto;
for (WikittyExtension ext : b.getStaticExtensions()) {
if (!extNames.contains(ext.getName())) {
// extension wanted by BusinessEntity (clazz)
// is not in wikitty, then wikitty is not good type
// for business
dto = null;
break;
}
}
}
// Add only entity in good types
if (dto != null) {
result.add(dto);
}
}
}
timeLog.log(start, "restore");
return result;
}
public List restore(Class clazz, List id) {
List result = restore(clazz, id, false);
return result;
}
public Set restore(Set id) {
ArrayList list = null;
if (id != null) {
list = new ArrayList(id);
}
List resultList = restore(list);
Set result = new HashSet(resultList);
return result;
}
public Set restore(Class clazz, Set id) {
Set result = restore(clazz, id, false);
return result;
}
public Set restore(Class clazz, Set id, boolean checkExtension) {
ArrayList list = null;
if (id != null) {
list = new ArrayList(id);
}
List resultList = restore(clazz, list, checkExtension);
Set result = new HashSet(resultList);
return result;
}
public void delete(String id) {
long start = TimeLog.getTime();
wikittyService.delete(securityToken, id);
timeLog.log(start, "delete");
}
public void delete(E object) {
long start = TimeLog.getTime();
if (object != null) {
String id = object.getWikittyId();
wikittyService.delete(securityToken, id);
}
timeLog.log(start, "delete(BusinessEntity)");
}
public void delete(Collection ids) {
long start = TimeLog.getTime();
wikittyService.delete(securityToken, ids);
timeLog.log(start, "delete");
}
public void delete(List objets) {
long start = TimeLog.getTime();
// prepare data to send to service
List ids = new ArrayList(objets.size());
for (E e : objets) {
if (e != null) {
String id = e.getWikittyId();
ids.add(id);
}
}
// call the service with Wikitty
wikittyService.delete(securityToken, ids);
timeLog.log(start, "delete>");
}
/**
* Null field are not used in search request.
*
* @param e sample wikitty
* @param firstIndex
* @param endIndex
* @param fieldFacet
* @return
*/
public PagedResult findAllByExample(E e,
int firstIndex, int endIndex, String ... fieldFacet ) {
long start = TimeLog.getTime();
Criteria criteria = Search.query(e.getWikitty()).criteria()
.setFirstIndex(firstIndex).setEndIndex(endIndex)
.setFacetField(fieldFacet);
PagedResult pagedResult = findAllIdByCriteria(criteria);
// we can use autoconvert = true because search by example add automaticaly
// restriction on extension
PagedResult result = (PagedResult)pagedResult.cast(
this, e.getClass(), true);
timeLog.log(start, "findAllByExample");
return result;
}
/**
* Null field are not used in search request.
*
* @param e sample wikitty
* @return
*/
public E findByExample(E e) {
long start = TimeLog.getTime();
Criteria criteria = Search.query(e.getWikitty()).criteria();
String id = findIdByCriteria(criteria);
E result = null;
if (id != null) {
Wikitty w = wikittyService.restore(securityToken, id);
result = (E) WikittyUtil.newInstance(
securityToken, wikittyService, e.getClass(), w);
}
timeLog.log(start, "findByExample");
return result;
}
///////////////////////////////////////////////////////////////////////////
//
// FIND ALL BY CRITERIA
//
///////////////////////////////////////////////////////////////////////////
/**
* Search object that correspond to criteria and that have all extension
* needed by BusinessEntity (clazz). If one criteria is null, find all extensions
* for this criteria else if criteria is empty return nothing.
*
* @param object type
* @param clazz entity class
* @param criterias criterias
* @return paged result
*/
public List> findAllByCriteria(
Class clazz, List criterias) {
long start = TimeLog.getTime();
List> result = null;
if (criterias != null) {
// newInstance only return BusinessEntityWikittyImpl
BusinessEntityImpl sample =
(BusinessEntityImpl) WikittyUtil.newInstance(clazz);
Wikitty wikitty = sample.getWikitty();
Collection extensions = wikitty.getExtensionNames();
List serviceCriterias = new ArrayList(criterias.size());
for (Criteria criteria : criterias) {
// 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 ...
Criteria serviceCriteria = null;
if (criteria != null) {
serviceCriteria = criteria.clone();
// Dont add contraint if using select
if (StringUtils.isEmpty(criteria.getSelect())) {
// utilisation de cette nouvelle contrainte sur le nouvel objet
// creation de la nouvelle contrainte
Search search = Search.query(criteria);
search = search.exteq(extensions);
serviceCriteria.setRestriction(search);
}
}
// ajout de ce criteria dans la liste de tous les criteres
serviceCriterias.add(serviceCriteria);
}
List> pagedResult = wikittyService.findAllByCriteria(
securityToken, serviceCriterias);
// TODO poussin 20110318 optimize cast. Try to cast all pagedResult id
// in one call to service. Currently each PagedResult.cast do a call
result = new ArrayList>(pagedResult.size());
for (PagedResult p : pagedResult) {
result.add((PagedResult)p.cast(this, sample.getClass(), true));
}
}
timeLog.log(start, "findAllByCriteria(List)");
return result;
}
/**
* Search object that correspond to criteria and that have all extension
* needed by BusinessEntity (clazz). If criteria is null, find all extensions
* else if criteria is empty return nothing.
*
* @param object type
* @param clazz entity class
* @param criteria criteria
* @return paged result
*/
public PagedResult findAllByCriteria(
Class clazz, Criteria criteria) {
long start = TimeLog.getTime();
PagedResult result = findAllByCriteria(clazz,
Collections.singletonList(criteria)).get(0);
timeLog.log(start, "findAllByCriteria(One)");
return result;
}
/**
* Search object that correspond to criteria and that have all extension
* needed by BusinessEntity (clazz). If criteria is null, find all extensions
* else if criteria is empty return nothing.
*
* @param object type
* @param clazz entity class
* @param c1 criteria 1
* @param c2 criteria 2
* @param otherCriteria otherCriteria
* @return paged result
*/
public PagedResult[] findAllByCriteria(
Class clazz, Criteria c1, Criteria c2, Criteria... otherCriteria) {
long start = TimeLog.getTime();
List criterias = new ArrayList(otherCriteria.length + 2);
Collections.addAll(criterias, c1, c2);
Collections.addAll(criterias, otherCriteria);
List> resultList = findAllByCriteria(clazz, criterias);
PagedResult[] result = resultList.toArray(new PagedResult[criterias.size()]);
timeLog.log(start, "findAllByCriteria(Varargs)");
return result;
}
///////////////////////////////////////////////////////////////////////////
//
// FIND ALL BY CRITERIA
//
///////////////////////////////////////////////////////////////////////////
public List> findAllByCriteria(List criteria) {
long start = TimeLog.getTime();
List> result = null;
if (criteria != null) {
List> resultId =
wikittyService.findAllByCriteria(securityToken, criteria);
// TODO poussin 20110318 optimize cast. Try to cast all pagedResult id
// in one call to service. Currently each PagedResult.cast do a call
result = new ArrayList>(resultId.size());
for (PagedResult p : resultId) {
result.add(p.cast(securityToken, wikittyService));
}
}
timeLog.log(start, "findAllByCriteria(List)");
return result;
}
public PagedResult findAllByCriteria(Criteria criteria) {
long start = TimeLog.getTime();
PagedResult result = null;
if (criteria != null) {
result = findAllByCriteria(Collections.singletonList(criteria)).get(0);
}
timeLog.log(start, "findAllByCriteria(One)");
return result;
}
public PagedResult[] findAllByCriteria(
Criteria c1, Criteria c2, Criteria ... otherCriteria) {
long start = TimeLog.getTime();
List criterias = new ArrayList(otherCriteria.length + 2);
Collections.addAll(criterias, c1, c2);
Collections.addAll(criterias, otherCriteria);
List> resultList = findAllByCriteria(criterias);
PagedResult[] result = resultList.toArray(new PagedResult[criterias.size()]);
timeLog.log(start, "findAllByCriteria(Varargs)");
return result;
}
///////////////////////////////////////////////////////////////////////////
//
// FIND ALL ID BY CRITERIA
//
///////////////////////////////////////////////////////////////////////////
public List> findAllIdByCriteria(List criteria) {
long start = TimeLog.getTime();
List> result = null;
if (criteria != null) {
result = wikittyService.findAllByCriteria(securityToken, criteria);
}
timeLog.log(start, "findAllIdByCriteria(List)");
return result;
}
public PagedResult findAllIdByCriteria(Criteria criteria) {
long start = TimeLog.getTime();
PagedResult result = null;
if (criteria != null) {
result = findAllIdByCriteria(
Collections.singletonList(criteria)).get(0);
}
timeLog.log(start, "findAllIdByCriteria(One)");
return result;
}
public PagedResult[] findAllIdByCriteria(
Criteria c1, Criteria c2, Criteria ... otherCriteria) {
long start = TimeLog.getTime();
List criterias = new ArrayList(otherCriteria.length + 2);
Collections.addAll(criterias, c1, c2);
Collections.addAll(criterias, otherCriteria);
List> resultList = findAllIdByCriteria(criterias);
PagedResult[] result = resultList.toArray(new PagedResult[criterias.size()]);
timeLog.log(start, "findAllIdByCriteria(Varargs)");
return result;
}
///////////////////////////////////////////////////////////////////////////
//
// FIND ID BY CRITERIA
//
///////////////////////////////////////////////////////////////////////////
public List findIdByCriteria(List criteria) {
long start = TimeLog.getTime();
List result = null;
if (criteria != null) {
result = wikittyService.findByCriteria(securityToken, criteria);
}
timeLog.log(start, "findIdByCriteria(List)");
return result;
}
public String findIdByCriteria(Criteria criteria) {
long start = TimeLog.getTime();
String result = null;
if (criteria != null) {
result = findIdByCriteria(Collections.singletonList(criteria)).get(0);
}
timeLog.log(start, "findIdByCriteria(One)");
return result;
}
public String[] findIdByCriteria(
Criteria c1, Criteria c2, Criteria... otherCriteria) {
long start = TimeLog.getTime();
List criterias = new ArrayList(otherCriteria.length + 2);
Collections.addAll(criterias, c1, c2);
Collections.addAll(criterias, otherCriteria);
List resultList = findIdByCriteria(criterias);
String[] result = resultList.toArray(new String[criterias.size()]);
timeLog.log(start, "findIdByCriteria(Varargs)");
return result;
}
///////////////////////////////////////////////////////////////////////////
//
// FIND BY CRITERIA
//
///////////////////////////////////////////////////////////////////////////
public List findByCriteria(
Class clazz, List criterias) {
long start = TimeLog.getTime();
List result = null;
if (criterias != null) {
BusinessEntityImpl sample =
(BusinessEntityImpl) WikittyUtil.newInstance(clazz);
Wikitty wikitty = sample.getWikitty();
Collection extensions = wikitty.getExtensionNames();
List serviceCriterias = new ArrayList(criterias.size());
for (Criteria criteria : criterias) {
Search search = Search.query(criteria);
search = search.exteq(extensions);
criteria = search.criteria();
serviceCriterias.add(criteria);
}
List id = findIdByCriteria(serviceCriterias);
result = restore(clazz, id);
}
timeLog.log(start, "multiFindByCriteria(List>");
return result;
}
public E findByCriteria(
Class clazz, Criteria criteria) {
long start = TimeLog.getTime();
E result = null;
if (criteria != null) {
List criterias = findByCriteria(clazz, Collections.singletonList(criteria));
if (!criterias.isEmpty()) {
result = criterias.get(0);
}
}
timeLog.log(start, "findByCriteria(One)");
return result;
}
public E[] findByCriteria(
Class clazz, Criteria c1, Criteria c2, Criteria... otherCriteria) {
long start = TimeLog.getTime();
List criterias = new ArrayList(otherCriteria.length + 2);
Collections.addAll(criterias, c1, c2);
Collections.addAll(criterias, otherCriteria);
List resultList = findByCriteria(clazz, criterias);
E[] result = resultList.toArray((E[])Array.newInstance(clazz, resultList.size()));
timeLog.log(start, "findByCriteria(One)");
return result;
}
///////////////////////////////////////////////////////////////////////////
//
// FIND BY CRITERIA
//
///////////////////////////////////////////////////////////////////////////
public List findByCriteria(List criteria) {
long start = TimeLog.getTime();
List result = null;
if (criteria != null) {
List id = findIdByCriteria(criteria);
result = restore(id);
}
timeLog.log(start, "findByCriteria(List)");
return result;
}
public Wikitty findByCriteria(Criteria criteria) {
long start = TimeLog.getTime();
String id = findIdByCriteria(criteria);
Wikitty wikitty = restore(id);
timeLog.log(start, "findByCriteria(One)");
return wikitty;
}
public Wikitty[] findByCriteria(
Criteria c1, Criteria c2, Criteria... otherCriteria) {
long start = TimeLog.getTime();
List criterias = new ArrayList(otherCriteria.length + 2);
Collections.addAll(criterias, c1, c2);
Collections.addAll(criterias, otherCriteria);
List resultList = findIdByCriteria(criterias);
List wikitties = restore(resultList);
Wikitty[] result = wikitties.toArray(new Wikitty[resultList.size()]);
timeLog.log(start, "findByCriteria(One)");
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
*
* @param wikittyId root
* @param depth profondeur de noeud a recuperer
* @param count vrai si l'on veut le nombre de piece attaches sur le noeud
* (piece des enfants compris)
* @param filter filter pour compter les pieces attachees
* @return treeNodeResult of wikitty
*
* @since 3.1
*/
public TreeNodeResult findTreeNode(
String wikittyId, int depth, boolean count, Criteria filter) {
long start = TimeLog.getTime();
TreeNodeResult resultId = wikittyService.findTreeNode(
securityToken, wikittyId, depth, count, filter);
RetrieveIdVisitor retrieveIdVisitor = new RetrieveIdVisitor();
resultId.acceptVisitor(retrieveIdVisitor);
List ids = retrieveIdVisitor.getIds();
List wikitties = restore(ids);
IdToObjectConverter converter =
new IdToObjectConverter(ids, wikitties);
ConvertTreeVisitor convertVisitor =
new ConvertTreeVisitor(converter);
resultId.acceptVisitor(convertVisitor);
TreeNodeResult result = convertVisitor.getTree();
timeLog.log(start, "findTreeNode");
return result;
}
/**
* 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 E in result
*
* @param clazz business class wanted to replace id in TreeNodeResult
* @param wikittyId root
* @param depth profondeur de noeud a recuperer
* @param count vrai si l'on veut le nombre de piece attaches sur le noeud (piece des enfants compris)
* @param filter filter pour compter les pieces attachees
* @return
*
* @since 3.1
*/
public TreeNodeResult findTreeNode(
Class clazz, String wikittyId, int depth,
boolean count, Criteria filter) {
long start = TimeLog.getTime();
TreeNodeResult resultId = wikittyService.findTreeNode(
securityToken, wikittyId, depth, count, filter);
RetrieveIdVisitor retrieveIdVisitor = new RetrieveIdVisitor();
resultId.acceptVisitor(retrieveIdVisitor);
List ids = retrieveIdVisitor.getIds();
List wikitties = restore(clazz, ids);
IdToObjectConverter converter =
new IdToObjectConverter(ids, wikitties);
ConvertTreeVisitor convertVisitor =
new ConvertTreeVisitor(converter);
resultId.acceptVisitor(convertVisitor);
TreeNodeResult result = convertVisitor.getTree();
timeLog.log(start, "findTreeNode");
return result;
}
/**
* Used to collect all node id
* @since 3.1
*/
static private class RetrieveIdVisitor implements TreeNodeResult.Visitor {
protected List ids = new ArrayList();
public List getIds() {
return ids;
}
@Override
public boolean visitEnter(TreeNodeResult node) {
String id = node.getObject();
ids.add(id);
return true;
}
@Override
public boolean visitLeave(TreeNodeResult node) {
return true;
}
}
/**
* Converti un id en son object WikittyTreeNode
* @since 3.1
*/
static private class IdToObjectConverter implements ConvertTreeVisitor.Converter {
protected Map objects = new HashMap();
protected String securityToken;
protected WikittyService wikittyService;
public IdToObjectConverter(List ids, List objectList) {
for (int i = 0; i < ids.size(); i++) {
this.objects.put(ids.get(i), objectList.get(i));
}
}
@Override
public T convert(String id) {
T result = objects.get(id);
return result;
}
}
/**
* Parcours un TreeNodeResult et en fait une copie en modifiant le type
* d'objet stocker dans le noeud grace a un converter, si le converter
* est null une exception est levee
*
* @param le type d'objet pour le nouvel arbre
* @since 3.1
*/
static private class ConvertTreeVisitor implements TreeNodeResult.Visitor {
static private interface Converter {
public TARGET convert(SOURCE o);
}
protected Converter converter;
protected TreeNodeResult tree = null;
protected LinkedList> stack =
new LinkedList>();
public ConvertTreeVisitor(Converter converter) {
this.converter = converter;
if (converter == null) {
throw new IllegalArgumentException("Converter can't be null");
}
}
public TreeNodeResult getTree() {
return tree;
}
@Override
public boolean visitEnter(TreeNodeResult node) {
String id = node.getObject();
int count = node.getAttCount();
TARGET object = converter.convert(id);
TreeNodeResult newNode = new TreeNodeResult(
object, count);
TreeNodeResult parent = stack.peekLast();
if (parent == null) {
// le premier noeud, donc le root a retourner plus tard
tree = newNode;
} else {
parent.add(newNode);
}
stack.offerLast(newNode);
return true;
}
@Override
public boolean visitLeave(TreeNodeResult node) {
stack.pollLast();
return true;
}
}
/**
* 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 just wikitty Id in result
*
* @param wikittyId
* @param depth
* @param count
* @param filter
* @return
* @since 3.1
*/
public TreeNodeResult findAllIdTreeNode(
String wikittyId, int depth, boolean count, Criteria filter) {
long start = TimeLog.getTime();
TreeNodeResult result = wikittyService.findTreeNode(
securityToken, wikittyId, depth, count, filter);
timeLog.log(start, "findAllIdTreeNode");
return result;
}
/**
* Delete specified tree node and all sub nodes.
*
* @param treeNodeId tree node id to delete
* @return {@true} if at least one node has been deleted
*/
public WikittyEvent deleteTree(String treeNodeId) {
long start = TimeLog.getTime();
WikittyEvent result = wikittyService.deleteTree(securityToken,treeNodeId);
timeLog.log(start, "deleteTree");
return result;
}
/**
* Restore node with wikittyId passed in argument and count of attachment
* in subtree begin with this node
*
* @param
* @param clazz
* @param wikittyId
* @param filter
* @return
* @deprecated since 3.1: use {@link #findTreeNode(java.lang.Class, java.lang.String, int, boolean, org.nuiton.wikitty.search.Criteria)} or open new ticket with your need
*/
@Deprecated
public Map.Entry restoreNode(
Class clazz, String wikittyId, Criteria filter) {
long start = TimeLog.getTime();
TreeNodeResult tree = findTreeNode(clazz, wikittyId, 0, true, filter);
Map.Entry result = new SimpleEntry(
tree.getObject(), tree.getAttCount());
timeLog.log(start, "restoreNode");
return result;
}
/**
* Restore node with wikittyId passed in argument and count of attachment
* in subtree begin with this node
*
* ATTENTION: extension is never checked.
*
* @param
* @param clazz
* @param wikittyId
* @param filter
* @param checkExtension not used
* @deprecated since 3.1: use {@link #findTreeNode(java.lang.Class, java.lang.String, int, boolean, org.nuiton.wikitty.search.Criteria)} or open new ticket with your need
*/
@Deprecated
public Map.Entry restoreNode(
Class clazz, String wikittyId, Criteria filter, boolean checkExtension) {
Map.Entry result = restoreNode(clazz, wikittyId, filter);
return result;
}
/**
* Return only children of wikittyId passed in argument
*
* @param clazz
* @param wikittyId
* @param filter
* @return
*
* @deprecated since 3.1: use {@link #findTreeNode(java.lang.Class, java.lang.String, int, boolean, org.nuiton.wikitty.search.Criteria) } or open new ticket with your need
*/
@Deprecated
public Map findTreeNode(
Class clazz, String wikittyId, Criteria filter) {
long start = TimeLog.getTime();
TreeNodeResult