Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%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
  * <http://www.gnu.org/licenses/lgpl-3.0.html>.
  * #L%
  */
 package org.nuiton.wikitty.services;
 
 
 import java.util.List;
 import java.util.Map;

Author(s):
poussin
Version:
$Revision$ Last update: $Date$ by : $Author$
 
 public class WikittyServiceTransaction implements WikittyService {

    
to use log facility, just put in your code: log.info(\"...\");
 
     static private Log log = LogFactory.getLog(WikittyServiceTransaction.class);

    
Real WikittyService
 
     protected WikittyService ws;
    
WikittyService used to store modified object
 
     protected WikittyService tx;
 
     protected List<WikittyEventevents;

    
if autoCommit > 0 all time events numbers element equals to this autoCommit commit is call
 
     protected int autoCommit = -1;
 
         this. = ws;
         // use WikittyService in Memory
         // use configuration to retrive transaction in memory implementation
         // you must used WikittyServiceInMemoryJdbcSolr implementation
         this. = WikittyServiceFactory.buildWikittyServiceTransaction(config);
          = new LinkedList<WikittyEvent>();
     }
 
     public void setAutoCommit(int autoCommit) {
         this. = autoCommit;
     }
 
     public int getAutoCommit() {
         return ;
     }
 
     protected void addEvent(String securityTokenWikittyEvent e) {
         .add(e);
         if ( > 0 && .size() >= ) {
             commit(securityToken);
         }
    }
    public void commit(String securityToken) {
        .replay(securityTokenfalse);
        this..clear(null);
        .clear();
    }
    public void commit(String securityTokenboolean force) {
        .replay(securityTokenforce);
        this..clear(null);
        .clear();
    }
    public void rollback(String securityToken) {
        this..clear(null);
        .clear();
    }
    
    @Override
    public void addWikittyServiceListener(WikittyListener listenerServiceListenerType type) {
        throw new UnsupportedOperationException(
                "You try to add listener on WikittyServiceTransaction,"
                + "this is an error desgin, you must add WikittyServiceNotifier"
                + "front of your WikittyServiceTransaction.");
    }
    @Override
    public void removeWikittyServiceListener(WikittyListener listenerServiceListenerType type) {
        throw new UnsupportedOperationException(
                "You try to remove listener on WikittyServiceTransaction,"
                + "this is an error desgin, you must add WikittyServiceNotifier"
                + "front of your WikittyServiceTransaction.");
    }
    @Override
    public String login(String loginString password) {
        return .login(loginpassword);
    }

    
Question: est un comportement normale, lorsqu'on se delogue depuis une transaction, on est deloguer partout ? je pense que oui

Parameters:
securityToken
    @Override
    public void logout(String securityToken) {
        .logout(securityToken);
    }
    @Override
    public String getToken(String user) {
        return .getToken(user);
    }
    @Override
    public WikittyEvent clear(String securityToken) {
        WikittyEvent e = .clear(securityToken);
        addEvent(securityTokene);
        return e;
    }
    @Override
    public boolean canWrite(String securityTokenWikitty wikitty) {
        // in transaction, we can do all. But not during commit
        return true;
    }
    @Override
    public boolean canDelete(String securityTokenString wikittyId) {
        // in transaction, we can do all. But not during commit
        return true;
    }
    @Override
    public boolean canRead(String securityTokenString wikittyId) {
        boolean result = .exists(securityTokenwikittyId);
        if (!result) {
            // on ne l'a pas en local on va voir si on peut le lire en distant
            result = .canRead(securityTokenwikittyId);
        }
        return result;
    }
    @Override
    public WikittyEvent replay(
            String securityTokenList<WikittyEventeventsboolean force) {
        WikittyEvent e = .replay(securityTokeneventsforce);
        events.add(e);
        return e;
    }
    @Override
    public WikittyEvent store(
            String securityTokenCollection<Wikittywikittiesboolean force) {
        WikittyEvent e = .store(securityTokenwikittiesforce);
        addEvent(securityTokene);
        return e;
    }
    @Override
    public List<StringgetAllExtensionIds(String securityToken) {
        HashSet<Stringtmp = new HashSet<String>();
        
        tmp.addAll(.getAllExtensionIds(securityToken));
        tmp.addAll(.getAllExtensionIds(securityToken));
        
        List<Stringresult = new ArrayList<String>(tmp);
        return result;
    }
    @Override
    public List<StringgetAllExtensionsRequires(String securityTokenString extensionName) {
        HashSet<Stringtmp = new HashSet<String>();
        tmp.addAll(.getAllExtensionsRequires(securityTokenextensionName));
        tmp.addAll(.getAllExtensionsRequires(securityTokenextensionName));
        List<Stringresult = new ArrayList<String>(tmp);
        return result;
    }
    @Override
            String securityTokenCollection<WikittyExtensionexts) {
        WikittyEvent e = .storeExtension(securityTokenexts);
        addEvent(securityTokene);
        return e;
    }
    @Override
            String securityTokenCollection<StringextNames) {
        WikittyEvent e = .deleteExtension(securityTokenextNames);
        addEvent(securityTokene);
        return e;
    }
    @Override
            String securityTokenString extensionId) {
        WikittyExtension result = .restoreExtension(securityTokenextensionId);
        if (result == null) {
            result = .restoreExtension(securityTokenextensionId);
        }
        return result;
    }
    @Override
            String securityTokenString name) {
        WikittyExtension result =
                .restoreExtensionLastVersion(securityTokenname);
        if (result == null) {
            result = .restoreExtensionLastVersion(securityTokenname);
        }
        return result;
    }
    @Override
    public List<WikittyExtensionrestoreExtensionAndDependenciesLastVesion(String securityTokenCollection<StringextensionNames) {
        List<WikittyExtensionresult = new ArrayList<WikittyExtension>();
        for (String extName : extensionNames) {
            WikittyExtension ext = restoreExtensionLastVersion(
                    securityTokenextName);
            if (ext != null) {
                // on recherche les dependances de cette extension ...
                List<Stringrequires = ext.getRequires();
                if (CollectionUtils.isNotEmpty(requires)) {
                    List<WikittyExtensiondependencies =
                            restoreExtensionAndDependenciesLastVesion(
                            securityTokenrequires);
                    // ... et on les ajoute avant dans le resultat
                    result .addAll(dependencies);
                }
                result.add(ext);
            }
        }
        return result;
    }
    @Override
    public List<Wikittyrestore(String securityTokenList<Stringids) {
        List<WikittyresultWS = .restore(securityTokenids);
        List<WikittyresultTx = .restore(securityTokenids);
        Wikitty[] result = resultWS.toArray(new Wikitty[resultWS.size()]);
        int i = 0;
        for (Wikitty w : resultTx) {
            String id = ids.get(i);
            // il faut prendre en compte que l'objet a pu etre supprime dans la
            // transaction donc meme s'il est null dans tx et pas dans ws, il
            // faut le mettre a null
            // si w n'a pas ete restore (null), mais qu'il exist, alors cela
            // veut dire qu'il est supprime.
            if (w != null || .exists(securityTokenid)) {
                // on remplace tout par les nouveaux de la transaction
                result[i] = w;
            }
            i++;
        }
        return Arrays.asList(result);
    }
    @Override
    public WikittyEvent delete(String securityTokenCollection<Stringids) {
        // pour que tout fonctionne bien, il faut que les objets supprimer soit
        // dans la tx, car il faut avoir une vrai trace de cette suppression dans la tx
        List<Wikittywikitties = .restore(securityTokennew ArrayList<String>(ids));
        .store(securityTokenwikittiestrue);
        WikittyEvent e = .delete(securityTokenids);
        addEvent(securityTokene);
        return e;
    }
    @Override
            String securityTokenList<Criteriacriteria) {
        List<PagedResult<String>> resultTxList =
                .findAllByCriteria(securityTokencriteria);
        List<PagedResult<String>> resultWsList =
                .findAllByCriteria(securityTokencriteria);
        List<PagedResult<String>> result =
                new ArrayList<PagedResult<String>>(resultWsList.size());
        for (int i=0; i<criteria.size(); i++) {
            PagedResult<StringresultTx = resultTxList.get(i);
            PagedResult<StringresultWs = resultWsList.get(i);
            // Il faut fusionner les deux resultats
            // - ne pas avoir de doublon
            // - ne pas retenir ceux supprimer dans la transaction
            // - fusionner les facettes (comment faire ?)
            // - respecter le range demander (comment faire, avec les suppressions possible ?)
            LinkedHashSet<Stringids =
                    new LinkedHashSet<String>(resultTx.size() + resultWs.size());
            ids.addAll(resultTx.getAll());
            for (String id : resultWs.getAll()) {
                if (!.exists(securityTokenid) || !.isDeleted(securityTokenid)) {
                    ids.add(id);
                }
            }
            String criteriaName = resultWs.getCriteriaName();
            int firstIndice = resultWs.getFirstIndice();
            // FIXME le resultat est faux, le nombre total n'est pas la somme des deux :(
            int numFound = resultTx.getNumFound() + resultWs.getNumFound();
            String queryString = resultWs.getQueryString();
            // FIXME les facettes sont fausses :(
            Map<StringList<FacetTopic>> facets = resultWs.getFacets();
            List<Stringresults = new ArrayList<String>(ids);
             result.add(new PagedResult<String>(criteriaName,
                    firstIndicenumFoundqueryStringfacetsresults));
        }
        if (criteria.size() != result.size()) {
            .error(String.format("Criteria input list (%s) has not same size that result list (%s)",
                    criteria.size(), result.size()));
        }
        return result;
    }
    @Override
    public List<StringfindByCriteria(String securityTokenList<Criteriacriteria) {
        List<Stringresult = new ArrayList<String>(criteria.size());
        List<CriteriacriteriaLimit = new ArrayList<Criteria>(criteria.size());
        for (Criteria c : criteria) {
            Criteria climit = Search.query(c).criteria().setFirstIndex(0).setEndIndex(1);
            criteriaLimit.add(climit);
        }
        List<PagedResult<String>> idsList = findAllByCriteria(
                securityTokencriteriaLimit);
        for (PagedResult<Stringids : idsList) {
            if (ids.size() > 0) {
                result.add(ids.getFirst());
            } else {
                result.add(null);
            }
        }
        if (criteria.size() != result.size()) {
            .error(String.format("Criteria input list (%s) has not same size that result list (%s)",
                    criteria.size(), result.size()));
        }
        return result;
    }
    @Override
    public TreeNodeResult<StringfindTreeNode(String securityToken,
            String wikittyIdint depthboolean countCriteria filter) {
        // FIXME
        throw new UnsupportedOperationException("Not supported yet.");
    }
    // FIXME poussin 20130218 a revoir car les order by, les facets, limit et offset ne sont pas respecte :(
    @Override
            String securityTokenList<WikittyQueryqueries) {
        // on recree une liste avec seulement les clause where
        List<WikittyQueryqueriesWhere = new ArrayList<WikittyQuery>();
        for (WikittyQuery q : queries) {
            if (q.isSelectQuery()) {
                queriesWhere.add(q.getWhereQuery());
            } else {
                queriesWhere.add(q);
            }
        }
        // on ne joue que les clauses where car le select sera rejouer completement
        List<WikittyQueryResult<Map<StringObject>>> resultTxList =
                .findAllByQuery(securityTokenqueriesWhere);
        List<WikittyQueryResult<Map<StringObject>>> resultWsList =
                .findAllByQuery(securityTokenqueriesWhere);
        List<WikittyQueryResult<Map<StringObject>>> result =
                new ArrayList<WikittyQueryResult<Map<StringObject>>>(queries.size());
        for (int i=0; i<queries.size(); i++) {
            long timeStart = System.currentTimeMillis();
            WikittyQuery query = queries.get(i);
            WikittyQueryResult<Map<StringObject>> resultTx = resultTxList.get(i);
            WikittyQueryResult<Map<StringObject>> resultWs = resultWsList.get(i);
            //
            // Il faut fusionner les deux resultats
            //
            // - ne pas avoir de doublon
            // - ne pas retenir ceux supprimer dans la transaction
            //   en respectant l'ordre de tri demande (comment faire?)
            // - fusionner les facettes (comment faire ?)
            // - respecter le range demander (comment faire, avec les suppressions possible ?)
            LinkedHashSet<Stringids =
                    new LinkedHashSet<String>(resultTx.getWikittyResultSize() + resultWs.getWikittyResultSize());
            ids.addAll(resultTx.getWikittyResult().getAll());
            for (String id : resultWs.getWikittyResult().getAll()) {
                if ((!.exists(securityTokenid) || !.isDeleted(securityTokenid))) {
                    ids.add(id);
                } else {
                    // pas un id, donc on ne sais pas encore comment faire :(. On l'ajoute
                    ids.add(id);
                }
            }
            List<StringwikittyId = new ArrayList<String>(ids);
            //
            // il faut calculer le select
            //
            List<Map<StringObject>> selectFusion = null;
            if (query.isSelectQuery()) {
                List<Map<StringObject>> values = new ArrayList<Map<StringObject>>(wikittyId.size());
                // recuperation des wikitties pour pouvoir jouer le select
                List<Wikittywikitties = restore(securityTokenwikittyId);
                // transformation des wikitties en Map avec l'id dans la map
                String idKey = ..getValue();
                for (Wikitty w : wikitties) {
                    Map<StringObjectmap = new LinkedHashMap<StringObject>(w.getFieldValue());
                    map.put(idKeyw.getWikittyId());
                    values.add(map);
                }
                // rejoue du select
                Select select = (Select)query.getCondition();
                selectFusion = select.getFunction().call(queryvalues);
            }
            //
            // il faut assigner le resultat principal (select ou wikittyId)
            //
            List<Map<StringObject>> results;
            if (query.isSelectQuery()) {
                // on met selectFusion dans result
                results = selectFusion;
            } else {
                // on met les ids dans results
                results = new ArrayList<Map<StringObject>>(ids.size());
                String idKey = ..getValue();
                for (String id : ids) {
                    results.add(WikittyUtil.singletonMap(idKeyid));
                }
            }
            String queryName = resultWs.getQueryName();
            int firstIndice = resultWs.getOffset();
            // FIXME le resultat est faux, le nombre total n'est pas la somme des deux :(
            int numFound = resultTx.getTotalResult() + resultWs.getTotalResult();
            String queryString = resultWs.getQueryString();
            // FIXME les facettes sont fausses :(
            Map<StringList<org.nuiton.wikitty.query.FacetTopic>> facets = resultWs.getFacets();
            long timeEnd = System.currentTimeMillis();
            long timeQuery = resultTx.getTimeQuery() + resultWs.getTimeQuery() + timeEnd - timeStart;
             result.add(new WikittyQueryResult<Map<StringObject>>(
                     queryNamefirstIndicenumFoundqueryqueryString,
                     resultsselectFusionwikittyIdfacets,
                     timeQuery, 0));
        }
        if (queries.size() != result.size()) {
            .error(String.format("Queries input list (%s) has not same size that result list (%s)",
                    queries.size(), result.size()));
        }
        return result;
    }
    @Override
    public List<Map<StringObject>> findByQuery(String securityTokenList<WikittyQueryqueries) {
        List<Map<StringObject>> result = new ArrayList<Map<StringObject>>(queries.size());
        List<WikittyQueryqueriesLimited = new ArrayList<WikittyQuery>(queries.size());
        for (WikittyQuery c : queries) {
            WikittyQuery climit = c.copy().setOffset(0).setLimit(1);
            queriesLimited.add(climit);
        }
        List<WikittyQueryResult<Map<StringObject>>> idsList = findAllByQuery(
                securityTokenqueriesLimited);
        for (WikittyQueryResult<Map<StringObject>> ids : idsList) {
            if (ids.size() > 0) {
                result.add(ids.peek());
            } else {
                result.add(null);
            }
        }
        if (queries.size() != result.size()) {
            .error(String.format("Query input list (%s) has not same size that result list (%s)",
                    queries.size(), result.size()));
        }
        return result;
    }
    @Override
    public WikittyQueryResultTreeNode<StringfindTreeNode(String securityToken,
            String wikittyIdint depthboolean countWikittyQuery filter) {
        // FIXME
        throw new UnsupportedOperationException("Not supported yet.");
    }
    @Override
    public WikittyEvent deleteTree(String securityTokenString treeNodeId) {
        // FIXME
        throw new UnsupportedOperationException("Not supported yet.");
    }
    @Override
    public Wikitty restoreVersion(String securityTokenString wikittyIdString version) {
        // FIXME
        throw new UnsupportedOperationException("Not supported yet.");
    }
    @Override
    public void syncSearchEngine(String securityToken) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    @Override
    public boolean exists(String securityTokenString wikittyId) {
        boolean result = .exists(securityTokenwikittyId);
        if (!result) {
            if (!.isDeleted(securityTokenwikittyId)) {
                result = .exists(securityTokenwikittyId);
            }
        }
        return result;
    }
    @Override
    public boolean isDeleted(String securityTokenString wikittyId) {
        boolean result = .isDeleted(securityTokenwikittyId);
        // pas efface, peut-etre qu'il existe
        if (!result && !.exists(securityTokenwikittyId)) {
            // il n'est pas efface et il n'existe pas dans la tx,
            // on recherche dans ws
            result = .isDeleted(securityTokenwikittyId);
        }
        return result;
    }
New to GrepCode? Check out our FAQ X