initial load

[DTRules.git] / DTRules / src / main / java / com / dtrules / admin / RulesAdminService.java

/*  
 * Copyright 2004-2007 MTBJ, Inc.  
 *   
 * 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 com.dtrules.admin;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.dtrules.decisiontables.RDecisionTable;
import com.dtrules.entity.IREntity;
import com.dtrules.entity.REntity;
import com.dtrules.entity.REntityEntry;
import com.dtrules.infrastructure.RulesException;
import com.dtrules.interpreter.IRObject;
import com.dtrules.interpreter.RName;
import com.dtrules.session.EntityFactory;
import com.dtrules.session.RSession;
import com.dtrules.session.RuleSet;
import com.dtrules.session.RulesDirectory;

/**
 * @author Prasath Ramachandran
 * Feb 1, 2007
 * 
 * The RulesAdminService provides all the methods for adding to and maintaining a 
 * Rules in DTRules.  This is the interface to be used by editors and other tools
 * to add/remove decision tables, modify the Entity Description Dictionary, and 
 * create and modify Rule Sets.
 */
@SuppressWarnings("unchecked")
public class RulesAdminService implements IRulesAdminService{
        final private RSession         session;
          private RulesDirectory   rd;          // The Rules Directory provides a place where Rule
                                                // sets are defined.
        
        /**
     * The RulesAdminService needs a session for specifing the output of debugging
     * and trace information.  It needs a Rules Directory to administer.  
         */
    public RulesAdminService(final RSession session, final RulesDirectory rd) {
        super();
        this.session = session;
        this.rd      = rd;
    }

    /**
     * Create a new Attribute;  The Entity modified is specified by the attribute.
     * @param rulesetname The name of the RuleSet where the attribute should be created.
     * @param attribute   The REntityEntry defines the Entity to be modified.  It is
     *                    assumed that this Entity already exists.
     * @return true if the attribute was successfully added. 
         */
        public boolean createAttribute(final String rulesetname, final REntityEntry attribute) {
        try {
            RuleSet  rs     = getRuleset(rulesetname);
            IREntity entity = rs.getEntityFactory(session).findRefEntity(attribute.attribute);
            entity.addAttribute(attribute);
            return true;
        } catch (RulesException e) {
            return false;
        }
                
        }

    /**
     * Given a Rule Set and an Entity, returns the list of EntityEntry objects
     * that define the meta information about each attribute of the entity. If an
     * error occurs while building the list, an empty list is returned.
     * 
     * @param rulesetname   The Rule Set in which the entity is defined
     * @param entityname    The entity name of intrest.
     * @return              The list of Entity Entries that define the attributes of the Entity
     */
    public List<REntityEntry> getEntityEntries(String rulesetname, String entityname){
        ArrayList<REntityEntry> entries = new ArrayList<REntityEntry>();
        RuleSet                 rs      = getRuleset(rulesetname);
        IREntity entity;
        try {
            entity = rs.getEntityFactory(session).findRefEntity(RName.getRName(entityname));
            Iterator<RName>         attribs = entity.getAttributeIterator();
            
            while(attribs.hasNext()){
                entries.add(entity.getEntry(attribs.next()));
            }
        } catch (RulesException e) { }
        
        return entries;
    }

    /**
     * Create a new Decision Table
     */
        public RDecisionTable createDecisionTable(String rulesetname, String decisiontablename) 
            throws RulesException{
                RuleSet rs     = getRuleset(rulesetname);
        return rs.getEntityFactory(session).newDecisionTable(decisiontablename,session);
        }

        /**
     * Creates a new Entity of the given name within the RuleSet.  If
     * the Entity already exists or the name is invalid, or this operation
     * fails in any other way, a null is returned.
         * @see com.dtrules.admin.IRulesAdminService#createEntity(java.lang.String, java.lang.String)
     * @param rulesetname The name of the RuleSet in which to create this entity
     * @param EntityName  The name of the new Entity
         */
        public IREntity createEntity(String rulesetname, boolean readonly, String entityName) {
        RName    name = RName.getRName(entityName);
                IREntity e    = session.getEntityFactory().findRefEntity(name);
                if(e!=null)return null;
        try {
            return session.getEntityFactory().findcreateRefEntity(readonly, name);
        } catch (RulesException e1) {
            return null;
        }
        }

        /**
     * Create a new Rule Set
         * @see com.dtrules.admin.IRulesAdminService#createRuleset(com.dtrules.session.RuleSet)
         */
        public void createRuleset(RuleSet ruleset) throws RulesException{
                rd.addRuleSet(ruleset);
        }

        /* (non-Javadoc)
         * @see com.dtrules.admin.IRulesAdminService#getAttributes(java.lang.String, java.lang.String)
         */
        @SuppressWarnings("unchecked")
        public List getAttributes(String rulesetname, String entityName) {
        if(rd==null)return null;
        try {
            RuleSet rs = rd.getRuleSet(RName.getRName(rulesetname));
            Iterator it = rs.getEntityFactory(session)
                          .findRefEntity(RName.getRName(entityName)).getAttributeIterator();
            return getList(it);
        } catch (RulesException e) {
            return null;
        }
        }

        /* (non-Javadoc)
         * @see com.dtrules.admin.IRulesAdminService#getDecisionTable(java.lang.String, java.lang.String)
         */
        public RDecisionTable getDecisionTable(String rulesetname, String DecisionTableName) {
        try {
            RuleSet rs = rd.getRuleSet(RName.getRName(rulesetname));
            return rs.getEntityFactory(session)
                   .findTable(RName.getRName(DecisionTableName));
        } catch (RulesException e) {
            return null;
        } 
        }

        /* (non-Javadoc)
         * @see com.dtrules.admin.IRulesAdminService#getDecisionTables(java.lang.String)
         */
        public List getDecisionTables(String rulesetname) {
                if(rd==null)return null;
        try {
            RuleSet rs = rd.getRuleSet(RName.getRName(rulesetname));
            Iterator it = rs.getEntityFactory(session).getDecisionTableRNameIterator();
            return getList(it);
        } catch (RulesException e) {
            return null;
        }
        }
        
    @SuppressWarnings("unchecked")
    private List getList(Iterator iterator){
        List list = new ArrayList();
        while(iterator.hasNext()){
            list.add(((IRObject)iterator.next()).stringValue());
        }
        return list;
        
    }
    
        /**
     * Return the list of Entities known to the given ruleset
     * @return List of Entity RName objects
         * @see com.dtrules.admin.IRulesAdminService#getEntities(java.lang.String)
         */
        public List getEntities(String rulesetname) {
        if(rd==null)return null;
        try {
            Iterator e = rd.getRuleSet(RName.getRName(rulesetname)).getEntityFactory(session)
                            .getEntityRNameIterator(); 
            return getList(e);
        } catch (RulesException e) {}
                return null;
        }

        /**
     * Return the RuleSet associated with the given RuleSet Name
     * @return RuleSet A set of Decision Tables and Entities which define a RuleSet
         * @see com.dtrules.admin.IRulesAdminService#getRuleset(java.lang.String)
         */
        public RuleSet getRuleset(String RulesetName) {
                if(rd==null)return null;
        return rd.getRuleSet(RName.getRName(RulesetName));
        }

        /**
     * Returns the list of RuleSets known to this Rules Directory
     * @return A List of RName objects giving the list Rule Sets
         * @see com.dtrules.admin.IRulesAdminService#getRulesets()
         */
        public List<String> getRulesets() {
                List<String> rulesets = new ArrayList<String>();
                for(Iterator it = rd.getRulesets().keySet().iterator(); it.hasNext();){
                        RName name = (RName)it.next();
                        rulesets.add(name.stringValue());
                }
                return rulesets;
        }

        /**
     * Loads the XML defining the RulesDirectory.  The given path must be a
     * path and filename which is valid in the file system, or a valid Java 
     * resource, or a valid URL.
     * @param pathtoDT 
         * @see com.dtrules.admin.IRulesAdminService#initialize(java.lang.String)
         */
        public void initialize(String pathtoDTrules) {
                String path = "C:\\eclipse\\workspace\\EB_POC\\CA HCO Plan\\xml\\";
                String file = path + "DTRules.xml";
                if(pathtoDTrules != null){
                        file = pathtoDTrules;
                }
                
                try {
                        rd = new RulesDirectory("",file);
                        
                } catch (Exception e) {
                        e.printStackTrace();
                }               
                
        }

        /**
     * This method changes (potentially) the attributes of an attribute of an
     * Entity.  The REntityEntry attribute must be populated correctly.
     * 
     * @param rulesetname    The Ruleset which holds the Entity for which the 
     *                       attribute applies.
     * @param attribute      Contains the Entity Name and all the other meta data                      
     *                       for the attribute to be changed.
     *                       
         * @see com.dtrules.admin.IRulesAdminService#updateAttribute(java.lang.String, com.dtrules.entity.REntityEntry)
         */
        public void updateAttribute(REntity entity, String rulesetname, REntityEntry attribute) throws RulesException {
        entity.addAttribute(attribute);
        
        }
    /**
     * Updates the Decision Table XML specified in the RuleSet with the Decision Tables as 
     * currently held in memory.  
     */
    public void saveDecisionTables(RSession session, String rulesetname) throws RulesException {
        RuleSet       rs       = rd.getRuleSet(RName.getRName(rulesetname));
        String        filepath = rs.getFilepath();
        String        filename = rs.getDT_XMLName();
        
        OutputStream out;
        try {
            out = new FileOutputStream(filepath+filename);
        } catch (FileNotFoundException e) {
            throw new RulesException(
                    "OutputFileCreationError",
                    "saveDecisionTables",
                    "An error occured openning the file: "+filepath+filename+"\n"+e
                   );
        }
        saveDecisionTables(out,session,rulesetname);
    }
    
    /**
     * Writes out the Decision Tables to the given output stream as the currently exist in 
     * Memory.
     * 
     * @param out outputstream to write the decision tables to.
     * @param session The session which gives us the outputstreams for debug statements and trace statements
     * @param rulesetname The Rule Set to be written out to the output stream
     * @throws RulesException
     */
        public void saveDecisionTables(OutputStream out, RSession session, String rulesetname) throws RulesException {
            RuleSet       rs       = rd.getRuleSet(RName.getRName(rulesetname));
        EntityFactory ef       = rs.getEntityFactory(session);
        
        PrintStream  ps  = new PrintStream(out);
        Iterator<RName> tables = ef.getDecisionTableRNameIterator();
        ps.println("<decision_tables>");
        while(tables.hasNext()){
            RName dtname = tables.next();
            ef.getDecisionTable(dtname).writeXML(ps);
        }
        ps.println("\n</decision_tables>");
        
        }
    
    /**
     * Test function.
     * @param args ignored.
     */
    public static void main(String args[]){
        String path = "C:\\eclipse\\workspace\\EB_POC\\new_york_EB\\xml\\";
        String file = path + "DTRules.xml";    
    
        RulesDirectory    rd      = new RulesDirectory("",file);
        RuleSet           rs      = rd.getRuleSet(RName.getRName("ebdemo"));
        RSession          session;
        try {
            OutputStream  out     = new FileOutputStream("c:\\temp\\dt.xml");
                          session = new RSession(rs);
            RulesAdminService admin   = new RulesAdminService(session, rd);
                          
            admin.saveDecisionTables(out, session, "ebdemo");
        } catch (Exception e1) {
            System.out.println(e1.toString());
        }
    }
        /* (non-Javadoc)
         * @see com.dtrules.admin.IRulesAdminService#updateEntity(java.lang.String, com.dtrules.entity.REntity)
         */
        public void saveEDD(RSession session, String rulesetname) throws RulesException {
        RuleSet       rs       = rd.getRuleSet(RName.getRName(rulesetname));
        EntityFactory ef       = rs.getEntityFactory(session);
        String        filepath = rs.getFilepath();
        String        filename = rs.getEDD_XMLName();
        
        OutputStream out;
        try {
            out = new FileOutputStream(filepath+filename);
        } catch (FileNotFoundException e) {
            throw new RulesException(
                    "OutputFileCreationError",
                    "saveDecisionTables",
                    "An error occured openning the file: "+filepath+filename+"\n"+e
                   );
        }
        PrintStream  ps  = new PrintStream(out);
        Iterator<RName> entities = ef.getEntityRNameIterator();
        ps.println("<entity_data_dictionary>");
        while(entities.hasNext()){
            RName ename = entities.next();
            ef.findRefEntity(ename).writeXML(ps);
        }
        ps.println("\n</entity_data_dictionary>");
        }

        /* (non-Javadoc)
         * @see com.dtrules.admin.IRulesAdminService#updateRuleset(com.dtrules.session.RuleSet)
         */
        public void updateRuleset(RuleSet ruleset) {
                // TODO Auto-generated method stub
                
        }
        
    
     /**
     * Given an incomplete table, this method returns a balanced table.
     * Entries in the table provided can be 'y', 'n', '-', or ' '.  If
     * blank, then it is assumed that the caller assumes this should be
     * flushed out. If the result will be larger than 16 columns, an 
     * null is returned. (You can't have a table larger than 16 columns).
     * @param table  -- A partial truth table.
     * @return
     */
    public String[][] balanceTable(String [] [] table){
        int rows = table.length;
        if(rows>4||rows<=0)return null;
        int cols = 1<<(rows);
        
        String newTable[][] = new String [rows][cols];
        
        for(int i=0; i< cols; i++){
            for(int j=0;j<rows; j++){
                newTable[j][i]= ((i>>(rows-1-j))&1)==1?"n":"y"; 
            }
        }
        
        return newTable;
    }

    public final RulesDirectory getRd() {
        return rd;
    }

    public final RSession getSession() {
        return session;
    }
    
}