aggregatedlayoutmanager.java

uPortal是开放源码的Portal门户产品

           String overParam = childNode.getAttribute("override");

           if ( paramName != null && paramValue != null ) {
            channelDesc.setParameterValue(paramName, paramValue);
            channelDesc.setParameterOverride(paramName, "yes".equalsIgnoreCase(overParam)?true:false);
           }
          } else if ( IAggregatedLayout.RESTRICTION.equals(nodeName) ) {
             String restrPath = childNode.getAttribute("path");
             String restrValue = childNode.getAttribute("value");
             String restrType = childNode.getAttribute("type");

             if ( restrValue != null ) {
              IUserLayoutRestriction restriction = UserLayoutRestrictionFactory.createRestriction(CommonUtils.parseInt(restrType),restrValue,restrPath);
              nodeDesc.addRestriction(restriction);
             }
            }
        }


      if ( channelDesc != null ) {
        channelDesc.setChannelPublishId(node.getAttribute("chanID"));
        channelDesc.setChannelTypeId(node.getAttribute("typeID"));
        channelDesc.setClassName(node.getAttribute("class"));
        channelDesc.setDescription(node.getAttribute("description"));
        channelDesc.setEditable(CommonUtils.strToBool(node.getAttribute("editable")));
        channelDesc.setHasAbout(CommonUtils.strToBool(node.getAttribute("hasAbout")));
        channelDesc.setHasHelp(CommonUtils.strToBool(node.getAttribute("hasHelp")));
        channelDesc.setIsSecure(CommonUtils.strToBool(node.getAttribute("secure")));
        channelDesc.setFunctionalName(node.getAttribute("fname"));
        channelDesc.setTimeout(Long.parseLong(node.getAttribute("timeout")));
        channelDesc.setTitle(node.getAttribute("title"));

          // Adding to the layout
          layoutNode = new ALChannel(channelDesc);
      } else {
          layoutNode = new ALFolder((IALFolderDescription)nodeDesc);
        }
          // Setting priority value
          layoutNode.setPriority(CommonUtils.parseInt(node.getAttribute("priority"),0));

          ALFolder parentFolder = getLayoutFolder(parentNodeId);
          // Binding the current node to the parent child list and parentNodeId to the current node
          if ( parentFolder != null ) {
           //parentFolder.addChildNode(nodeDesc.getId());
           layoutNode.setParentNodeId(parentNodeId);
          }


          Element nextNode = (Element) node.getNextSibling();
          Element prevNode = (Element) node.getPreviousSibling();

          if ( nextNode != null && isNodeFolderOrChannel(nextNode) )
             layoutNode.setNextNodeId(nextNode.getAttribute("ID"));
          if ( prevNode != null && isNodeFolderOrChannel(prevNode) )
             layoutNode.setPreviousNodeId(prevNode.getAttribute("ID") );

          // Setting the first child node ID
          if ( layoutNode.getNodeType() == IUserLayoutNodeDescription.FOLDER ) {
          	Node firstChild = node.getFirstChild();
          	if ( firstChild != null ) {
             String id = ((Element)firstChild).getAttribute("ID");
             if ( id != null && id.length() > 0 )
              ((ALFolder)layoutNode).setFirstChildNodeId(id);
          	} 
          }

          // Putting the LayoutNode object into the layout
          layoutData.put(nodeDesc.getId(), layoutNode);

          // Recurrence for all children
          for ( int i = 0; i < childNodes.getLength() && (layoutNode.getNodeType()==IUserLayoutNodeDescription.FOLDER); i++ ) {
            Element childNode = (Element) childNodes.item(i);
            if ( isNodeFolderOrChannel ( childNode ) )
             setUserLayoutDOM ( childNode, nodeDesc.getId(), layoutData );
          }

    }

    public void setUserLayoutDOM( Document domLayout ) throws PortalException {
      Hashtable layoutData = new Hashtable();
      String rootId = getRootFolderId();
      Element rootNode = (Element) domLayout.getDocumentElement().getFirstChild();
      ALFolder rootFolder = new ALFolder((IALFolderDescription)ALNode.createUserLayoutNodeDescription(rootNode));
      rootFolder.setFirstChildNodeId(((Element)rootNode.getFirstChild()).getAttribute("ID"));
      layoutData.put(rootId,rootFolder);
      NodeList childNodes = rootNode.getChildNodes();
      layout.setLayoutData(layoutData);
      for ( int i = 0; i < childNodes.getLength(); i++ )
       setUserLayoutDOM ( childNodes.item(i), rootId, layoutData );
      updateCacheKey();
    }

    private boolean isNodeFolderOrChannel ( Element node ) {
      String nodeName = node.getNodeName();
      return ( IAggregatedLayout.FOLDER.equals(nodeName) || IAggregatedLayout.CHANNEL.equals(nodeName) );
    }

    public void setLayoutStore(IUserLayoutStore layoutStore ) {
      this.layoutStore = (AggregatedUserLayoutStore) layoutStore;
    }

    public void loadUserLayout() throws PortalException {
        try {
            if ( layoutStore != null ) {
                fragmentId = null;
                layout = (AggregatedLayout) layoutStore.getAggregatedLayout(person,userProfile);
                layout.setLayoutManager(this);
                // Setting the first child node id for the root node to NULL if it does not exist in the layout
                ALFolder rootFolder = getLayoutFolder(getRootFolderId());
                String firstChildId = rootFolder.getFirstChildNodeId();
                if ( firstChildId != null && getLayoutNode(firstChildId) == null )
                    rootFolder.setFirstChildNodeId(null);
                // Moving the wrong pushed fragments to the lost folder
                moveWrongFragmentsToLostFolder();
                // Checking restrictions and move "wrong" nodes to the lost folder
                moveWrongNodesToLostFolder();
                // Inform layout listeners
                for(Iterator i = listeners.iterator(); i.hasNext();) {
                    LayoutEventListener lel = (LayoutEventListener)i.next();
                    lel.layoutLoaded();
                }
                updateCacheKey();
            }
        } catch ( Exception e ) {
            log.error("Exception loading user layout", e);
            throw new PortalException("Exception loading user layout: " + e.getMessage(), e);
        }
    }
    
	/**
		* Returns true if any fragment is currently loaded into the layout manager, 
		* false - otherwise
		* @return a boolean value
		* @exception PortalException if an error occurs
		*/
	public boolean isFragmentLoaded() throws PortalException {
   	 return isLayoutFragment();
    }

    public void saveUserLayout() throws PortalException {
      try {
        if ( !isLayoutFragment() ) {
          layoutStore.setAggregatedLayout(person,userProfile,layout);
          // Inform layout listeners
          for(Iterator i = listeners.iterator(); i.hasNext();) {
              LayoutEventListener lel = (LayoutEventListener)i.next();
              lel.layoutSaved();
          }
        } else {
          saveFragment();
        }
          
         updateCacheKey();
      } catch ( Exception e ) {
        throw new PortalException(e.getMessage());
      }
    }
      
    public void saveFragment ( ILayoutFragment fragment ) throws PortalException {
       layoutStore.setFragment(person,fragment);	
    }
    
   
	public void deleteFragment ( String fragmentId ) throws PortalException {
	   layoutStore.deleteFragment(person,fragmentId);	
	}


	/**
					 * Returns the list of Ids of the fragments that the user can subscribe to
					 * @return <code>Collection</code> a set of the fragment IDs
					 * @exception PortalException if an error occurs
					 */
	public Collection getSubscribableFragments() throws PortalException {
	  return layoutStore.getSubscribableFragments(person);	
	}

	public Collection getFragments () throws PortalException {
	   return layoutStore.getFragments(person).keySet();	
	}
	
	/**
				* Returns the user group keys which the fragment is published to
				* @param fragmentId a <code>String</code> value
				* @return a <code>Collection</code> object containing the group keys
				* @exception PortalException if an error occurs
				*/
	public Collection getPublishGroups (String fragmentId ) throws PortalException {
	  return layoutStore.getPublishGroups(person,fragmentId);	
	}
	
	/**
					* Persists the user groups which the fragment is published to
					* @param groups an array of <code>IGroupMember</code> objects
					* @param fragmentId a <code>String</code> value
					* @exception PortalException if an error occurs
					*/
    public void setPublishGroups ( IGroupMember[] groups, String fragmentId ) throws PortalException {
		  layoutStore.setPublishGroups(groups,person,fragmentId);	
	}
	
	public ILayoutFragment getFragment ( String fragmentId ) throws PortalException {
	   return layoutStore.getFragment(person,fragmentId);	
    }
    
	public String createFragment( String fragmentName, String fragmentDesc, String fragmentRootName ) throws PortalException {
		
	  try {
	  	
			 // Creating an empty layout with a root folder
			 String newFragmentId = layoutStore.getNextFragmentId();
			 ALFragment fragment = new ALFragment (newFragmentId,this);
			 
			 // Creating the layout root node
			 ALFolder rootFolder = ALFolder.createRootFolder();
			
			 // Creating the fragment root node
		     ALFolderDescription nodeDesc = (ALFolderDescription) createNodeDescription(IUserLayoutNodeDescription.FOLDER);
		     
		     // Setting the root fragment ID = 1
		     nodeDesc.setId("1");
			 nodeDesc.setName(fragmentRootName);
			 nodeDesc.setFolderType(IUserLayoutFolderDescription.REGULAR_TYPE);
			 // Setting the fragment ID
			 nodeDesc.setFragmentId(newFragmentId);
			 
			 //Creating a new folder with the folder description
			 ALFolder fragmentRoot = new ALFolder(nodeDesc);
			 
			 //Updating the DB and getting the node ID for the new node
			 //fragmentRoot = layoutStore.addUserLayoutNode(person,userProfile,fragmentRoot);
			 
			 // Setting the link between the layout root and the fragment root
			 fragmentRoot.setParentNodeId(rootFolder.getId());
			 rootFolder.setFirstChildNodeId(fragmentRoot.getId());
			 
			 // Fill the hashtable with the new nodes
		     Hashtable layoutData = new Hashtable();
			 layoutData.put(rootFolder.getId(),rootFolder);
		     layoutData.put(fragmentRoot.getId(),fragmentRoot);
			 			 
			 // Setting the layout data		 
			 fragment.setLayoutData(layoutData);
			 fragment.setName(fragmentName);
			 fragment.setDescription(fragmentDesc);
			 
			 // Setting the fragment in the database
			 layoutStore.setFragment(person,fragment);
		
		     // Getting the list of the fragments	
			 /*fragments = (Hashtable) layoutStore.getFragments(person);
		     if ( fragments != null && fragments.size() > 0 ) 
			  fragment.setFragments(fragments); */ 
			
			 updateCacheKey();
			 
			 // Return a new fragment ID
			 return newFragmentId;
			 
		  } catch ( Exception e ) {
		  	e.printStackTrace();
			throw new PortalException(e.getMessage());
		  }
	}


    public void loadFragment( String fragmentId ) throws PortalException {
      try {
      
        layout = (ALFragment) layoutStore.getFragment(person,fragmentId);
        layout.setLayoutManager(this);
        /*fragments = (Hashtable) layoutStore.getFragments(person);
		if ( fragments != null && fragments.size() > 0 ) 
		  layout.setFragments(fragments);*/
        this.fragmentId = fragmentId;
        // Checking restrictions and move "wrong" nodes to the lost folder
        //moveWrongNodesToLostFolder();
        updateCacheKey();
      } catch ( Exception e ) {
        throw new PortalException(e.getMessage());
      }
    }

    public void saveFragment() throws PortalException {
      try {
       if ( isLayoutFragment() ) {
        layoutStore.setFragment(person,(ILayoutFragment)layout);
		/*fragments = (Hashtable) layoutStore.getFragments(person);
		if ( fragments != null && fragments.size() > 0 ) 
		  layout.setFragments(fragments);*/
       }
        updateCacheKey();
      } catch ( Exception e ) {
        throw new PortalException(e.getMessage());
      }
    }
    
	/**
		 * Deletes the current fragment if the layout is a fragment
		 * @exception PortalException if an error occurs
		 */
	public void deleteFragment() throws PortalException {
		try {
		  if ( isLayoutFragment() ) {
			layoutStore.deleteFragment(person,fragmentId);
		  }
		    loadUserLayout();
			updateCacheKey();
	    } catch ( Exception e ) {
			throw new PortalException(e.getMessage());
		  }		
	}

    private boolean isLayoutFragment() {
      return ( fragmentId != null && layout != null );
    }

    public IUserLayoutNodeDescription getNode(String nodeId) throws PortalException {
      return layout.getNodeDescription(nodeId);
    }

    public synchronized boolean moveNode(String nodeId, String parentId, String nextSiblingId) throws PortalException {
    	
        // if the node is being moved to itself that operation must be prevented	
        if ( nodeId.equals(nextSiblingId) )