NodeManagerDBImpl.java

/*
 * Copyright 2005-2008 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.openuap.cms.node.manager.impl;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import org.openuap.base.util.StringUtil;
import org.openuap.cms.cm.dao.ContentTableDao;
import org.openuap.cms.cm.model.ContentTable;
import org.openuap.cms.config.CMSConfig;
import org.openuap.cms.node.cache.NodeCache;
import org.openuap.cms.node.dao.NodeDao;
import org.openuap.cms.node.event.NodeEvent;
import org.openuap.cms.node.manager.NodeManager;
import org.openuap.cms.node.manager.NodeQuickQuery;
import org.openuap.cms.node.model.Node;
import org.openuap.cms.node.model.Nodes;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;

import com.thoughtworks.xstream.XStream;

/**
 * <p>
 * 结点管理实现.
 * </p>
 * 
 * 
 * <p>
 * $Id: NodeManagerDBImpl.java 4005 2011-01-11 17:59:13Z orangeforjava $
 * </p>
 *
 * @author Joseph
 * @version 1.0
 */
public class NodeManagerDBImpl implements NodeManager, ApplicationListener {

	private static final String INIT_DATA_FILE_NAME = "nodeData.xml";

	private NodeDao nodeDao;

	private ContentTableDao contentTableDao;

	public NodeManagerDBImpl() {
	}

	public void setNodeDao(NodeDao nodeDao) {
		this.nodeDao = nodeDao;
	}

	public void setContentTableDao(ContentTableDao contentTableDao) {
		this.contentTableDao = contentTableDao;
	}

	public Long addNode(Node node) {
		return nodeDao.addNode(node);
	}

	public void saveNode(Node node) {
		nodeDao.saveNode(node);
	}

	public void deleteNode(Long nodeId) {
		nodeDao.deleteNode(nodeId);
	}

	public Node getNodeById(Long nodeId) {
		return nodeDao.getNodeById(nodeId);
	}

	public Node getNodeByGuid(String guid) {
		return nodeDao.getNodeByGuid(guid);
	}

	public List<Node> getNodes(Long parentId) {
		return nodeDao.getNodes(parentId);
	}

	public List<Node> getNodes(Long parentId, Long rootId) {
		return nodeDao.getNodes(parentId, rootId);
	}

	public List<Node> getNodes(String hql, Object[] args) {
		return nodeDao.getNodes(hql, args);
	}

	public long getAllNodeCount() {
		return nodeDao.getAllNodeCount();
	}

	public long getNodeCount(Long parentId) {
		return nodeDao.getNodeCount(parentId);
	}
	
	public List<Node> getNodes(Long parentId, Long rootId, Integer disabled) {
		return nodeDao.getNodes(parentId, rootId, disabled);
	}

	public long getNodeCount(Long parentId, Long rootId) {
		return nodeDao.getNodeCount(parentId, rootId);
	}

	public long getNodeCount(Long parentId, Long rootId, Integer disabled) {
		return nodeDao.getNodeCount(parentId, rootId, disabled);
	}

	public List<Node> getNodes(Long parentId, Long rootId, Integer disabled,
			Integer nodeType) {
		return nodeDao.getNodes(parentId, rootId, disabled, nodeType);
	}

	public long getNodeCount(Long parentId, Long rootId, Integer disabled,
			Integer nodeType) {
		return nodeDao.getNodeCount(parentId, rootId, disabled, nodeType);
	}

	public String getNodeFullPath(Long nodeId, String delimiter) {
		Node node = this.getNode(nodeId);
		if (node != null) {
			Long pid = node.getParentId();
			if (pid == Long.valueOf("0")) {
				return node.getName();
			} else {
				return getNodeFullPath(pid, delimiter) + delimiter
						+ node.getName();
			}
		}
		if (nodeId.intValue() == 0) {
			return "站点根";
		}
		return "";
	}

	public void recycleNode(Long nodeId, boolean containChild) {
		nodeDao.recycleNode(nodeId, containChild);
	}

	public void unRecycleNode(Long nodeId, boolean containChild) {
		nodeDao.unRecycleNode(nodeId, containChild);
	}

	public void deleteNode(Long nodeId, boolean containChild) {
		nodeDao.deleteNode(nodeId, containChild);
	}

	public boolean getContainTableIdNodes(Long nodeId, Long tableId,
			List nodeIds, List containNodeIds) {
		NodeQuickQuery query=new NodeQuickQuery(getAllNodesFromCache());
		return query.getContainTableIdNodes(nodeId, tableId, nodeIds,
				containNodeIds);
	}

	public List<Node> getRecycleBinNodes() {
		return nodeDao.getRecycleBinNodes();
	}

	public void deleteRecycleBinNodes() {
		nodeDao.deleteRecycleBinNodes();
	}

	public boolean getIsChildNode(Long parentId, Long nodeId) {
		return nodeDao.getIsChildNode(parentId, nodeId);
	}

	public boolean initData() {
		XStream xstream = new XStream();
		xstream.alias("node", Node.class);
		xstream.alias("data", Nodes.class);
		//
		try {
			String dataPath = CMSConfig.getInstance().getInitDataPath();
			String fileName = dataPath + "/" + INIT_DATA_FILE_NAME;
			fileName = StringUtil.normalizePath(fileName);
			File file = new File(fileName);
			InputStreamReader in = new InputStreamReader(new FileInputStream(
					file), "UTF-8");
			Nodes nodes = (Nodes) xstream.fromXML(in);
			if (nodes != null) {
				List nodeList = nodes.getNodes();
				if (nodeList != null) {
					for (int i = 0; i < nodeList.size(); i++) {
						Node node = (Node) nodeList.get(i);
						Node node_old = this.getNodeByGuid(node.getNodeGuid());
						String tableName = node.getTableName();
						Long tid = null;
						Long nid = null;
						if (tableName != null) {
							ContentTable ct = contentTableDao
									.getCTByTableName(tableName);
							if (ct != null) {
								tid = ct.getTableId();
							}
						}
						if (tid == null) {
							tid = new Long(0);
						}
						if (node_old != null) {
							nid = node_old.getNodeId();
							node.setTableId(tid);
							this.saveNode(node);
						} else {
							node.setTableId(tid);
							nid = this.addNode(node);
							node.setNodeId(nid);
						}
					}
				}
			}
			return true;
		} catch (Exception ex) {
			ex.printStackTrace();
			return false;
		}

	}

	public List getAllChildNodeId(Long parentNodeId) {
		// 从缓存中获取必要的信息
		List ids = new ArrayList();
		ids.add(parentNodeId);
		getChildNodeIds(parentNodeId, ids);
		return ids;
	}

	private void getChildNodeIds(Long parentNodeId, List<Long> idList) {
		List ids = NodeCache.getChildNodeIds(parentNodeId);
		//
		if (ids != null) {
			for (int i = 0; i < ids.size(); i++) {
				Long id = (Long) ids.get(i);
				idList.add(id);
				getChildNodeIds(id, idList);
			}
		}

	}

	public List<Node> getNavNodes(Long leafNodeId, Long topNodeId) {
		Stack<Node> navNodes = new Stack<Node>();
		getNavNodes(leafNodeId, topNodeId, navNodes);
		List<Node> rsNodes = new ArrayList<Node>();
		Node node = null;
		while (!navNodes.empty() && ((node = navNodes.pop()) != null)) {
			rsNodes.add(node);
		}
		return rsNodes;
	}

	public List<Node> getNavNodes(Node leafNode, Long topNodeId) {
		//
		if (leafNode != null) {
			long pid = leafNode.getParentId();
			Stack<Node> navNodes = new Stack<Node>();
			if (pid > 0) {
				getNavNodes(pid, topNodeId, navNodes);
			}
			List<Node> rsNodes = new ArrayList<Node>();
			Node node = null;
			while (!navNodes.empty() && ((node = navNodes.pop()) != null)) {
				rsNodes.add(node);
			}
			rsNodes.add(leafNode);
			return rsNodes;
		}
		return null;
	}

	private void getNavNodes(Long leafNodeId, Long topNodeId,
			Stack<Node> navNodes) {
		Node node = getNode(leafNodeId);
		if (node != null) {
			Long pid = node.getParentId();
			navNodes.push(node);
			if (pid > 0 && !pid.equals(topNodeId)) {
				getNavNodes(pid, topNodeId, navNodes);
			}
		}
	}

	/**
	 * 从缓存中获得Node对象
	 */
	public Node getNode(Long nodeId) {
		Node node = NodeCache.getNode(nodeId);
		return node;
	}

	public List getAllNodes() {
		return nodeDao.getAllNodes();
	}

	public List<Node> getRootNodes() {
		return null;
	}

	public List<Node> getAllNodesFromCache() {
		return NodeCache.getAllNodes();
	}

	public List getChildNodes(long parentId) {
		return NodeCache.getChildNodes(parentId);
	}

	public int getChildNodesCount(long parentId) {
		return getChildNodes(parentId).size();
	}

	public Node getNodeByGuidFromCache(String guid) {
		return NodeCache.getNodeByGuid(guid);
	}

	public void onApplicationEvent(ApplicationEvent event) {

		if (event instanceof NodeEvent) {
			NodeEvent nodeEvent = (NodeEvent) event;
			String type = nodeEvent.getEventType();
			if (type.equals(NodeEvent.NODE_CREATED)
					|| type.equals(NodeEvent.NODE_UPDATED)
					|| type.equals(NodeEvent.NODE_DELETED)) {
				//监听结点变更事件来更新缓存
				NodeCache.clear();
			}
		}
	}

	public void updateNodeContentCount(Long nodeId, String type, long count) {
		nodeDao.updateNodeContentCount(nodeId, type, count);
	}

	
}