ResourceBusinessImpl

/**
 * Copyright By Grandsoft Company Limited.
 * 2012-3-2 下午08:47:53
 */
package gboat2.web.business.impl;

import gboat2.base.core.dao.Page;
import gboat2.base.core.dao.PageBean;
import gboat2.base.core.dao.QuerySupport;
import gboat2.base.core.model.Module;
import gboat2.base.core.service.BaseService;
import gboat2.base.core.service.IModuleService;
import gboat2.web.business.IResourceBusiness;
import gboat2.web.model.Resource;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 *
 * @author tanxw
 * @since jdk1.6
 * @date 2012-3-2
 *
 */
@Transactional
@Service
public class ResourceBusinessImpl extends BaseService implements IResourceBusiness {

	@Autowired
	private IModuleService moduleService;

	/**
	 * 移动节点
	 * @param movedId	被移动的节点
	 * @param targetParentId	新的父节点
	 * @param targetIndex	如果是排序，被插入的节点
	 * @return true/false
	 */
	public boolean moveResource(String movedId, String targetParentId, int targetIndex) {
		if (StringUtils.isEmpty(movedId) || StringUtils.isEmpty(targetParentId)) {
			return false;
		}

		Resource moved = (Resource) get(Resource.class, movedId);
		moved.setParentId(targetParentId);
		double dispOrder = this.computeMovedResNewDispOrder(moved, targetParentId, targetIndex);
		moved.setDispOrder(dispOrder);

		return this.update(moved);
	}

	@Override
	public boolean deleteResource(Resource resource) {
		baseDAO.delete(resource);

		//删除所有与其关联的表
		Map<String, Object> params = new HashMap<String, Object>();
		params.put("resId", resource.getResId());
		baseDAO.deleteByQuery("delete from Authority where resId=:resId", params);
		baseDAO.deleteByQuery("delete from Operation where resId=:resId", params);
		baseDAO.deleteByQuery("delete from Shortcut where resId=:resId", params);
		baseDAO.deleteByQuery("delete from DataLevelAuthority where resId=:resId", params);

		//删除模块后，其子模块的父节点调整为删除节点的父节点；
		String parentId = resource.getParentId();
		double maxDispOder = this.getMaxOrderWithParent(parentId);
		List<Resource> children = getChildrenByParentId(resource.getResId());
		if (null != children) {
			for (Resource child : children) {
				child.setParentId(parentId);
				maxDispOder += 1;
				child.setDispOrder(maxDispOder);
				this.update(child);
			}
		}

		return true;
	}

	/**
	 * 计算被移动的节点的新排序值
	 * @param targetParentId 被移动的节点
	 * @param targetIndex 新节点在其父节点下的目标排序索引值
	 * @return 计算出的新的序号
	 */
	private double computeMovedResNewDispOrder(Resource moved, String targetParentId, int targetIndex) {
		List<Resource> children = this.getChildrenByParentId(targetParentId, moved.getSystemId());
		if (children.size() == 0) { //无子节点，则新添加的节点作为第一个子节点
			return 100f;
		}

		if (0 >= targetIndex) { //排在第一个
			return children.get(0).getDispOrder() / 2;
		}

		if (children.size() < targetIndex + 1) { //排在最后一个
			return children.get(children.size() - 1).getDispOrder() + 1;
		}

		//排在中间的情况
		double preDispOrder = children.get(targetIndex - 1).getDispOrder();
		double nextDispOrder = children.get(targetIndex).getDispOrder();

		return (preDispOrder + nextDispOrder) / 2;
	}

	@Override
	public double getMaxOrderWithParent(String parentId) {
		if (StringUtils.isEmpty(parentId)) {
			parentId = "0";
		}
		float order = 0.0f;
		String[][] params = { { Resource.class.getName() }, { "_parentId", parentId }, { QuerySupport.PARAM_ORDERBY, "dispOrder desc" },
		        { QuerySupport.PARAM_PAGESIZE, "1" } };
		List<Resource> mods = (List<Resource>) this.baseDAO.getPage(params).getResult();
		if (mods.size() > 0) {
			order = (float) mods.get(0).getDispOrder();
		}
		return order;
	}

	public Resource getResourcesTree(String systemId) {
		Resource root = new Resource();
		root.setResName("root");
		root.setResId("0");
		root.setLeaf(false);
		List<Resource> tops = this.getTopLevelResources(systemId);
		if (tops != null) {
			for (Resource res : tops) {
				res.setChildren(this.getChildrenRecursively(res));
				res.setLeaf(this.isLeaf(res));
			}
		}
		root.setChildren(tops);
		return root;
	}

	private boolean isLeaf(Resource res) {
		if ("0".equals(res.getSingleton())) {//如果是非单例节点，则不能视为叶子节点
			return false;
		}
		return null == res.getChildren() || res.getChildren().size() == 0;
	}

	private List<Resource> getChildrenRecursively(Resource parent) {
		List<Resource> list = this.getChildrenByParentId(parent.getResId());
		if (null != list) {
			for (Resource res : list) {
				res.setChildren(this.getChildrenRecursively(res));
				res.setLeaf(this.isLeaf(res));
			}
		}
		return list;
	}

	public List<Resource> getChildrenByParentId(String parentId) {
		String[][] params = new String[][] { { Resource.class.getName() }, { "_parentId", parentId }, { QuerySupport.PARAM_ORDERBY, "dispOrder" } };
		return (List<Resource>) baseDAO.queryList(params);
	}

	public List<Resource> getChildrenByParentId(String parentId, String systemId) {
		String[][] params = new String[][] { { Resource.class.getName() }, { "_parentId", parentId }, { "_systemId", systemId },
		        { QuerySupport.PARAM_ORDERBY, "dispOrder" } };
		return (List<Resource>) baseDAO.queryList(params);
	}

	public List<Resource> getTopLevelResources(String systemId) {
		if (StringUtils.isEmpty(systemId)) { //系统id不存在时直接返回空
			return null;
		}
		String[][] params = new String[][] { { Resource.class.getName() }, { "_parentId", "0" }, { "_systemId", systemId },
		        { QuerySupport.PARAM_ORDERBY, "dispOrder" } };
		return (List<Resource>) baseDAO.queryList(params);
	}

	public Resource getPreviousSibling(Resource res) {
		Resource brother = null;
		Map<String, Object> params = new HashMap<String, Object>();
		params.put(QuerySupport.PARAM_TABLENAME, Resource.class);
		params.put(QuerySupport.PARAM_PAGESIZE, "1");
		params.put(QuerySupport.PARAM_ORDERBY, "dispOrder desc");
		params.put("_parentId", res.getParentId());
		params.put("_dispOrder_lt", res.getDispOrder());
		List<Resource> mods = (List<Resource>) baseDAO.getPage(params).getResult();
		if (mods.size() > 0) {
			brother = mods.get(0);
		}
		return brother;
	}

	@Override
	public Page<Resource> getAnnotatedResources(String queryString, String page, String pagesize) {
		List<Module> modules;
		int currentPage = StringUtils.isEmpty(page) ? 1 : Integer.parseInt(page.trim());
		int size = StringUtils.isEmpty(pagesize) ? QuerySupport.PAGESIZE_DEFAULT : Integer.parseInt(pagesize.trim());

		if (StringUtils.isEmpty(queryString)) {
			modules = moduleService.getModules();
		} else {
			modules = moduleService.getModules(queryString);
		}

		//分页信息
		PageBean pageBean = new PageBean();
		pageBean.setCount(modules.size());
		pageBean.setPage(currentPage);
		pageBean.setPageSize(size);

		int fromIndex = (currentPage - 1) * size;
		int toIndex = fromIndex + size;
		toIndex = modules.size() < toIndex ? modules.size() : fromIndex + size; //防止边界溢出
		modules = modules.subList(fromIndex, toIndex); //根据分页截取

		List<Resource> results = new ArrayList<Resource>();
		//转换适配
		for (Module module : modules) {
			Resource res = new Resource();
			res.setResName(module.getModuleName());
			res.setModuleName(module.getModuleName());
			res.setResUrl(module.getEntryUri());
			res.setBundle(module.getBundleName());
			res.setActionClass(module.getClassName());
			res.setResCode(getAvailbleResCode(module));
			results.add(res);
		}

		return new Page<Resource>(results, pageBean);
	}

	private String getAvailbleResCode(Module module) {
		String code = module.getCode();
		if (StringUtils.isEmpty(code)) {
			code = module.getClassName();
			int n = code.lastIndexOf('.');
			if (n > 0) {
				code = code.substring(n + 1);
			}
			if (code.endsWith("Action")) {
				code = code.substring(0, code.length() - 6);
			}
		}

		int i = 1;
		String tryCode = code;
		while (getResourceByCode(tryCode) != null) {
			tryCode = code + i;
			i++;
		}
		return tryCode;
	}

	@Override
	public List<Resource> getAllResource() {
		String[][] params = new String[][] { { Resource.class.getName() } };
		List<Resource> list = (List<Resource>) super.query(params);
		return list;
	}

	@Override
	public Resource getResourceByResname(String resName) {
		Resource ret = null;
		String[][] params = { { Resource.class.getName() }, { "_resName", resName } };
		List<Resource> list = (List<Resource>) super.query(params);
		if (null != list && list.size() > 0) {
			ret = list.get(0);
		}
		return ret;
	}

	@Override
	public List<Resource> getResourceByUrl(String resUrl){
		String[][] params = {
				{Resource.class.getName()},
				{"_resUrl", resUrl}
		};
		return (List<Resource>)super.query(params);
	}

	@Override
	public Resource getResourceByCode(String resCode) {
		Map<String, Object> params = new HashMap<String, Object>();
		params.put(QuerySupport.PARAM_TABLENAME, Resource.class);
		params.put("_resCode", resCode);
		List<Resource> resourceList = (List<Resource>) baseDAO.queryList(params);
		if (resourceList.size() > 0) {
			return resourceList.get(0);
		}
		return null;
	}

	private Resource cloneResource(Resource res) {
		Resource newRes = new Resource();
		newRes.setResId(null);
		newRes.setActionClass(res.getActionClass());
		newRes.setBundle(res.getBundle());
		newRes.setDispOrder(res.getDispOrder());
		newRes.setLeaf(res.getLeaf());
		newRes.setModuleName(res.getModuleName());
		newRes.setResName(res.getResName());
		newRes.setResUrl(res.getResUrl());
		newRes.setSingleton(res.getSingleton());
		newRes.setStatus(res.getStatus());
		newRes.setSystemId(res.getSystemId());
		newRes.setType(res.getType());
		newRes.setResCode(res.getResCode() + 1);
		return newRes;
	}

	@Override
	public boolean copyResource(String copyedId, String targetParentId) {
		if (StringUtils.isEmpty(copyedId) || StringUtils.isEmpty(targetParentId)) {
			return false;
		}

		Resource copyed = (Resource) get(Resource.class, copyedId);
		List<Resource> children = getChildrenRecursively(copyed);

		//复制最顶层的节点
		Resource root = cloneResource(copyed);
		double order = getMaxOrderWithParent(targetParentId) + 1;
		root.setDispOrder(order);
		root.setParentId(targetParentId);
		save(root);

		//递归复制子节点
		if (null != children) {
			for (Resource item : children) {
				cloneAndSaveResourceRecursively(item, root.getResId());
			}
		}

		return true;
	}

	/**
	 * @param target 复制的目标节点
	 * @param mountToParent 要挂载到的父节点
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	private void cloneAndSaveResourceRecursively(Resource target, String mountToParent) {
		Resource newRoot = cloneResource(target);
		newRoot.setParentId(mountToParent);
		save(newRoot);

		List<Resource> children = target.getChildren();
		if (null != children) {
			for (Resource item : children) {
				cloneAndSaveResourceRecursively(item, newRoot.getResId());
			}
		}
	}
}