conceptstrchecker.java~

《Java网络程序设计.rar》包括三个网络程序的源代码。

/*
 */

package org.impact.stars.control.web.checker;

import org.impact.stars.control.event.StarsEvent;
import org.impact.stars.control.event.ConceptEvent;
import org.impact.stars.control.web.AppModelManager;

import org.impact.stars.conceptmd.concept.model.ConceptModel;
import org.impact.stars.control.web.ConceptstrWebImpl;
import org.impact.stars.control.event.ConceptstrEvent;
import org.impact.stars.util.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.ServletContext;

import java.util.*;

/**
 * This class is the default implementation of the ConsistentChecker
 *
*/
public class ConceptstrChecker extends ConsistentCheckerSupport {

    //protected DataTreeModel conceptTree;
    protected AccessRule accessRule;
    private HashMap conceptTreeMap;

    /*
     *This method transfer the conceptlist to a abstract datavector
     */
    public ConceptstrChecker()
    {
        conceptTreeMap = new HashMap();
        accessRule = new AccessRule();
    }
    
    public AccessRule getaccessRule()
    {
        if (accessRule == null)
        {
            accessRule = new AccessRule();
            return accessRule;
        }
        else
        {
            return accessRule;
        }
    }
    
    public HashMap getconceptTreeMap()
    {
        if (conceptTreeMap == null)
        {
            conceptTreeMap = new HashMap();
            return conceptTreeMap;
        }
        else
        {
            return conceptTreeMap;
        }
    }
    
    public Vector transferVector (Collection conceptModelList)
    {
         Debug.println("ConceptstrChecker: transferVector");        
         Vector datavector = new Vector();
         Vector conceptvector = new Vector(conceptModelList);
         Datanode anode = null;
         ConceptModel aconceptmodel = null;
     		for (Enumeration enum = conceptvector.elements(); enum.hasMoreElements() ;) {

			aconceptmodel=(ConceptModel)enum.nextElement();
			anode = new Datanode(aconceptmodel.getConceptID(), aconceptmodel.getParentID(), aconceptmodel.getName());
                        anode.setRead("0");
                        anode.setWrite("0");
                        anode.setUperBranch("0");
                        Debug.println("transferVector"+anode.getDataID());
                        datavector.addElement(anode);
                }
                return datavector;
    }
    /*
     *this method is used to check the permition for simple concept
     */
    public String getPermition(StarsEvent event)
    {
        Debug.println("ConceptstrChecker: getPermition");                
        if (event.getEventName().equals("java:comp/env/event/ConceptEvent"))
        {
            return getConceptPermition(event);
        }
            else if (event.getEventName().equals("java:comp/env/event/ConceptstrEvent"))
            {
                return getConceptstrPermition(event);
            }
        return "WRONG event";
    }
    
    public String getConceptPermition(StarsEvent event){
        Debug.println("ConceptstrChecker: getConceptPermition");        
        ConceptEvent ce = (ConceptEvent)event;
        String cstrID = ce.getCstrID();        
        DataTreeModel dtree = getTree(cstrID);
        
        switch (ce.getActionType()) {
        case ConceptEvent.CREATE_CONCEPT: {
            Debug.println("ConceptChecker : getConcept CREATE_CONCEPT event");
            return accessRule.checkPermition(dtree, AccessRule.CREATE, ce.getConceptID());
        } 
        
                case ConceptEvent.CREATE_CONCEPT_DATA: {
            Debug.println("ConceptChecker : getConcept CREATE_CONCEPT_DATA event");
            return "OK";
        } 

          case ConceptEvent.UPDATE_CONCEPT: {
            Debug.println("ConceptChecker : UPDATE_CONCEPT event");
            return accessRule.checkPermition(dtree, AccessRule.MODIFY, ce.getConceptID());
        } 
          case ConceptEvent.UPDATE_CONCEPT_DATA: {
            Debug.println("ConceptChecker : UPDATE_CONCEPT_DATA event");
            return "OK"; //To optimize need to obtain the session to identify the client
        }
        case ConceptEvent.DELETE_CONCEPT: {
            return accessRule.checkPermition(dtree, AccessRule.DELETE, ce.getConceptID());
        } 
        default:
            Debug.print("Error: not implemented yet");
            break;
        }
        return "BLOCK: Unknown Request";
    }
        
     public String getConceptstrPermition(StarsEvent event){
        Debug.println("ConceptstrChecker: getConceptstrPermition");        

        ConceptstrEvent cstre = (ConceptstrEvent)event;
        String cstrID = cstre.getConceptstrID();
        
        DataTreeModel dtree = getTree(cstrID);
        switch (cstre.getActionType()) {
        case ConceptstrEvent.CREATE_CONCEPTSTR: {
            Debug.println("ConceptChecker : CREATE_CONCEPTSTR event");
            return "OK";
        } 
        case ConceptstrEvent.UPDATE_CONCEPTSTR: {
            Debug.println("ConceptChecker : UPDATE_CONCEPTSTR event");
            return accessRule.checkPermition(dtree, AccessRule.MODIFY, cstre.getConceptstrID());
        }
        case ConceptstrEvent.UPDATE_CONCEPTSTR_DATA: {
            Debug.println("ConceptChecker : UPDATE_CONCEPTSTR_DATA event");
            return "OK"; //To optimize need to obtain the session to identify the client
        }
        
        case ConceptstrEvent.RESTRUCT_CONCEPTSTR: {
            return accessRule.checkPermition(dtree, AccessRule.RESTRUCT, cstre.getUpdateConceptID());
        } 
        
        case ConceptstrEvent.RESTRUCT_CONCEPTSTR_DATA: {
            return "OK"; //the client side maintains that the DATA is sent only it has permition
        } 

        case ConceptstrEvent.DELETE_CONCEPTSTR: {
            return accessRule.checkPermition(dtree, AccessRule.DELETE, cstre.getConceptstrID());
        } 
        default:
            Debug.print("Error: not implemented yet");
            return "OK";
        }
    }
    

    public void doConceptStart(StarsEvent event){
        ConceptEvent ce = (ConceptEvent)event;
        String cstrID = ce.getCstrID();        
        DataTreeModel dtree = getTree(cstrID);
        
        switch (ce.getActionType()) {
        case ConceptEvent.CREATE_CONCEPT: {
            Debug.println("ConceptChecker : CREATE_CONCEPT event");
            accessRule.doStart(dtree, AccessRule.CREATE, ce.getConceptID());
            
        } break;
                case ConceptEvent.CREATE_CONCEPT_DATA: {
            Debug.println("ConceptChecker : CREATE_CONCEPT_DATA event");
        } break;

        case ConceptEvent.UPDATE_CONCEPT: {
            Debug.println("ConceptChecker : UPDATE_CONCEPT event");
            accessRule.doStart(dtree, AccessRule.MODIFY, ce.getConceptID());
        } break;
        case ConceptEvent.UPDATE_CONCEPT_DATA: {
            Debug.println("ConceptChecker : UPDATE_CONCEPT_DATA event");
        } break;
                
        case ConceptEvent.DELETE_CONCEPT: {
            accessRule.doStart(dtree, AccessRule.DELETE, ce.getConceptID());
        } break;
        default:
            Debug.print("Error: not implemented yet");
            break;
        }
     }
    
    public void doConceptstrStart(StarsEvent event){