UILockedNodePageList.java

/*
 * Copyright (C) 2003-2012 eXo Platform SAS.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package org.exoplatform.ecm.webui.component.admin.unlock;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Session;
import javax.jcr.query.Query;

import org.exoplatform.commons.exception.ExoMessageException;
import org.exoplatform.commons.utils.PageList;
import org.exoplatform.services.jcr.RepositoryService;
import org.exoplatform.services.jcr.core.ManageableRepository;
import org.exoplatform.services.jcr.impl.core.query.QueryImpl;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.exoplatform.services.wcm.core.NodeLocation;
import org.exoplatform.services.wcm.utils.WCMCoreUtils;

/**
 * Created by The eXo Platform SAS
 * Author : eXoPlatform
 *          exo@exoplatform.com
 * May 23, 2012  
 */
public class UILockedNodePageList extends PageList<NodeLocation> {
  
  private static final Log LOG  = ExoLogger.getLogger(UILockedNodePageList.class);

  private static final int QUERY_SIZE = 200;
  
  private String query;
  private Map<String, Integer> workspaceNodeMap;
  private String[] workspaceNameList;
  private List<NodeLocation> buffer;

  public UILockedNodePageList(int pageSize) {
    super(pageSize);
  }
  
  public UILockedNodePageList(String query, int pageSize, int currentPage) {
    super(pageSize);
    this.query = query;
    workspaceNameList = getWorkSpaceNameList();
    workspaceNodeMap = new HashMap<String, Integer>();
    buffer = this.getData(0, Math.max(QUERY_SIZE, (currentPage + 10) * pageSize));
    this.setAvailablePage(buffer.size());
  }

  /**
   * gets list of workspace name in repository
   * @return
   */
  private String[] getWorkSpaceNameList() {
    RepositoryService repoService = WCMCoreUtils.getService(RepositoryService.class);
    String[] ret = new String[]{};
    try {
      ret = repoService.getCurrentRepository().getWorkspaceNames();
    } catch (Exception e) {
      if (LOG.isErrorEnabled()) {
        LOG.error(e);
      }
    }
    return ret;
  }

  @Override
  protected void populateCurrentPage(int page) throws Exception {
    currentListPage_ = buffer.subList(getFrom(), getTo());
  }

  @Override
  protected void checkAndSetPage(int page) throws Exception
  {
    if (page + 10 > availablePage_) {
      buffer.addAll(getData(buffer.size(), (page + 10) * getPageSize() - availablePage_ + QUERY_SIZE));
      setAvailablePage(buffer.size());
    }
    if (page < 1 || page > availablePage_) {
      Object[] args = {Integer.toString(page), Integer.toString(availablePage_)};
      throw new ExoMessageException("PageList.page-out-of-range", args);
    }
    currentPage_ = page;
  }

  private List<NodeLocation> getData(int from, int count) {
//    int count = this.getTo() - this.getFrom();//number of node need to query
//    int delta = this.getFrom();
    int delta = from;
    List<NodeLocation> ret = new ArrayList<NodeLocation>();//data will be filled to this list
    //iterate through all workspaces
    for (String workspace : workspaceNameList) {
      Integer lockedNodeCount = workspaceNodeMap.get(workspace);
      if (lockedNodeCount != null) {
        if (lockedNodeCount <= delta) {//(1.1)
          delta -= lockedNodeCount;
        } else if (delta < lockedNodeCount && lockedNodeCount <= delta + count) { //(1.2)
          ret.addAll(queryNodes(workspace, delta, lockedNodeCount - delta));
          delta = 0;
          count -= (lockedNodeCount - delta);
        } else if (delta + count < lockedNodeCount) {
          ret = queryNodes(workspace, delta, count);
          break;//delta = 0; count = 0;
        }
      } else { //lockedNodeCount==null
        List<NodeLocation> queryNodeData = queryNodes(workspace, delta, count);
        if (queryNodeData.size() == 0) {//(2.1), as (1.1) : lockedNodeCount <= delta
          lockedNodeCount = queryNodes(workspace, 0, count).size();
          delta -= lockedNodeCount;
          workspaceNodeMap.put(workspace, lockedNodeCount);
        } else if (0 < queryNodeData.size() && queryNodeData.size() < count) {
          //(2.2), as (1.2) : delta < lockedNodeCount && lockedNodeCount <= delta + count
          ret.addAll(queryNodeData);
          delta = 0;
          count -= queryNodeData.size();
        } else if (queryNodeData.size() == count) {//(2.3), as (1.3) : delta + count < lockedNodeCount
          ret = queryNodeData;
          break;//delta = 0; count = 0;
        }
      }
      if (count == 0) {
        break;
      }
    }
    return ret;
  }

  /**
   * gets all nodes by this.query, in given workspace, from offset to (offset + limit)
   * @throws Exception
   */
  private List<NodeLocation> queryNodes(String workspace, int offset, int limit) {
    List<NodeLocation> ret = new ArrayList<NodeLocation>();
    try {
      ManageableRepository repo = WCMCoreUtils.getService(RepositoryService.class).getCurrentRepository();
      Session session = WCMCoreUtils.getSystemSessionProvider().getSession(workspace, 
                                                                           repo);
      Query query = session.getWorkspace().getQueryManager().createQuery(this.query, Query.SQL);
      ((QueryImpl)query).setOffset(offset);
      ((QueryImpl)query).setLimit(limit);
      
      for (NodeIterator iter = query.execute().getNodes(); iter.hasNext();) {
        Node node = iter.nextNode();
        if (node.isLocked()) {
          ret.add(NodeLocation.getNodeLocationByNode(node));
        }
      }
    } catch (Exception e) {
      if (LOG.isErrorEnabled()) {
        LOG.error(e);
      }
    }
    
    return ret;
  }
  @Override
  public List getAll() throws Exception {
    return buffer;
  }
  
}