[Wikitty-commits] r896 - trunk/wikitty-publication/src/main/java/org/nuiton/wikitty/publication

17 May 2011

Author: mfortun
Date: 2011-05-17 16:01:38 +0200 (Tue, 17 May 2011)
New Revision: 896

Url: http://nuiton.org/repositories/revision/wikitty/896

Log:
* add multicontext for pagedresult's methods


Modified:
   trunk/wikitty-publication/src/main/java/org/nuiton/wikitty/publication/WikittyPublicationProxy.java

Modified: trunk/wikitty-publication/src/main/java/org/nuiton/wikitty/publication/WikittyPublicationProxy.java
===================================================================

--- trunk/wikitty-publication/src/main/java/org/nuiton/wikitty/publication/WikittyPublicationProxy.java	2011-05-16 16:03:53 UTC (rev 895)
+++ trunk/wikitty-publication/src/main/java/org/nuiton/wikitty/publication/WikittyPublicationProxy.java	2011-05-17 14:01:38 UTC (rev 896)
@@ -301,7 +301,7 @@
     }
 
     public List<Wikitty> storeWikitty(List<Wikitty> wikitties) {
-        
+
         List<Wikitty> result = new ArrayList<Wikitty>();
 
         List<Wikitty> tempObject = new ArrayList<Wikitty>();
@@ -472,7 +472,54 @@
 
     public <E extends BusinessEntityImpl> PagedResult<E> findAllByExample(E e,
             int firstIndex, int endIndex, String... fieldFacet) {
-        return mainProxy.findAllByExample(e, firstIndex, endIndex, fieldFacet);
+
+        PagedResult<E> result = mainProxy.findAllByExample(e, firstIndex,
+                endIndex, fieldFacet);
+
+        int resultSizeExpected = endIndex - firstIndex;
+        if (isFallbackService() && result.size() < resultSizeExpected) {
+
+            if (result.size() == 0) {
+                String oldRequest = result.getQueryString();
+
+                /*
+                 * change the param because we search on the beginning of the
+                 * content of the otherLike they were the same collection
+                 */
+                result = fallbackProxy.findAllByExample(e, 0,
+                        resultSizeExpected, fieldFacet);
+
+                // reform the result
+                PagedResult<E> reformResult = new PagedResult<E>(firstIndex,
+                        result.getNumFound(), oldRequest, result.getFacets(),
+                        result.getAll());
+                result = reformResult;
+            } else {
+
+                /*
+                 * Calculate the number of missing element and search then on
+                 * the fallback wikitty service, and then add this result to the
+                 * final result;
+                 */
+                int missingNumber = resultSizeExpected - result.size();
+
+                PagedResult<E> resultTempFromFall = fallbackProxy
+                        .findAllByExample(e, 0, missingNumber, fieldFacet);
+
+                List<E> completedResultList = result.getAll();
+                completedResultList.addAll(resultTempFromFall.getAll());
+
+                int totalNumberofFound = result.getNumFound()
+                        + resultTempFromFall.getNumFound();
+
+                PagedResult<E> reformResult = new PagedResult<E>(firstIndex,
+                        totalNumberofFound, result.getQueryString(),
+                        result.getFacets(), completedResultList);
+                result = reformResult;
+            }
+        }
+
+        return result;
     }
 
     public <E extends BusinessEntityImpl> E findByExample(E e) {
@@ -487,95 +534,538 @@
 
     public <E extends BusinessEntity> List<PagedResult<E>> findAllByCriteria(
             Class<E> clazz, List<Criteria> criterias) {
-        return mainProxy.findAllByCriteria(clazz, criterias);
+
+        List<PagedResult<E>> result = mainProxy.findAllByCriteria(clazz,
+                criterias);
+
+        if (isFallbackService()) {
+
+            for (int i = 0; i < result.size(); i++) {
+
+                /*
+                 * get the curent criteria and corresponding result to check if
+                 * the expected number of result is match
+                 */
+                Criteria currentCrit = criterias.get(i);
+                PagedResult<E> currentResult = result.get(i);
+
+                int resultSizeExpected = currentCrit.getEndIndex()
+                        - currentCrit.getFirstIndex();
+                if (currentResult.size() < resultSizeExpected) {
+                    /*
+                     * if result empty, just put the result of the fallback's
+                     * requestresult
+                     */
+
+                    /*
+                     * rebuild the criteria to search properly on the second
+                     * service we search for wikitty not in the same position,
+                     * but in the beginning
+                     */
+                    Criteria critFallback = Search.query(currentCrit)
+                            .criteria();
+                    critFallback.setFirstIndex(0);
+                    critFallback.setEndIndex(currentCrit.getEndIndex()
+                            - currentCrit.getFirstIndex());
+
+                    if (result.size() == 0) {
+
+                        PagedResult<E> tempPagedResult = fallbackProxy
+                                .findAllByCriteria(clazz, critFallback);
+
+                        // rebuild the result to match the expected criteria
+                        tempPagedResult = new PagedResult<E>(
+                                currentCrit.getFirstIndex(),
+                                tempPagedResult.getNumFound(),
+                                currentCrit.toString(),
+                                tempPagedResult.getFacets(),
+                                tempPagedResult.getAll());
+
+                        result.set(i, tempPagedResult);
+                    } else {
+
+                        /*
+                         * we will search to complete the result with id from
+                         * the fallback service so we reduce the number of
+                         * element requested on the fallback service and we add
+                         * a restriction on wikitty id to exclude id already in
+                         * the first part of the result
+                         * 
+                         * it not assume that wikitty id found does not exist on
+                         * the first part of a criteria, for example if first
+                         * index where 12, nothing assure that we found wikitty
+                         * in the fall back that aren't in the 11 first wikitty
+                         * of the main service
+                         */
+                        PagedResult<String> idFromMain = mainProxy
+                                .findAllIdByCriteria(currentCrit);
+
+                        Criteria excluding = idNotInCriteriaConstructor(
+                                critFallback, idFromMain.getAll());
+
+                        excluding.setEndIndex(resultSizeExpected
+                                - result.size());
+
+                        PagedResult<E> resultFallback = fallbackProxy
+                                .findAllByCriteria(clazz, excluding);
+
+                        List<E> allresult = currentResult.getAll();
+                        allresult.addAll(resultFallback.getAll());
+                        int number = currentResult.getNumFound()
+                                + resultFallback.getNumFound();
+
+                        // rebuilt the result
+                        PagedResult<E> tempPagedResult = new PagedResult<E>(
+                                currentCrit.getFirstIndex(), number,
+                                currentCrit.toString(),
+                                currentResult.getFacets(), allresult);
+                        // re set the result in the list
+                        result.set(i, tempPagedResult);
+                    }
+                }
+
+            }
+        }
+
+        return result;
     }
 
     public <E extends BusinessEntity> PagedResult<E> findAllByCriteria(
             Class<E> clazz, Criteria criteria) {
 
-        PagedResult<E> result = mainProxy.findAllByCriteria(clazz, criteria); 
-        
-        
-        if (isFallbackService()) {
+        PagedResult<E> result = mainProxy.findAllByCriteria(clazz, criteria);
+
+        // PagedResult<String> result = mainProxy.findAllIdByCriteria(criteria);
+
+        int resultSizeExpected = criteria.getEndIndex()
+                - criteria.getFirstIndex();
+        if (isFallbackService() && result.size() < resultSizeExpected) {
+            // if result empty, just put the result of the fallback's request
+            // result
+
             /*
-             * TODO mfortun-2011-05-16 algo
-             * 
-             * search id on the main,
-             * search id on the fallback
-             * fallbackid-mainid
-             * 
-             * restore id from fallback
-             * complete pagedresult 
-             * 
-             * 
-             *
+             * rebuild the criteria to search properly on the second service we
+             * search for wikitty not in the same position, but in the beginning
              */
-            
+            Criteria critFallback = Search.query(criteria).criteria();
+            critFallback.setFirstIndex(0);
+            critFallback.setEndIndex(criteria.getEndIndex()
+                    - criteria.getFirstIndex());
+
+            if (result.size() == 0) {
+
+                result = fallbackProxy.findAllByCriteria(clazz, critFallback);
+                // rebuild the result to match the expected criteria
+                result = new PagedResult<E>(criteria.getFirstIndex(),
+                        result.getNumFound(), criteria.toString(),
+                        result.getFacets(), result.getAll());
+            } else {
+
+                PagedResult<String> idFromMain = mainProxy
+                        .findAllIdByCriteria(criteria);
+
+                /*
+                 * we will search to complete the result with id from the
+                 * fallback service so we reduce the number of element requested
+                 * on the fallback service and we add a restriction on wikitty
+                 * id to exclude id already in the first part of the result
+                 * 
+                 * it not assume that wikitty id found does not exist on the
+                 * first part of a criteria, for example if first index where
+                 * 12, nothing assure that we found wikitty in the fall back
+                 * that aren't in the 11 first wikitty of the main service
+                 */
+                Criteria excluding = idNotInCriteriaConstructor(critFallback,
+                        idFromMain.getAll());
+
+                excluding.setEndIndex(resultSizeExpected - result.size());
+
+                PagedResult<E> resultFallback = fallbackProxy
+                        .findAllByCriteria(clazz, excluding);
+
+                List<E> allresult = result.getAll();
+                allresult.addAll(resultFallback.getAll());
+                int number = result.getNumFound()
+                        + resultFallback.getNumFound();
+
+                result = new PagedResult<E>(criteria.getFirstIndex(), number,
+                        criteria.toString(), result.getFacets(), allresult);
+            }
         }
-        
-        
-        
+
         return result;
     }
 
     public <E extends BusinessEntity> PagedResult<E>[] findAllByCriteria(
             Class<E> clazz, Criteria c1, Criteria c2, Criteria... otherCriteria) {
-        
+
         List<Criteria> criterias = new ArrayList<Criteria>();
         criterias.add(c1);
         criterias.add(c2);
         CollectionUtil.addAll(criterias, otherCriteria);
-        
+
         // deleguate to easily handle multicontext
-        return (PagedResult<E>[]) this.findAllByCriteria(clazz, criterias).toArray();
+        return (PagedResult<E>[]) this.findAllByCriteria(clazz, criterias)
+                .toArray();
     }
 
     public List<PagedResult<Wikitty>> findAllByCriteria(List<Criteria> criteria) {
-        return mainProxy.findAllByCriteria(criteria);
+
+        List<PagedResult<Wikitty>> result = mainProxy
+                .findAllByCriteria(criteria);
+
+        if (isFallbackService()) {
+
+            for (int i = 0; i < result.size(); i++) {
+
+                /*
+                 * get the curent criteria and corresponding result to check if
+                 * the expected number of result is match
+                 */
+                Criteria currentCrit = criteria.get(i);
+                PagedResult<Wikitty> currentResult = result.get(i);
+
+                int resultSizeExpected = currentCrit.getEndIndex()
+                        - currentCrit.getFirstIndex();
+                if (currentResult.size() < resultSizeExpected) {
+                    /*
+                     * if result empty, just put the result of the fallback's
+                     * requestresult
+                     */
+
+                    /*
+                     * rebuild the criteria to search properly on the second
+                     * service we search for wikitty not in the same position,
+                     * but in the beginning
+                     */
+                    Criteria critFallback = Search.query(currentCrit)
+                            .criteria();
+                    critFallback.setFirstIndex(0);
+                    critFallback.setEndIndex(currentCrit.getEndIndex()
+                            - currentCrit.getFirstIndex());
+
+                    if (result.size() == 0) {
+
+                        PagedResult<Wikitty> tempPagedResult = fallbackProxy
+                                .findAllByCriteria(critFallback);
+
+                        // rebuild the result to match the expected criteria
+                        tempPagedResult = new PagedResult<Wikitty>(
+                                currentCrit.getFirstIndex(),
+                                tempPagedResult.getNumFound(),
+                                currentCrit.toString(),
+                                tempPagedResult.getFacets(),
+                                tempPagedResult.getAll());
+
+                        result.set(i, tempPagedResult);
+                    } else {
+
+                        /*
+                         * we will search to complete the result with id from
+                         * the fallback service so we reduce the number of
+                         * element requested on the fallback service and we add
+                         * a restriction on wikitty id to exclude id already in
+                         * the first part of the result
+                         * 
+                         * it not assume that wikitty id found does not exist on
+                         * the first part of a criteria, for example if first
+                         * index where 12, nothing assure that we found wikitty
+                         * in the fall back that aren't in the 11 first wikitty
+                         * of the main service
+                         */
+                        PagedResult<String> idFromMain = mainProxy
+                                .findAllIdByCriteria(currentCrit);
+
+                        Criteria excluding = idNotInCriteriaConstructor(
+                                critFallback, idFromMain.getAll());
+
+                        excluding.setEndIndex(resultSizeExpected
+                                - result.size());
+
+                        PagedResult<Wikitty> resultFallback = fallbackProxy
+                                .findAllByCriteria(excluding);
+
+                        List<Wikitty> allresult = currentResult.getAll();
+                        allresult.addAll(resultFallback.getAll());
+                        int number = currentResult.getNumFound()
+                                + resultFallback.getNumFound();
+
+                        // rebuilt the result
+                        PagedResult<Wikitty> tempPagedResult = new PagedResult<Wikitty>(
+                                currentCrit.getFirstIndex(), number,
+                                currentCrit.toString(),
+                                currentResult.getFacets(), allresult);
+                        // re set the result in the list
+                        result.set(i, tempPagedResult);
+                    }
+                }
+
+            }
+        }
+
+        return result;
+
     }
 
     public PagedResult<Wikitty> findAllByCriteria(Criteria criteria) {
-        return mainProxy.findAllByCriteria(criteria);
+
+        PagedResult<Wikitty> result = mainProxy.findAllByCriteria(criteria);
+
+        // PagedResult<String> result = mainProxy.findAllIdByCriteria(criteria);
+
+        int resultSizeExpected = criteria.getEndIndex()
+                - criteria.getFirstIndex();
+        if (isFallbackService() && result.size() < resultSizeExpected) {
+            // if result empty, just put the result of the fallback's request
+            // result
+
+            /*
+             * rebuild the criteria to search properly on the second service we
+             * search for wikitty not in the same position, but in the beginning
+             */
+            Criteria critFallback = Search.query(criteria).criteria();
+            critFallback.setFirstIndex(0);
+            critFallback.setEndIndex(criteria.getEndIndex()
+                    - criteria.getFirstIndex());
+
+            if (result.size() == 0) {
+
+                result = fallbackProxy.findAllByCriteria(critFallback);
+                // rebuild the result to match the expected criteria
+                result = new PagedResult<Wikitty>(criteria.getFirstIndex(),
+                        result.getNumFound(), criteria.toString(),
+                        result.getFacets(), result.getAll());
+            } else {
+
+                PagedResult<String> idFromMain = mainProxy
+                        .findAllIdByCriteria(criteria);
+
+                /*
+                 * we will search to complete the result with id from the
+                 * fallback service so we reduce the number of element requested
+                 * on the fallback service and we add a restriction on wikitty
+                 * id to exclude id already in the first part of the result
+                 * 
+                 * it not assume that wikitty id found does not exist on the
+                 * first part of a criteria, for example if first index where
+                 * 12, nothing assure that we found wikitty in the fall back
+                 * that aren't in the 11 first wikitty of the main service
+                 */
+                Criteria excluding = idNotInCriteriaConstructor(critFallback,
+                        idFromMain.getAll());
+
+                excluding.setEndIndex(resultSizeExpected - result.size());
+
+                PagedResult<Wikitty> resultFallback = fallbackProxy
+                        .findAllByCriteria(excluding);
+
+                List<Wikitty> allresult = result.getAll();
+                allresult.addAll(resultFallback.getAll());
+                int number = result.getNumFound()
+                        + resultFallback.getNumFound();
+
+                result = new PagedResult<Wikitty>(criteria.getFirstIndex(),
+                        number, criteria.toString(), result.getFacets(),
+                        allresult);
+            }
+        }
+
+        return result;
+
     }
 
     public PagedResult<Wikitty>[] findAllByCriteria(Criteria c1, Criteria c2,
             Criteria... otherCriteria) {
-        
+
         List<Criteria> criterias = new ArrayList<Criteria>();
         criterias.add(c1);
         criterias.add(c2);
         CollectionUtil.addAll(criterias, otherCriteria);
-        
+
         // deleguate to easily handle multicontext
-        return (PagedResult<Wikitty>[]) this.findAllByCriteria(criterias).toArray();
+        return (PagedResult<Wikitty>[]) this.findAllByCriteria(criterias)
+                .toArray();
     }
 
     public List<PagedResult<String>> findAllIdByCriteria(List<Criteria> criteria) {
-        return mainProxy.findAllIdByCriteria(criteria);
+
+        List<PagedResult<String>> result = mainProxy
+                .findAllIdByCriteria(criteria);
+
+        if (isFallbackService()) {
+
+            for (int i = 0; i < result.size(); i++) {
+
+                /*
+                 * get the curent criteria and corresponding result to check if
+                 * the expected number of result is match
+                 */
+                Criteria currentCrit = criteria.get(i);
+                PagedResult<String> currentResult = result.get(i);
+
+                int resultSizeExpected = currentCrit.getEndIndex()
+                        - currentCrit.getFirstIndex();
+                if (currentResult.size() < resultSizeExpected) {
+                    /*
+                     * if result empty, just put the result of the fallback's
+                     * requestresult
+                     */
+
+                    /*
+                     * rebuild the criteria to search properly on the second
+                     * service we search for wikitty not in the same position,
+                     * but in the beginning
+                     */
+                    Criteria critFallback = Search.query(currentCrit)
+                            .criteria();
+                    critFallback.setFirstIndex(0);
+                    critFallback.setEndIndex(currentCrit.getEndIndex()
+                            - currentCrit.getFirstIndex());
+
+                    if (result.size() == 0) {
+
+                        PagedResult<String> tempPagedResult = fallbackProxy
+                                .findAllIdByCriteria(critFallback);
+
+                        // rebuild the result to match the expected criteria
+                        tempPagedResult = new PagedResult<String>(
+                                currentCrit.getFirstIndex(),
+                                tempPagedResult.getNumFound(),
+                                currentCrit.toString(),
+                                tempPagedResult.getFacets(),
+                                tempPagedResult.getAll());
+
+                        result.set(i, tempPagedResult);
+                    } else {
+
+                        /*
+                         * we will search to complete the result with id from
+                         * the fallback service so we reduce the number of
+                         * element requested on the fallback service and we add
+                         * a restriction on wikitty id to exclude id already in
+                         * the first part of the result
+                         * 
+                         * it not assume that wikitty id found does not exist on
+                         * the first part of a criteria, for example if first
+                         * index where 12, nothing assure that we found wikitty
+                         * in the fall back that aren't in the 11 first wikitty
+                         * of the main service
+                         */
+                        Criteria excluding = idNotInCriteriaConstructor(
+                                critFallback, currentResult.getAll());
+
+                        excluding.setEndIndex(resultSizeExpected
+                                - result.size());
+
+                        PagedResult<String> resultFallback = fallbackProxy
+                                .findAllIdByCriteria(excluding);
+
+                        List<String> allresult = currentResult.getAll();
+                        allresult.addAll(resultFallback.getAll());
+                        int number = currentResult.getNumFound()
+                                + resultFallback.getNumFound();
+
+                        // rebuilt the result
+                        PagedResult<String> tempPagedResult = new PagedResult<String>(
+                                currentCrit.getFirstIndex(), number,
+                                currentCrit.toString(),
+                                currentResult.getFacets(), allresult);
+                        // re set the result in the list
+                        result.set(i, tempPagedResult);
+                    }
+                }
+
+            }
+        }
+
+        return result;
+
     }
 
     public PagedResult<String> findAllIdByCriteria(Criteria criteria) {
-        return mainProxy.findAllIdByCriteria(criteria);
+
+        PagedResult<String> result = mainProxy.findAllIdByCriteria(criteria);
+
+        int resultSizeExpected = criteria.getEndIndex()
+                - criteria.getFirstIndex();
+        if (isFallbackService() && result.size() < resultSizeExpected) {
+            // if result empty, just put the result of the fallback's request
+            // result
+
+            /*
+             * rebuild the criteria to search properly on the second service we
+             * search for wikitty not in the same position, but in the beginning
+             */
+            Criteria critFallback = Search.query(criteria).criteria();
+            critFallback.setFirstIndex(0);
+            critFallback.setEndIndex(criteria.getEndIndex()
+                    - criteria.getFirstIndex());
+
+            if (result.size() == 0) {
+
+                result = fallbackProxy.findAllIdByCriteria(critFallback);
+                // rebuild the result to match the expected criteria
+                result = new PagedResult<String>(criteria.getFirstIndex(),
+                        result.getNumFound(), criteria.toString(),
+                        result.getFacets(), result.getAll());
+            } else {
+
+                /*
+                 * we will search to complete the result with id from the
+                 * fallback service so we reduce the number of element requested
+                 * on the fallback service and we add a restriction on wikitty
+                 * id to exclude id already in the first part of the result
+                 * 
+                 * it not assume that wikitty id found does not exist on the
+                 * first part of a criteria, for example if first index where
+                 * 12, nothing assure that we found wikitty in the fall back
+                 * that aren't in the 11 first wikitty of the main service
+                 */
+                Criteria excluding = idNotInCriteriaConstructor(critFallback,
+                        result.getAll());
+
+                excluding.setEndIndex(resultSizeExpected - result.size());
+
+                PagedResult<String> resultFallback = fallbackProxy
+                        .findAllIdByCriteria(excluding);
+
+                List<String> allresult = result.getAll();
+                allresult.addAll(resultFallback.getAll());
+                int number = result.getNumFound()
+                        + resultFallback.getNumFound();
+
+                result = new PagedResult<String>(criteria.getFirstIndex(),
+                        number, criteria.toString(), result.getFacets(),
+                        allresult);
+            }
+        }
+
+        return result;
     }
 
     public PagedResult<String>[] findAllIdByCriteria(Criteria c1, Criteria c2,
             Criteria... otherCriteria) {
-        
-        
+
         List<Criteria> criterias = new ArrayList<Criteria>();
         criterias.add(c1);
         criterias.add(c2);
         CollectionUtil.addAll(criterias, otherCriteria);
-        
+
         // deleguate to easily handle multicontext
-        return (PagedResult<String>[]) this.findAllIdByCriteria( criterias).toArray();
+        return (PagedResult<String>[]) this.findAllIdByCriteria(criterias)
+                .toArray();
     }
 
     public List<String> findIdByCriteria(List<Criteria> criteria) {
 
         List<String> result = mainProxy.findIdByCriteria(criteria);
 
+        // TODO mfortun-2011-05-17 reform criteria
+
         if (isFallbackService()) {
+            
+            
+            
             if (result == null) {
                 result = fallbackProxy.findIdByCriteria(criteria);
             } else {
@@ -973,4 +1463,19 @@
         return result;
     }
 
+    protected Criteria idNotInCriteriaConstructor(Criteria origin,
+            List<String> toExclude) {
+        Criteria result = null;
+
+        Search search = Search.query(origin);
+
+        for (String id : toExclude) {
+            search.idneq(id);
+        }
+
+        result = search.criteria();
+
+        return result;
+    }
+
 }

    

[Wikitty-commits] r896 - trunk/wikitty-publication/src/main/java/org/nuiton/wikitty/publication

mfortun＠users.nuiton.org