[jboss-svn-commits] JBL Code SVN: r8232 - in labs/jbossrules/trunk/drools-repository/src: main/java/org/drools/repository test/java/org/drools/repository
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon Dec 11 13:02:34 EST 2006
Author: mark.proctor at jboss.com
Date: 2006-12-11 13:02:27 -0500 (Mon, 11 Dec 2006)
New Revision: 8232
Added:
labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/AssetItem.java
labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/PackageItem.java
Removed:
labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RuleItem.java
labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageItem.java
Modified:
labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageIterator.java
labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulesRepository.java
labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/DslItemTestCase.java
labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RuleItemTestCase.java
labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulePackageItemTestCase.java
labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulesRepositoryTestCase.java
labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/ScalabilityTest.java
Log:
JBRULES-583 Refactor RuleItem to AssetItem
Copied: labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/AssetItem.java (from rev 8220, labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RuleItem.java)
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RuleItem.java 2006-12-11 12:57:12 UTC (rev 8220)
+++ labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/AssetItem.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -0,0 +1,342 @@
+package org.drools.repository;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.jcr.AccessDeniedException;
+import javax.jcr.ItemExistsException;
+import javax.jcr.ItemNotFoundException;
+import javax.jcr.Node;
+import javax.jcr.PathNotFoundException;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+import javax.jcr.Value;
+import javax.jcr.lock.LockException;
+import javax.jcr.nodetype.ConstraintViolationException;
+import javax.jcr.version.VersionException;
+
+import org.apache.log4j.Logger;
+
+/**
+ * The RuleItem class is used to abstract away the details of the underlying JCR repository.
+ * It is used to pass information about rules stored in the repository.
+ *
+ * @author btruitt
+ */
+public class AssetItem extends CategorisableItem {
+ private Logger log = Logger.getLogger( AssetItem.class );
+
+ /**
+ * The name of the DSL property on the rule node type
+ */
+ public static final String DSL_PROPERTY_NAME = "drools:dslReference";
+
+ /**
+ * The name of the rule node type
+ */
+ public static final String RULE_NODE_TYPE_NAME = "drools:ruleNodeType";
+
+ public static final String RULE_CONTENT_PROPERTY_NAME = "drools:content";
+
+ public static final String RULE_CONTENT_URI_PROPERTY_NAME = "drools:contentURI";
+
+ /**
+ * The name of the date effective property on the rule node type
+ */
+ public static final String DATE_EFFECTIVE_PROPERTY_NAME = "drools:dateEffective";
+
+ /**
+ * The name of the date expired property on the rule node type
+ */
+ public static final String DATE_EXPIRED_PROPERTY_NAME = "drools:dateExpired";
+
+ public static final String PACKAGE_NAME_PROPERTY = "drools:packageName";
+
+ /**
+ * Constructs a RuleItem object, setting its node attribute to the specified node.
+ *
+ * @param rulesRepository the rulesRepository that instantiated this object
+ * @param node the node in the repository that this RuleItem corresponds to
+ * @throws RulesRepositoryException
+ */
+ public AssetItem(RulesRepository rulesRepository,
+ Node node) throws RulesRepositoryException {
+ super( rulesRepository,
+ node );
+
+ try {
+ //make sure this node is a rule node
+ if ( !(this.node.getPrimaryNodeType().getName().equals( RULE_NODE_TYPE_NAME ) || isHistoricalVersion()) ) {
+ String message = this.node.getName() + " is not a node of type " + RULE_NODE_TYPE_NAME + " nor nt:version. It is a node of type: " + this.node.getPrimaryNodeType().getName();
+ log.error( message );
+ throw new RulesRepositoryException( message );
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * returns the contents of the rule node.
+ * It there is a URI, this may need to access the external resource
+ * to grab/sync the latest, but in any case, it should be the real content.
+ */
+ public String getRuleContent() throws RulesRepositoryException {
+ try {
+ Node ruleNode = getVersionContentNode();
+ if ( ruleNode.hasProperty( RULE_CONTENT_PROPERTY_NAME ) ) {
+ Property data = ruleNode.getProperty( RULE_CONTENT_PROPERTY_NAME );
+ return data.getValue().getString();
+
+ } else {
+ return null;
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * returns the URI for where the rules content is stored.
+ * Rule content may be stored in an external repository,
+ * such as subversion. This URI will contain information for
+ * how to get to the exact version that maps to this rule node.
+ */
+ public String getRuleContentURI() throws RulesRepositoryException {
+ try {
+ Node ruleNode = getVersionContentNode();
+ if ( ruleNode.hasProperty( RULE_CONTENT_URI_PROPERTY_NAME ) ) {
+ Property data = ruleNode.getProperty( RULE_CONTENT_URI_PROPERTY_NAME );
+ return data.getValue().getString();
+ } else {
+ return "";
+ }
+
+ } catch ( Exception e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * @return the date the rule becomes effective
+ * @throws RulesRepositoryException
+ */
+ public Calendar getDateEffective() throws RulesRepositoryException {
+ try {
+ Node ruleNode = getVersionContentNode();
+
+ Property dateEffectiveProperty = ruleNode.getProperty( DATE_EFFECTIVE_PROPERTY_NAME );
+ return dateEffectiveProperty.getDate();
+ } catch ( PathNotFoundException e ) {
+ // doesn't have this property
+ return null;
+ } catch ( Exception e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Creates a new version of this object's rule node, updating the effective date for the
+ * rule node.
+ *
+ * @param newDateEffective the new effective date for the rule
+ * @throws RulesRepositoryException
+ */
+ public void updateDateEffective(Calendar newDateEffective) throws RulesRepositoryException {
+ checkIsUpdateable();
+ checkout();
+ try {
+ this.node.setProperty( DATE_EFFECTIVE_PROPERTY_NAME,
+ newDateEffective );
+ } catch ( RepositoryException e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * @return the date the rule becomes expired
+ * @throws RulesRepositoryException
+ */
+ public Calendar getDateExpired() throws RulesRepositoryException {
+ try {
+ Node ruleNode = getVersionContentNode();
+
+ Property dateExpiredProperty = ruleNode.getProperty( DATE_EXPIRED_PROPERTY_NAME );
+ return dateExpiredProperty.getDate();
+ } catch ( PathNotFoundException e ) {
+ // doesn't have this property
+ return null;
+ } catch ( Exception e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Creates a new version of this object's rule node, updating the expired date for the
+ * rule node.
+ *
+ * @param newDateExpired the new expired date for the rule
+ * @throws RulesRepositoryException
+ */
+ public void updateDateExpired(Calendar newDateExpired) throws RulesRepositoryException {
+ checkout();
+
+ try {
+ this.node.setProperty( DATE_EXPIRED_PROPERTY_NAME,
+ newDateExpired );
+ } catch ( Exception e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * This will update the rules content (checking it out if it is not already).
+ * This will not save the session or create a new version of the node
+ * (this has to be done seperately, as several properties may change as part of one edit).
+ */
+ public AssetItem updateRuleContent(String newRuleContent) throws RulesRepositoryException {
+ checkout();
+ try {
+ this.node.setProperty( RULE_CONTENT_PROPERTY_NAME,
+ newRuleContent );
+ return this;
+ } catch ( RepositoryException e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * The URI represents a location for
+ */
+ public void updateRuleContentURI(String newURI) throws RulesRepositoryException {
+ checkout();
+ try {
+ this.node.setProperty( RULE_CONTENT_URI_PROPERTY_NAME,
+ newURI );
+ } catch ( RepositoryException e ) {
+ log.error( "Caught Exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Gets a DslItem object corresponding to the DSL reference from the node that this object
+ * encapsulates.
+ *
+ * @return a DslItem object corresponding to the DSL reference for this rule node. If there is
+ * no DSL node referenced from this object's node, then null.
+ * @throws RulesRepositoryException
+ */
+ public DslItem getDsl() throws RulesRepositoryException {
+ try {
+ Property dslProperty = getVersionContentNode().getProperty( DSL_PROPERTY_NAME );
+ Node dslNode = this.node.getSession().getNodeByUUID( dslProperty.getString() );
+ return new DslItem( this.rulesRepository,
+ dslNode );
+ } catch ( PathNotFoundException e ) {
+ //not set
+ return null;
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Nicely formats the information contained by the node that this object encapsulates
+ */
+ public String toString() {
+ try {
+ StringBuffer returnString = new StringBuffer();
+ returnString.append( "Content of rule item named '" + this.getName() + "':\n" );
+ returnString.append( "Content: " + this.getRuleContent() + "\n" );
+ returnString.append( "Content URI: " + this.getRuleContentURI() + "\n" );
+ returnString.append( "------\n" );
+
+ returnString.append( "Date Effective: " + this.getDateEffective() + "\n" );
+ returnString.append( "Date Expired: " + this.getDateExpired() + "\n" );
+ returnString.append( "------\n" );
+
+ returnString.append( "Rule state: " );
+ StateItem stateItem = this.getState();
+ if ( stateItem != null ) {
+ returnString.append( this.getState().getName() + "\n" );
+ } else {
+ returnString.append( "NO STATE SET FOR THIS NODE\n" );
+ }
+ returnString.append( "------\n" );
+
+ returnString.append( "Rule tags:\n" );
+ for ( Iterator it = this.getCategories().iterator(); it.hasNext(); ) {
+ CategoryItem currentTag = (CategoryItem) it.next();
+ returnString.append( currentTag.getName() + "\n" );
+ }
+ returnString.append( "--------------\n" );
+ return returnString.toString();
+ } catch ( Exception e ) {
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ public VersionableItem getPrecedingVersion() throws RulesRepositoryException {
+ try {
+ Node precedingVersionNode = this.getPrecedingVersionNode();
+ if ( precedingVersionNode != null ) {
+ return new AssetItem( this.rulesRepository,
+ precedingVersionNode );
+ } else {
+ return null;
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ public VersionableItem getSucceedingVersion() throws RulesRepositoryException {
+ try {
+ Node succeedingVersionNode = this.getSucceedingVersionNode();
+ if ( succeedingVersionNode != null ) {
+ return new AssetItem( this.rulesRepository,
+ succeedingVersionNode );
+ } else {
+ return null;
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Get the name of the enclosing package.
+ * As assets are stored in versionable subfolders, this means walking up 2 levels in the
+ * hierarchy to get to the enclosing "package" node.
+ */
+ public String getPackageName() {
+ return super.getStringProperty( PACKAGE_NAME_PROPERTY );
+ }
+
+}
\ No newline at end of file
Copied: labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/PackageItem.java (from rev 8229, labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageItem.java)
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageItem.java 2006-12-11 17:44:40 UTC (rev 8229)
+++ labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/PackageItem.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -0,0 +1,628 @@
+package org.drools.repository;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.jcr.ItemExistsException;
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.PathNotFoundException;
+import javax.jcr.RepositoryException;
+import javax.jcr.UnsupportedRepositoryOperationException;
+import javax.jcr.Value;
+import javax.jcr.ValueFactory;
+
+import org.apache.log4j.Logger;
+
+/**
+ * A PackageItem object aggregates a set of assets (for example, rules). This is advantageous for systems using the JBoss Rules
+ * engine where the application might make use of many related rules.
+ * <p>
+ * A PackageItem refers to rule nodes within the RulesRepository. It contains the "master copy" of assets (which may be linked
+ * into other packages or other types of containers).
+ * This is a container "node".
+ *
+ * @author btruitt
+ */
+public class PackageItem extends VersionableItem {
+ private static Logger log = Logger.getLogger( PackageItem.class );
+
+ /**
+ * This is the name of the rules "subfolder" where rules are kept
+ * for this package.
+ */
+ public static final String RULES_FOLDER_NAME = "rules";
+
+ /**
+ * The name of the reference property on the rulepackage_node_type type node that objects of
+ * this type hold a reference to
+ */
+ public static final String RULE_REFERENCE_PROPERTY_NAME = "drools:ruleReference";
+
+ /**
+ * The name of the reference property on the rulepackage_node_type type node that objects of
+ * this type hold a reference to
+ */
+ public static final String FUNCTION_REFERENCE_PROPERTY_NAME = "drools:functionReference";
+
+ /**
+ * The name of the rule package node type
+ */
+ public static final String RULE_PACKAGE_TYPE_NAME = "drools:rulepackageNodeType";
+
+ /**
+ * The folder where functions are kept
+ */
+ public static final String FUNCTION_FOLDER_NAME = "functions";
+
+ /**
+ * Constructs an object of type RulePackageItem corresponding the specified node
+ * @param rulesRepository the rulesRepository that instantiated this object
+ * @param node the node to which this object corresponds
+ * @throws RulesRepositoryException
+ */
+ public PackageItem(RulesRepository rulesRepository,
+ Node node) throws RulesRepositoryException {
+ super( rulesRepository,
+ node );
+
+ try {
+ //make sure this node is a rule package node
+ if ( !(this.node.getPrimaryNodeType().getName().equals( RULE_PACKAGE_TYPE_NAME ) ||
+ isHistoricalVersion()) ) {
+ String message = this.node.getName() + " is not a node of type " + RULE_PACKAGE_TYPE_NAME + ". It is a node of type: " + this.node.getPrimaryNodeType().getName();
+ log.error( message );
+ throw new RulesRepositoryException( message );
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught exception: " + e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+
+ /**
+ * Adds a rule to the current package with no category (not recommended !).
+ * Without categories, its going to be hard to find rules later on
+ * (unless packages are enough for you).
+ */
+ public AssetItem addRule(String ruleName, String description) {
+ return addRule(ruleName, description, null);
+ }
+
+
+ /**
+ * This adds a rule to the current physical package (you can move it later).
+ * With the given category
+ */
+ public AssetItem addRule(String ruleName,
+ String description, String initialCategory) {
+ Node ruleNode;
+ try {
+
+ Node rulesFolder = this.node.getNode( RULES_FOLDER_NAME );
+ ruleNode = rulesFolder.addNode( ruleName,
+ AssetItem.RULE_NODE_TYPE_NAME );
+ ruleNode.setProperty( AssetItem.TITLE_PROPERTY_NAME,
+ ruleName );
+
+ ruleNode.setProperty( AssetItem.DESCRIPTION_PROPERTY_NAME,
+ description );
+ ruleNode.setProperty( AssetItem.FORMAT_PROPERTY_NAME,
+ AssetItem.RULE_FORMAT );
+
+
+ ruleNode.setProperty( VersionableItem.CHECKIN_COMMENT,
+ "Initial" );
+
+ Calendar lastModified = Calendar.getInstance();
+
+ ruleNode.setProperty( AssetItem.LAST_MODIFIED_PROPERTY_NAME, lastModified );
+ ruleNode.setProperty( AssetItem.CREATION_DATE_PROPERTY, lastModified );
+
+ ruleNode.setProperty( AssetItem.PACKAGE_NAME_PROPERTY, this.getName() );
+
+ AssetItem rule = new AssetItem( this.rulesRepository, ruleNode );
+
+ if (initialCategory != null) {
+ rule.addCategory( initialCategory );
+ }
+
+ return rule;
+
+ } catch ( Exception e ) {
+ if ( e instanceof RuntimeException ) {
+ throw (RuntimeException) e;
+ } else if ( e instanceof ItemExistsException ) {
+ throw new RulesRepositoryException( "A rule of that name already exists in that package.",
+ e );
+ } else {
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ }
+
+ /** Remove a rule by name */
+ public void removeRule(String name) {
+ try {
+ this.node.getNode( RULES_FOLDER_NAME + "/" + name ).remove();
+ } catch ( RepositoryException e ) {
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+
+
+ // The following should be kept for reference on how to add a reference that
+ //is either locked to a version or follows head - FOR SHARING RULES
+ // /**
+ // * Adds a rule to the rule package node this object represents. The reference to the rule
+ // * will optionally follow the head version of the specified rule's node or the specific
+ // * current version.
+ // *
+ // * @param ruleItem the ruleItem corresponding to the node to add to the rule package this
+ // * object represents
+ // * @param followRuleHead if true, the reference to the rule node will follow the head version
+ // * of the node, even if new versions are added. If false, will refer
+ // * specifically to the current version.
+ // * @throws RulesRepositoryException
+ // */
+ // public void addRuleReference(RuleItem ruleItem, boolean followRuleHead) throws RulesRepositoryException {
+ // try {
+ // ValueFactory factory = this.node.getSession().getValueFactory();
+ // int i = 0;
+ // Value[] newValueArray = null;
+ //
+ // try {
+ // Value[] oldValueArray = this.node.getProperty(RULE_REFERENCE_PROPERTY_NAME).getValues();
+ // newValueArray = new Value[oldValueArray.length + 1];
+ //
+ // for(i=0; i<oldValueArray.length; i++) {
+ // newValueArray[i] = oldValueArray[i];
+ // }
+ // }
+ // catch(PathNotFoundException e) {
+ // //the property has not been created yet. do so now
+ // newValueArray = new Value[1];
+ // }
+ // finally {
+ // if(newValueArray != null) { //just here to make the compiler happy
+ // if(followRuleHead) {
+ // newValueArray[i] = factory.createValue(ruleItem.getNode());
+ // }
+ // else {
+ // //this is the magic that ties it to a specific version
+ // newValueArray[i] = factory.createValue(ruleItem.getNode().getBaseVersion());
+ // }
+ // this.node.checkout();
+ // this.node.setProperty(RULE_REFERENCE_PROPERTY_NAME, newValueArray);
+ // this.node.getSession().save();
+ // this.node.checkin();
+ // }
+ // else {
+ // throw new RulesRepositoryException("Unexpected null pointer for newValueArray");
+ // }
+ // }
+ // }
+ // catch(UnsupportedRepositoryOperationException e) {
+ // String message = "";
+ // try {
+ // message = "Error: Caught UnsupportedRepositoryOperationException when attempting to get base version for rule: " + ruleItem.getNode().getName() + ". Are you sure your JCR repository supports versioning? ";
+ // log.error(message + e);
+ // }
+ // catch (RepositoryException e1) {
+ // log.error("Caught exception: " + e1);
+ // throw new RulesRepositoryException(message, e1);
+ // }
+ // log.error("Caught exception: " + e);
+ // throw new RulesRepositoryException(e);
+ // }
+ // catch(Exception e) {
+ // log.error("Caught exception: " + e);
+ // throw new RulesRepositoryException(e);
+ // }
+ // }
+
+ /**
+ * Adds a function to the rule package node this object represents. The reference to the
+ * function node will follow the head version of the specified node.
+ *
+ * @param functionItem the functionItem corresponding to the node to add to the rule package this
+ * object represents
+ * @throws RulesRepositoryException
+ */
+ public void addFunction(FunctionItem functionItem) throws RulesRepositoryException {
+ this.addFunction( functionItem,
+ true );
+ }
+
+ /**
+ * Adds a function to the rule package node this object represents. The reference to the function
+ * will optionally follow the head version of the specified node or the specific current version.
+ *
+ * @param functionItem the functionItem corresponding to the node to add to the rule package this
+ * object represents
+ * @param followRuleHead if true, the reference to the function node will follow the head version
+ * of the node, even if new versions are added. If false, will refer
+ * specifically to the current version.
+ * @throws RulesRepositoryException
+ */
+ public void addFunction(FunctionItem functionItem,
+ boolean followFunctionHead) throws RulesRepositoryException {
+ try {
+ ValueFactory factory = this.node.getSession().getValueFactory();
+ int i = 0;
+ Value[] newValueArray = null;
+
+ try {
+ Value[] oldValueArray = this.node.getProperty( FUNCTION_REFERENCE_PROPERTY_NAME ).getValues();
+ newValueArray = new Value[oldValueArray.length + 1];
+
+ for ( i = 0; i < oldValueArray.length; i++ ) {
+ newValueArray[i] = oldValueArray[i];
+ }
+ } catch ( PathNotFoundException e ) {
+ //the property has not been created yet. do so now
+ newValueArray = new Value[1];
+ } finally {
+ if ( newValueArray != null ) { //just here to make the compiler happy
+ if ( followFunctionHead ) {
+ newValueArray[i] = factory.createValue( functionItem.getNode() );
+ } else {
+ newValueArray[i] = factory.createValue( functionItem.getNode().getBaseVersion() );
+ }
+ this.node.checkout();
+ this.node.setProperty( FUNCTION_REFERENCE_PROPERTY_NAME,
+ newValueArray );
+ this.node.getSession().save();
+ this.node.checkin();
+ } else {
+ throw new RulesRepositoryException( "Unexpected null pointer for newValueArray" );
+ }
+ }
+ } catch ( UnsupportedRepositoryOperationException e ) {
+ String message = "";
+ try {
+ message = "Error: Caught UnsupportedRepositoryOperationException when attempting to get base version for function: " + functionItem.getNode().getName() + ". Are you sure your JCR repository supports versioning? ";
+ log.error( message + e );
+ } catch ( RepositoryException e1 ) {
+ log.error( "Caught exception: " + e1 );
+ throw new RulesRepositoryException( message,
+ e1 );
+ }
+ log.error( "Caught exception: " + e );
+ throw new RulesRepositoryException( e );
+ } catch ( Exception e ) {
+ log.error( "Caught exception: " + e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Removes the specified rule from the rule package node this object represents.
+ *
+ * @param ruleItem the ruleItem corresponding to the node to remove from the rule package
+ * this object represents
+ * @throws RulesRepositoryException
+ */
+ public void removeRuleReference(AssetItem ruleItem) throws RulesRepositoryException {
+ try {
+ Value[] oldValueArray = this.node.getProperty( RULE_REFERENCE_PROPERTY_NAME ).getValues();
+ Value[] newValueArray = new Value[oldValueArray.length - 1];
+
+ boolean wasThere = false;
+
+ int j = 0;
+ for ( int i = 0; i < oldValueArray.length; i++ ) {
+ Node ruleNode = this.node.getSession().getNodeByUUID( oldValueArray[i].getString() );
+ AssetItem currentRuleItem = new AssetItem( this.rulesRepository,
+ ruleNode );
+ if ( currentRuleItem.equals( ruleItem ) ) {
+ wasThere = true;
+ } else {
+ newValueArray[j] = oldValueArray[i];
+ j++;
+ }
+ }
+
+ if ( !wasThere ) {
+ return;
+ } else {
+ this.node.checkout();
+ this.node.setProperty( RULE_REFERENCE_PROPERTY_NAME,
+ newValueArray );
+ this.node.getSession().save();
+ this.node.checkin();
+ }
+ } catch ( PathNotFoundException e ) {
+ //the property has not been created yet.
+ return;
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Removes the specified function from the rule package node this object represents.
+ *
+ * @param functionItem the functionItem corresponding to the node to remove from the rule package
+ * this object represents
+ * @throws RulesRepositoryException
+ */
+ public void removeFunction(FunctionItem functionItem) throws RulesRepositoryException {
+ try {
+ Value[] oldValueArray = this.node.getProperty( FUNCTION_REFERENCE_PROPERTY_NAME ).getValues();
+ Value[] newValueArray = new Value[oldValueArray.length - 1];
+
+ boolean wasThere = false;
+
+ int j = 0;
+ for ( int i = 0; i < oldValueArray.length; i++ ) {
+ Node functionNode = this.node.getSession().getNodeByUUID( oldValueArray[i].getString() );
+ FunctionItem currentFunctionItem = new FunctionItem( this.rulesRepository,
+ functionNode );
+ if ( currentFunctionItem.equals( functionItem ) ) {
+ wasThere = true;
+ } else {
+ newValueArray[j] = oldValueArray[i];
+ j++;
+ }
+ }
+
+ if ( !wasThere ) {
+ return;
+ } else {
+ this.node.checkout();
+ this.node.setProperty( FUNCTION_REFERENCE_PROPERTY_NAME,
+ newValueArray );
+ this.node.getSession().save();
+ this.node.checkin();
+ }
+ } catch ( PathNotFoundException e ) {
+ //the property has not been created yet.
+ return;
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * Gets a list of FunctionItem objects for each function node in this rule package
+ *
+ * @return the List object holding the FunctionItem objects in this rule package
+ * @throws RulesRepositoryException
+ */
+ public List getFunctions() throws RulesRepositoryException {
+ try {
+ Value[] valueArray = this.node.getProperty( FUNCTION_REFERENCE_PROPERTY_NAME ).getValues();
+ List returnList = new ArrayList();
+
+ for ( int i = 0; i < valueArray.length; i++ ) {
+ Node functionNode = this.node.getSession().getNodeByUUID( valueArray[i].getString() );
+ returnList.add( new FunctionItem( this.rulesRepository,
+ functionNode ) );
+ }
+ return returnList;
+ } catch ( PathNotFoundException e ) {
+ //the property has not been created yet.
+ return new ArrayList();
+ } catch ( Exception e ) {
+ log.error( "Caught exception: " + e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ // /**
+ // * Gets a list of RuleItem objects for each rule node in this rule package
+ // *
+ // * @return the List object holding the RuleItem objects in this rule package
+ // * @throws RulesRepositoryException
+ // */
+ // public List getRules() throws RulesRepositoryException {
+ // try {
+ // Value[] valueArray = this.node.getProperty(RULE_REFERENCE_PROPERTY_NAME).getValues();
+ // List returnList = new ArrayList();
+ //
+ // for(int i=0; i<valueArray.length; i++) {
+ // Node ruleNode = this.node.getSession().getNodeByUUID(valueArray[i].getString());
+ // returnList.add(new RuleItem(this.rulesRepository, ruleNode));
+ // }
+ // return returnList;
+ // }
+ // catch(PathNotFoundException e) {
+ // //the property has not been created yet.
+ // return new ArrayList();
+ // }
+ // catch(Exception e) {
+ // log.error("Caught exception: " + e);
+ // throw new RulesRepositoryException(e);
+ // }
+ // }
+
+ /** Return an iterator for the rules in this package */
+ public Iterator getRules() {
+ try {
+ Node content = getVersionContentNode();
+ RuleItemIterator it = new RuleItemIterator( content.getNode( RULES_FOLDER_NAME ).getNodes(),
+ this.rulesRepository );
+ return it;
+ } catch ( PathNotFoundException e ) {
+ throw new RulesRepositoryException( e );
+ } catch ( RepositoryException e ) {
+ throw new RulesRepositoryException( e );
+ }
+
+ }
+
+ /**
+ * Load a specific rule asset by name.
+ */
+ public AssetItem loadRule(String name) {
+
+ try {
+ Node content = getVersionContentNode();
+ return new AssetItem(
+ this.rulesRepository,
+ content.getNode( RULES_FOLDER_NAME ).getNode( name ));
+ } catch ( RepositoryException e ) {
+ throw new RulesRepositoryException(e);
+ }
+
+ }
+
+ /**
+ * Nicely formats the information contained by the node that this object encapsulates
+ */
+ public String toString() {
+ try {
+ StringBuffer returnString = new StringBuffer();
+ returnString.append( "Content of the rule package named " + this.node.getName() + ":" );
+ returnString.append( "Description: " + this.getDescription() + "\n" );
+ returnString.append( "Format: " + this.getFormat() + "\n" );
+ returnString.append( "Last modified: " + this.getLastModified() + "\n" );
+ returnString.append( "Title: " + this.getTitle() + "\n" );
+ returnString.append( "----\n" );
+
+ return returnString.toString();
+ } catch ( Exception e ) {
+ log.error( "Caught Exception",
+ e );
+ return null;
+ }
+ }
+
+ public VersionableItem getPrecedingVersion() throws RulesRepositoryException {
+ try {
+ Node precedingVersionNode = this.getPrecedingVersionNode();
+ if ( precedingVersionNode != null ) {
+ return new PackageItem( this.rulesRepository,
+ precedingVersionNode );
+ } else {
+ return null;
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ public VersionableItem getSucceedingVersion() throws RulesRepositoryException {
+ try {
+ Node succeedingVersionNode = this.getSucceedingVersionNode();
+ if ( succeedingVersionNode != null ) {
+ return new PackageItem( this.rulesRepository,
+ succeedingVersionNode );
+ } else {
+ return null;
+ }
+ } catch ( Exception e ) {
+ log.error( "Caught exception",
+ e );
+ throw new RulesRepositoryException( e );
+ }
+ }
+
+ /**
+ * This iterates over nodes and produces RuleItem's.
+ * Also allows "skipping" of results to jump to certain items,
+ * as per JCRs "skip".
+ */
+ static class RuleItemIterator
+ implements
+ Iterator {
+
+ private NodeIterator it;
+ private RulesRepository rulesRepository;
+
+ public RuleItemIterator(NodeIterator nodes,
+ RulesRepository repo) {
+ this.it = nodes;
+ this.rulesRepository = repo;
+ }
+
+ public boolean hasNext() {
+ return it.hasNext();
+ }
+
+ public Object next() {
+ return new AssetItem( rulesRepository,
+ (Node) it.next() );
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException( "You can't remove a rule this way." );
+ }
+
+ /**
+ * @param i The number of rules to skip.
+ */
+ public void skip(int i) {
+ it.skip( i );
+ }
+
+ }
+
+
+ /**
+ * This will return a list of rules for a given state.
+ * It works through the rules that belong to this package, and
+ * if they are not in the correct state, walks backwards until it finds one
+ * in the correct state.
+ *
+ * If it walks all the way back up the versions looking for the "latest"
+ * version with the appropriate state, and can't find one,
+ * that asset is not included in the result.
+ */
+ public Iterator getRules(final StateItem state) {
+ final Iterator rules = getRules();
+
+ List result = new ArrayList();
+ while(rules.hasNext()) {
+ AssetItem head = (AssetItem) rules.next();
+ if (head.sameState( state )) {
+ result.add( head );
+ } else {
+ Iterator prev = head.getPredecessorVersionsIterator();
+ while (prev.hasNext()) {
+ AssetItem prevRule = (AssetItem) prev.next();
+ if (prevRule.sameState( state )) {
+ result.add( prevRule );
+ break;
+ }
+ }
+ }
+ }
+ return result.iterator();
+ }
+
+ /**
+ * This will create a new version of a package, effectively freezing the state.
+ * This means in the "head" version of the package, rules can be added
+ * removed, without effecting the baseline that was created.
+ */
+ public void createBaseline(String comment,
+ StateItem state) {
+ Iterator rules = getRules();
+ while(rules.hasNext()) {
+ AssetItem rule = (AssetItem) rules.next();
+ rule.updateState( state );
+ rule.checkin( comment );
+ }
+
+ checkin( comment );
+ try {
+ this.node.checkout();
+ } catch ( RepositoryException e ) {
+ throw new RulesRepositoryException("Unable to check out package node after creating a new baseline.", e);
+ }
+
+ }
+}
\ No newline at end of file
Deleted: labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RuleItem.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RuleItem.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RuleItem.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -1,342 +0,0 @@
-package org.drools.repository;
-
-import java.util.ArrayList;
-import java.util.Calendar;
-import java.util.Iterator;
-import java.util.List;
-
-import javax.jcr.AccessDeniedException;
-import javax.jcr.ItemExistsException;
-import javax.jcr.ItemNotFoundException;
-import javax.jcr.Node;
-import javax.jcr.PathNotFoundException;
-import javax.jcr.Property;
-import javax.jcr.RepositoryException;
-import javax.jcr.Value;
-import javax.jcr.lock.LockException;
-import javax.jcr.nodetype.ConstraintViolationException;
-import javax.jcr.version.VersionException;
-
-import org.apache.log4j.Logger;
-
-/**
- * The RuleItem class is used to abstract away the details of the underlying JCR repository.
- * It is used to pass information about rules stored in the repository.
- *
- * @author btruitt
- */
-public class RuleItem extends CategorisableItem {
- private Logger log = Logger.getLogger( RuleItem.class );
-
- /**
- * The name of the DSL property on the rule node type
- */
- public static final String DSL_PROPERTY_NAME = "drools:dslReference";
-
- /**
- * The name of the rule node type
- */
- public static final String RULE_NODE_TYPE_NAME = "drools:ruleNodeType";
-
- public static final String RULE_CONTENT_PROPERTY_NAME = "drools:content";
-
- public static final String RULE_CONTENT_URI_PROPERTY_NAME = "drools:contentURI";
-
- /**
- * The name of the date effective property on the rule node type
- */
- public static final String DATE_EFFECTIVE_PROPERTY_NAME = "drools:dateEffective";
-
- /**
- * The name of the date expired property on the rule node type
- */
- public static final String DATE_EXPIRED_PROPERTY_NAME = "drools:dateExpired";
-
- public static final String PACKAGE_NAME_PROPERTY = "drools:packageName";
-
- /**
- * Constructs a RuleItem object, setting its node attribute to the specified node.
- *
- * @param rulesRepository the rulesRepository that instantiated this object
- * @param node the node in the repository that this RuleItem corresponds to
- * @throws RulesRepositoryException
- */
- public RuleItem(RulesRepository rulesRepository,
- Node node) throws RulesRepositoryException {
- super( rulesRepository,
- node );
-
- try {
- //make sure this node is a rule node
- if ( !(this.node.getPrimaryNodeType().getName().equals( RULE_NODE_TYPE_NAME ) || isHistoricalVersion()) ) {
- String message = this.node.getName() + " is not a node of type " + RULE_NODE_TYPE_NAME + " nor nt:version. It is a node of type: " + this.node.getPrimaryNodeType().getName();
- log.error( message );
- throw new RulesRepositoryException( message );
- }
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * returns the contents of the rule node.
- * It there is a URI, this may need to access the external resource
- * to grab/sync the latest, but in any case, it should be the real content.
- */
- public String getRuleContent() throws RulesRepositoryException {
- try {
- Node ruleNode = getVersionContentNode();
- if ( ruleNode.hasProperty( RULE_CONTENT_PROPERTY_NAME ) ) {
- Property data = ruleNode.getProperty( RULE_CONTENT_PROPERTY_NAME );
- return data.getValue().getString();
-
- } else {
- return null;
- }
- } catch ( Exception e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * returns the URI for where the rules content is stored.
- * Rule content may be stored in an external repository,
- * such as subversion. This URI will contain information for
- * how to get to the exact version that maps to this rule node.
- */
- public String getRuleContentURI() throws RulesRepositoryException {
- try {
- Node ruleNode = getVersionContentNode();
- if ( ruleNode.hasProperty( RULE_CONTENT_URI_PROPERTY_NAME ) ) {
- Property data = ruleNode.getProperty( RULE_CONTENT_URI_PROPERTY_NAME );
- return data.getValue().getString();
- } else {
- return "";
- }
-
- } catch ( Exception e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * @return the date the rule becomes effective
- * @throws RulesRepositoryException
- */
- public Calendar getDateEffective() throws RulesRepositoryException {
- try {
- Node ruleNode = getVersionContentNode();
-
- Property dateEffectiveProperty = ruleNode.getProperty( DATE_EFFECTIVE_PROPERTY_NAME );
- return dateEffectiveProperty.getDate();
- } catch ( PathNotFoundException e ) {
- // doesn't have this property
- return null;
- } catch ( Exception e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Creates a new version of this object's rule node, updating the effective date for the
- * rule node.
- *
- * @param newDateEffective the new effective date for the rule
- * @throws RulesRepositoryException
- */
- public void updateDateEffective(Calendar newDateEffective) throws RulesRepositoryException {
- checkIsUpdateable();
- checkout();
- try {
- this.node.setProperty( DATE_EFFECTIVE_PROPERTY_NAME,
- newDateEffective );
- } catch ( RepositoryException e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * @return the date the rule becomes expired
- * @throws RulesRepositoryException
- */
- public Calendar getDateExpired() throws RulesRepositoryException {
- try {
- Node ruleNode = getVersionContentNode();
-
- Property dateExpiredProperty = ruleNode.getProperty( DATE_EXPIRED_PROPERTY_NAME );
- return dateExpiredProperty.getDate();
- } catch ( PathNotFoundException e ) {
- // doesn't have this property
- return null;
- } catch ( Exception e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Creates a new version of this object's rule node, updating the expired date for the
- * rule node.
- *
- * @param newDateExpired the new expired date for the rule
- * @throws RulesRepositoryException
- */
- public void updateDateExpired(Calendar newDateExpired) throws RulesRepositoryException {
- checkout();
-
- try {
- this.node.setProperty( DATE_EXPIRED_PROPERTY_NAME,
- newDateExpired );
- } catch ( Exception e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * This will update the rules content (checking it out if it is not already).
- * This will not save the session or create a new version of the node
- * (this has to be done seperately, as several properties may change as part of one edit).
- */
- public RuleItem updateRuleContent(String newRuleContent) throws RulesRepositoryException {
- checkout();
- try {
- this.node.setProperty( RULE_CONTENT_PROPERTY_NAME,
- newRuleContent );
- return this;
- } catch ( RepositoryException e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * The URI represents a location for
- */
- public void updateRuleContentURI(String newURI) throws RulesRepositoryException {
- checkout();
- try {
- this.node.setProperty( RULE_CONTENT_URI_PROPERTY_NAME,
- newURI );
- } catch ( RepositoryException e ) {
- log.error( "Caught Exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Gets a DslItem object corresponding to the DSL reference from the node that this object
- * encapsulates.
- *
- * @return a DslItem object corresponding to the DSL reference for this rule node. If there is
- * no DSL node referenced from this object's node, then null.
- * @throws RulesRepositoryException
- */
- public DslItem getDsl() throws RulesRepositoryException {
- try {
- Property dslProperty = getVersionContentNode().getProperty( DSL_PROPERTY_NAME );
- Node dslNode = this.node.getSession().getNodeByUUID( dslProperty.getString() );
- return new DslItem( this.rulesRepository,
- dslNode );
- } catch ( PathNotFoundException e ) {
- //not set
- return null;
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Nicely formats the information contained by the node that this object encapsulates
- */
- public String toString() {
- try {
- StringBuffer returnString = new StringBuffer();
- returnString.append( "Content of rule item named '" + this.getName() + "':\n" );
- returnString.append( "Content: " + this.getRuleContent() + "\n" );
- returnString.append( "Content URI: " + this.getRuleContentURI() + "\n" );
- returnString.append( "------\n" );
-
- returnString.append( "Date Effective: " + this.getDateEffective() + "\n" );
- returnString.append( "Date Expired: " + this.getDateExpired() + "\n" );
- returnString.append( "------\n" );
-
- returnString.append( "Rule state: " );
- StateItem stateItem = this.getState();
- if ( stateItem != null ) {
- returnString.append( this.getState().getName() + "\n" );
- } else {
- returnString.append( "NO STATE SET FOR THIS NODE\n" );
- }
- returnString.append( "------\n" );
-
- returnString.append( "Rule tags:\n" );
- for ( Iterator it = this.getCategories().iterator(); it.hasNext(); ) {
- CategoryItem currentTag = (CategoryItem) it.next();
- returnString.append( currentTag.getName() + "\n" );
- }
- returnString.append( "--------------\n" );
- return returnString.toString();
- } catch ( Exception e ) {
- throw new RulesRepositoryException( e );
- }
- }
-
- public VersionableItem getPrecedingVersion() throws RulesRepositoryException {
- try {
- Node precedingVersionNode = this.getPrecedingVersionNode();
- if ( precedingVersionNode != null ) {
- return new RuleItem( this.rulesRepository,
- precedingVersionNode );
- } else {
- return null;
- }
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- public VersionableItem getSucceedingVersion() throws RulesRepositoryException {
- try {
- Node succeedingVersionNode = this.getSucceedingVersionNode();
- if ( succeedingVersionNode != null ) {
- return new RuleItem( this.rulesRepository,
- succeedingVersionNode );
- } else {
- return null;
- }
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Get the name of the enclosing package.
- * As assets are stored in versionable subfolders, this means walking up 2 levels in the
- * hierarchy to get to the enclosing "package" node.
- */
- public String getPackageName() {
- return super.getStringProperty( PACKAGE_NAME_PROPERTY );
- }
-
-}
\ No newline at end of file
Deleted: labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageItem.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageItem.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageItem.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -1,628 +0,0 @@
-package org.drools.repository;
-
-import java.util.ArrayList;
-import java.util.Calendar;
-import java.util.Iterator;
-import java.util.List;
-
-import javax.jcr.ItemExistsException;
-import javax.jcr.Node;
-import javax.jcr.NodeIterator;
-import javax.jcr.PathNotFoundException;
-import javax.jcr.RepositoryException;
-import javax.jcr.UnsupportedRepositoryOperationException;
-import javax.jcr.Value;
-import javax.jcr.ValueFactory;
-
-import org.apache.log4j.Logger;
-
-/**
- * A ruleSet object aggregates a set of rules. This is advantageous for systems using the JBoss Rules
- * engine where the application might make use of many related rules.
- * <p>
- * A rule set refers to rule nodes within the RulesRepository. It can either have the reference to a
- * specific rule follow the head version of that rule, or have this reference continue to refer to
- * a specific version of that rule even when a new version of the rule is checked into the repository
- *
- * @author btruitt
- */
-public class RulePackageItem extends VersionableItem {
- private static Logger log = Logger.getLogger( RulePackageItem.class );
-
- /**
- * This is the name of the rules "subfolder" where rules are kept
- * for this package.
- */
- public static final String RULES_FOLDER_NAME = "rules";
-
- /**
- * The name of the reference property on the rulepackage_node_type type node that objects of
- * this type hold a reference to
- */
- public static final String RULE_REFERENCE_PROPERTY_NAME = "drools:ruleReference";
-
- /**
- * The name of the reference property on the rulepackage_node_type type node that objects of
- * this type hold a reference to
- */
- public static final String FUNCTION_REFERENCE_PROPERTY_NAME = "drools:functionReference";
-
- /**
- * The name of the rule package node type
- */
- public static final String RULE_PACKAGE_TYPE_NAME = "drools:rulepackageNodeType";
-
- /**
- * The folder where functions are kept
- */
- public static final String FUNCTION_FOLDER_NAME = "functions";
-
- /**
- * Constructs an object of type RulePackageItem corresponding the specified node
- * @param rulesRepository the rulesRepository that instantiated this object
- * @param node the node to which this object corresponds
- * @throws RulesRepositoryException
- */
- public RulePackageItem(RulesRepository rulesRepository,
- Node node) throws RulesRepositoryException {
- super( rulesRepository,
- node );
-
- try {
- //make sure this node is a rule package node
- if ( !(this.node.getPrimaryNodeType().getName().equals( RULE_PACKAGE_TYPE_NAME ) ||
- isHistoricalVersion()) ) {
- String message = this.node.getName() + " is not a node of type " + RULE_PACKAGE_TYPE_NAME + ". It is a node of type: " + this.node.getPrimaryNodeType().getName();
- log.error( message );
- throw new RulesRepositoryException( message );
- }
- } catch ( Exception e ) {
- log.error( "Caught exception: " + e );
- throw new RulesRepositoryException( e );
- }
- }
-
-
- /**
- * Adds a rule to the current package with no category (not recommended !).
- * Without categories, its going to be hard to find rules later on
- * (unless packages are enough for you).
- */
- public RuleItem addRule(String ruleName, String description) {
- return addRule(ruleName, description, null);
- }
-
-
- /**
- * This adds a rule to the current physical package (you can move it later).
- * With the given category
- */
- public RuleItem addRule(String ruleName,
- String description, String initialCategory) {
- Node ruleNode;
- try {
-
- Node rulesFolder = this.node.getNode( RULES_FOLDER_NAME );
- ruleNode = rulesFolder.addNode( ruleName,
- RuleItem.RULE_NODE_TYPE_NAME );
- ruleNode.setProperty( RuleItem.TITLE_PROPERTY_NAME,
- ruleName );
-
- ruleNode.setProperty( RuleItem.DESCRIPTION_PROPERTY_NAME,
- description );
- ruleNode.setProperty( RuleItem.FORMAT_PROPERTY_NAME,
- RuleItem.RULE_FORMAT );
-
-
- ruleNode.setProperty( VersionableItem.CHECKIN_COMMENT,
- "Initial" );
-
- Calendar lastModified = Calendar.getInstance();
-
- ruleNode.setProperty( RuleItem.LAST_MODIFIED_PROPERTY_NAME, lastModified );
- ruleNode.setProperty( RuleItem.CREATION_DATE_PROPERTY, lastModified );
-
- ruleNode.setProperty( RuleItem.PACKAGE_NAME_PROPERTY, this.getName() );
-
- RuleItem rule = new RuleItem( this.rulesRepository, ruleNode );
-
- if (initialCategory != null) {
- rule.addCategory( initialCategory );
- }
-
- return rule;
-
- } catch ( Exception e ) {
- if ( e instanceof RuntimeException ) {
- throw (RuntimeException) e;
- } else if ( e instanceof ItemExistsException ) {
- throw new RulesRepositoryException( "A rule of that name already exists in that package.",
- e );
- } else {
- throw new RulesRepositoryException( e );
- }
- }
-
- }
-
- /** Remove a rule by name */
- public void removeRule(String name) {
- try {
- this.node.getNode( RULES_FOLDER_NAME + "/" + name ).remove();
- } catch ( RepositoryException e ) {
- throw new RulesRepositoryException( e );
- }
- }
-
-
-
- // The following should be kept for reference on how to add a reference that
- //is either locked to a version or follows head - FOR SHARING RULES
- // /**
- // * Adds a rule to the rule package node this object represents. The reference to the rule
- // * will optionally follow the head version of the specified rule's node or the specific
- // * current version.
- // *
- // * @param ruleItem the ruleItem corresponding to the node to add to the rule package this
- // * object represents
- // * @param followRuleHead if true, the reference to the rule node will follow the head version
- // * of the node, even if new versions are added. If false, will refer
- // * specifically to the current version.
- // * @throws RulesRepositoryException
- // */
- // public void addRuleReference(RuleItem ruleItem, boolean followRuleHead) throws RulesRepositoryException {
- // try {
- // ValueFactory factory = this.node.getSession().getValueFactory();
- // int i = 0;
- // Value[] newValueArray = null;
- //
- // try {
- // Value[] oldValueArray = this.node.getProperty(RULE_REFERENCE_PROPERTY_NAME).getValues();
- // newValueArray = new Value[oldValueArray.length + 1];
- //
- // for(i=0; i<oldValueArray.length; i++) {
- // newValueArray[i] = oldValueArray[i];
- // }
- // }
- // catch(PathNotFoundException e) {
- // //the property has not been created yet. do so now
- // newValueArray = new Value[1];
- // }
- // finally {
- // if(newValueArray != null) { //just here to make the compiler happy
- // if(followRuleHead) {
- // newValueArray[i] = factory.createValue(ruleItem.getNode());
- // }
- // else {
- // //this is the magic that ties it to a specific version
- // newValueArray[i] = factory.createValue(ruleItem.getNode().getBaseVersion());
- // }
- // this.node.checkout();
- // this.node.setProperty(RULE_REFERENCE_PROPERTY_NAME, newValueArray);
- // this.node.getSession().save();
- // this.node.checkin();
- // }
- // else {
- // throw new RulesRepositoryException("Unexpected null pointer for newValueArray");
- // }
- // }
- // }
- // catch(UnsupportedRepositoryOperationException e) {
- // String message = "";
- // try {
- // message = "Error: Caught UnsupportedRepositoryOperationException when attempting to get base version for rule: " + ruleItem.getNode().getName() + ". Are you sure your JCR repository supports versioning? ";
- // log.error(message + e);
- // }
- // catch (RepositoryException e1) {
- // log.error("Caught exception: " + e1);
- // throw new RulesRepositoryException(message, e1);
- // }
- // log.error("Caught exception: " + e);
- // throw new RulesRepositoryException(e);
- // }
- // catch(Exception e) {
- // log.error("Caught exception: " + e);
- // throw new RulesRepositoryException(e);
- // }
- // }
-
- /**
- * Adds a function to the rule package node this object represents. The reference to the
- * function node will follow the head version of the specified node.
- *
- * @param functionItem the functionItem corresponding to the node to add to the rule package this
- * object represents
- * @throws RulesRepositoryException
- */
- public void addFunction(FunctionItem functionItem) throws RulesRepositoryException {
- this.addFunction( functionItem,
- true );
- }
-
- /**
- * Adds a function to the rule package node this object represents. The reference to the function
- * will optionally follow the head version of the specified node or the specific current version.
- *
- * @param functionItem the functionItem corresponding to the node to add to the rule package this
- * object represents
- * @param followRuleHead if true, the reference to the function node will follow the head version
- * of the node, even if new versions are added. If false, will refer
- * specifically to the current version.
- * @throws RulesRepositoryException
- */
- public void addFunction(FunctionItem functionItem,
- boolean followFunctionHead) throws RulesRepositoryException {
- try {
- ValueFactory factory = this.node.getSession().getValueFactory();
- int i = 0;
- Value[] newValueArray = null;
-
- try {
- Value[] oldValueArray = this.node.getProperty( FUNCTION_REFERENCE_PROPERTY_NAME ).getValues();
- newValueArray = new Value[oldValueArray.length + 1];
-
- for ( i = 0; i < oldValueArray.length; i++ ) {
- newValueArray[i] = oldValueArray[i];
- }
- } catch ( PathNotFoundException e ) {
- //the property has not been created yet. do so now
- newValueArray = new Value[1];
- } finally {
- if ( newValueArray != null ) { //just here to make the compiler happy
- if ( followFunctionHead ) {
- newValueArray[i] = factory.createValue( functionItem.getNode() );
- } else {
- newValueArray[i] = factory.createValue( functionItem.getNode().getBaseVersion() );
- }
- this.node.checkout();
- this.node.setProperty( FUNCTION_REFERENCE_PROPERTY_NAME,
- newValueArray );
- this.node.getSession().save();
- this.node.checkin();
- } else {
- throw new RulesRepositoryException( "Unexpected null pointer for newValueArray" );
- }
- }
- } catch ( UnsupportedRepositoryOperationException e ) {
- String message = "";
- try {
- message = "Error: Caught UnsupportedRepositoryOperationException when attempting to get base version for function: " + functionItem.getNode().getName() + ". Are you sure your JCR repository supports versioning? ";
- log.error( message + e );
- } catch ( RepositoryException e1 ) {
- log.error( "Caught exception: " + e1 );
- throw new RulesRepositoryException( message,
- e1 );
- }
- log.error( "Caught exception: " + e );
- throw new RulesRepositoryException( e );
- } catch ( Exception e ) {
- log.error( "Caught exception: " + e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Removes the specified rule from the rule package node this object represents.
- *
- * @param ruleItem the ruleItem corresponding to the node to remove from the rule package
- * this object represents
- * @throws RulesRepositoryException
- */
- public void removeRuleReference(RuleItem ruleItem) throws RulesRepositoryException {
- try {
- Value[] oldValueArray = this.node.getProperty( RULE_REFERENCE_PROPERTY_NAME ).getValues();
- Value[] newValueArray = new Value[oldValueArray.length - 1];
-
- boolean wasThere = false;
-
- int j = 0;
- for ( int i = 0; i < oldValueArray.length; i++ ) {
- Node ruleNode = this.node.getSession().getNodeByUUID( oldValueArray[i].getString() );
- RuleItem currentRuleItem = new RuleItem( this.rulesRepository,
- ruleNode );
- if ( currentRuleItem.equals( ruleItem ) ) {
- wasThere = true;
- } else {
- newValueArray[j] = oldValueArray[i];
- j++;
- }
- }
-
- if ( !wasThere ) {
- return;
- } else {
- this.node.checkout();
- this.node.setProperty( RULE_REFERENCE_PROPERTY_NAME,
- newValueArray );
- this.node.getSession().save();
- this.node.checkin();
- }
- } catch ( PathNotFoundException e ) {
- //the property has not been created yet.
- return;
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Removes the specified function from the rule package node this object represents.
- *
- * @param functionItem the functionItem corresponding to the node to remove from the rule package
- * this object represents
- * @throws RulesRepositoryException
- */
- public void removeFunction(FunctionItem functionItem) throws RulesRepositoryException {
- try {
- Value[] oldValueArray = this.node.getProperty( FUNCTION_REFERENCE_PROPERTY_NAME ).getValues();
- Value[] newValueArray = new Value[oldValueArray.length - 1];
-
- boolean wasThere = false;
-
- int j = 0;
- for ( int i = 0; i < oldValueArray.length; i++ ) {
- Node functionNode = this.node.getSession().getNodeByUUID( oldValueArray[i].getString() );
- FunctionItem currentFunctionItem = new FunctionItem( this.rulesRepository,
- functionNode );
- if ( currentFunctionItem.equals( functionItem ) ) {
- wasThere = true;
- } else {
- newValueArray[j] = oldValueArray[i];
- j++;
- }
- }
-
- if ( !wasThere ) {
- return;
- } else {
- this.node.checkout();
- this.node.setProperty( FUNCTION_REFERENCE_PROPERTY_NAME,
- newValueArray );
- this.node.getSession().save();
- this.node.checkin();
- }
- } catch ( PathNotFoundException e ) {
- //the property has not been created yet.
- return;
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * Gets a list of FunctionItem objects for each function node in this rule package
- *
- * @return the List object holding the FunctionItem objects in this rule package
- * @throws RulesRepositoryException
- */
- public List getFunctions() throws RulesRepositoryException {
- try {
- Value[] valueArray = this.node.getProperty( FUNCTION_REFERENCE_PROPERTY_NAME ).getValues();
- List returnList = new ArrayList();
-
- for ( int i = 0; i < valueArray.length; i++ ) {
- Node functionNode = this.node.getSession().getNodeByUUID( valueArray[i].getString() );
- returnList.add( new FunctionItem( this.rulesRepository,
- functionNode ) );
- }
- return returnList;
- } catch ( PathNotFoundException e ) {
- //the property has not been created yet.
- return new ArrayList();
- } catch ( Exception e ) {
- log.error( "Caught exception: " + e );
- throw new RulesRepositoryException( e );
- }
- }
-
- // /**
- // * Gets a list of RuleItem objects for each rule node in this rule package
- // *
- // * @return the List object holding the RuleItem objects in this rule package
- // * @throws RulesRepositoryException
- // */
- // public List getRules() throws RulesRepositoryException {
- // try {
- // Value[] valueArray = this.node.getProperty(RULE_REFERENCE_PROPERTY_NAME).getValues();
- // List returnList = new ArrayList();
- //
- // for(int i=0; i<valueArray.length; i++) {
- // Node ruleNode = this.node.getSession().getNodeByUUID(valueArray[i].getString());
- // returnList.add(new RuleItem(this.rulesRepository, ruleNode));
- // }
- // return returnList;
- // }
- // catch(PathNotFoundException e) {
- // //the property has not been created yet.
- // return new ArrayList();
- // }
- // catch(Exception e) {
- // log.error("Caught exception: " + e);
- // throw new RulesRepositoryException(e);
- // }
- // }
-
- /** Return an iterator for the rules in this package */
- public Iterator getRules() {
- try {
- Node content = getVersionContentNode();
- RuleItemIterator it = new RuleItemIterator( content.getNode( RULES_FOLDER_NAME ).getNodes(),
- this.rulesRepository );
- return it;
- } catch ( PathNotFoundException e ) {
- throw new RulesRepositoryException( e );
- } catch ( RepositoryException e ) {
- throw new RulesRepositoryException( e );
- }
-
- }
-
- /**
- * Load a specific rule asset by name.
- */
- public RuleItem loadRule(String name) {
-
- try {
- Node content = getVersionContentNode();
- return new RuleItem(
- this.rulesRepository,
- content.getNode( RULES_FOLDER_NAME ).getNode( name ));
- } catch ( RepositoryException e ) {
- throw new RulesRepositoryException(e);
- }
-
- }
-
- /**
- * Nicely formats the information contained by the node that this object encapsulates
- */
- public String toString() {
- try {
- StringBuffer returnString = new StringBuffer();
- returnString.append( "Content of the rule package named " + this.node.getName() + ":" );
- returnString.append( "Description: " + this.getDescription() + "\n" );
- returnString.append( "Format: " + this.getFormat() + "\n" );
- returnString.append( "Last modified: " + this.getLastModified() + "\n" );
- returnString.append( "Title: " + this.getTitle() + "\n" );
- returnString.append( "----\n" );
-
- return returnString.toString();
- } catch ( Exception e ) {
- log.error( "Caught Exception",
- e );
- return null;
- }
- }
-
- public VersionableItem getPrecedingVersion() throws RulesRepositoryException {
- try {
- Node precedingVersionNode = this.getPrecedingVersionNode();
- if ( precedingVersionNode != null ) {
- return new RulePackageItem( this.rulesRepository,
- precedingVersionNode );
- } else {
- return null;
- }
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- public VersionableItem getSucceedingVersion() throws RulesRepositoryException {
- try {
- Node succeedingVersionNode = this.getSucceedingVersionNode();
- if ( succeedingVersionNode != null ) {
- return new RulePackageItem( this.rulesRepository,
- succeedingVersionNode );
- } else {
- return null;
- }
- } catch ( Exception e ) {
- log.error( "Caught exception",
- e );
- throw new RulesRepositoryException( e );
- }
- }
-
- /**
- * This iterates over nodes and produces RuleItem's.
- * Also allows "skipping" of results to jump to certain items,
- * as per JCRs "skip".
- */
- static class RuleItemIterator
- implements
- Iterator {
-
- private NodeIterator it;
- private RulesRepository rulesRepository;
-
- public RuleItemIterator(NodeIterator nodes,
- RulesRepository repo) {
- this.it = nodes;
- this.rulesRepository = repo;
- }
-
- public boolean hasNext() {
- return it.hasNext();
- }
-
- public Object next() {
- return new RuleItem( rulesRepository,
- (Node) it.next() );
- }
-
- public void remove() {
- throw new UnsupportedOperationException( "You can't remove a rule this way." );
- }
-
- /**
- * @param i The number of rules to skip.
- */
- public void skip(int i) {
- it.skip( i );
- }
-
- }
-
-
- /**
- * This will return a list of rules for a given state.
- * It works through the rules that belong to this package, and
- * if they are not in the correct state, walks backwards until it finds one
- * in the correct state.
- *
- * If it walks all the way back up the versions looking for the "latest"
- * version with the appropriate state, and can't find one,
- * that asset is not included in the result.
- */
- public Iterator getRules(final StateItem state) {
- final Iterator rules = getRules();
-
- List result = new ArrayList();
- while(rules.hasNext()) {
- RuleItem head = (RuleItem) rules.next();
- if (head.sameState( state )) {
- result.add( head );
- } else {
- Iterator prev = head.getPredecessorVersionsIterator();
- while (prev.hasNext()) {
- RuleItem prevRule = (RuleItem) prev.next();
- if (prevRule.sameState( state )) {
- result.add( prevRule );
- break;
- }
- }
- }
- }
- return result.iterator();
- }
-
- /**
- * This will create a new version of a package, effectively freezing the state.
- * This means in the "head" version of the package, rules can be added
- * removed, without effecting the baseline that was created.
- */
- public void createBaseline(String comment,
- StateItem state) {
- Iterator rules = getRules();
- while(rules.hasNext()) {
- RuleItem rule = (RuleItem) rules.next();
- rule.updateState( state );
- rule.checkin( comment );
- }
-
- checkin( comment );
- try {
- this.node.checkout();
- } catch ( RepositoryException e ) {
- throw new RulesRepositoryException("Unable to check out package node after creating a new baseline.", e);
- }
-
- }
-}
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageIterator.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageIterator.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulePackageIterator.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -27,7 +27,7 @@
}
public Object next() {
- return new RulePackageItem(this.repository, (Node) this.packageNodeIterator.next());
+ return new PackageItem(this.repository, (Node) this.packageNodeIterator.next());
}
public void remove() {
Modified: labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulesRepository.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulesRepository.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/main/java/org/drools/repository/RulesRepository.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -509,12 +509,12 @@
* @param name the name of the package to load
* @return a RulePackageItem object
*/
- public RulePackageItem loadRulePackage(String name) throws RulesRepositoryException {
+ public PackageItem loadRulePackage(String name) throws RulesRepositoryException {
try {
Node folderNode = this.getAreaNode(RULE_PACKAGE_AREA);
Node rulePackageNode = folderNode.getNode(name);
- return new RulePackageItem(this, rulePackageNode);
+ return new PackageItem(this, rulePackageNode);
}
catch(Exception e) {
log.error("Unable to load a rule package. ", e);
@@ -529,7 +529,7 @@
/**
* This will return or create the default package for rules that have no home yet.
*/
- public RulePackageItem loadDefaultRulePackage() throws RulesRepositoryException {
+ public PackageItem loadDefaultRulePackage() throws RulesRepositoryException {
Node folderNode = this.getAreaNode( RULE_PACKAGE_AREA );
try {
if (folderNode.hasNode( DEFAULT_PACKAGE )) {
@@ -550,10 +550,10 @@
* @return a RulePackageItem object
* @throws RulesRepositoryException
*/
- public RulePackageItem loadRulePackageByUUID(String uuid) throws RulesRepositoryException {
+ public PackageItem loadRulePackageByUUID(String uuid) throws RulesRepositoryException {
try {
Node rulePackageNode = this.session.getNodeByUUID(uuid);
- return new RulePackageItem(this, rulePackageNode);
+ return new PackageItem(this, rulePackageNode);
}
catch (Exception e) {
log.error("Unable to load a rule package by UUID. ", e);
@@ -569,10 +569,10 @@
/**
* Loads a rule by its UUID (generally the fastest way to load something).
*/
- public RuleItem loadRuleByUUID(String uuid) {
+ public AssetItem loadRuleByUUID(String uuid) {
try {
Node rulePackageNode = this.session.getNodeByUUID(uuid);
- return new RuleItem(this, rulePackageNode);
+ return new AssetItem(this, rulePackageNode);
}
catch (RepositoryException e) {
log.error("Unable to load a rule asset by UUID.", e);
@@ -593,32 +593,32 @@
* @return a RulePackageItem, encapsulating the created node
* @throws RulesRepositoryException
*/
- public RulePackageItem createRulePackage(String name, String description) throws RulesRepositoryException {
+ public PackageItem createRulePackage(String name, String description) throws RulesRepositoryException {
Node folderNode = this.getAreaNode(RULE_PACKAGE_AREA);
try {
//create the node - see section 6.7.22.6 of the spec
- Node rulePackageNode = folderNode.addNode(name, RulePackageItem.RULE_PACKAGE_TYPE_NAME);
+ Node rulePackageNode = folderNode.addNode(name, PackageItem.RULE_PACKAGE_TYPE_NAME);
- rulePackageNode.addNode( RulePackageItem.RULES_FOLDER_NAME, "drools:versionableAssetFolder" );
- rulePackageNode.addNode( RulePackageItem.FUNCTION_FOLDER_NAME, "drools:versionableAssetFolder" );
+ rulePackageNode.addNode( PackageItem.RULES_FOLDER_NAME, "drools:versionableAssetFolder" );
+ rulePackageNode.addNode( PackageItem.FUNCTION_FOLDER_NAME, "drools:versionableAssetFolder" );
- rulePackageNode.setProperty(RulePackageItem.TITLE_PROPERTY_NAME, name);
+ rulePackageNode.setProperty(PackageItem.TITLE_PROPERTY_NAME, name);
- rulePackageNode.setProperty(RuleItem.DESCRIPTION_PROPERTY_NAME, description);
- rulePackageNode.setProperty(RuleItem.FORMAT_PROPERTY_NAME, RuleItem.RULE_PACKAGE_FORMAT);
+ rulePackageNode.setProperty(AssetItem.DESCRIPTION_PROPERTY_NAME, description);
+ rulePackageNode.setProperty(AssetItem.FORMAT_PROPERTY_NAME, AssetItem.RULE_PACKAGE_FORMAT);
Calendar lastModified = Calendar.getInstance();
- rulePackageNode.setProperty(RulePackageItem.LAST_MODIFIED_PROPERTY_NAME, lastModified);
+ rulePackageNode.setProperty(PackageItem.LAST_MODIFIED_PROPERTY_NAME, lastModified);
- rulePackageNode.setProperty( RulePackageItem.CREATION_DATE_PROPERTY, lastModified );
+ rulePackageNode.setProperty( PackageItem.CREATION_DATE_PROPERTY, lastModified );
this.session.save();
- return new RulePackageItem(this, rulePackageNode);
+ return new PackageItem(this, rulePackageNode);
} catch (ItemExistsException e) {
throw new RulesRepositoryException("A package name must be unique.", e);
} catch (RepositoryException e) {
@@ -703,8 +703,8 @@
while(it.hasNext()) {
Property ruleLink = (Property) it.next();
Node parentNode = ruleLink.getParent();
- if(parentNode.getPrimaryNodeType().getName().equals(RuleItem.RULE_NODE_TYPE_NAME)) {
- results.add(new RuleItem(this, parentNode));
+ if(parentNode.getPrimaryNodeType().getName().equals(AssetItem.RULE_NODE_TYPE_NAME)) {
+ results.add(new AssetItem(this, parentNode));
}
}
return results;
@@ -766,18 +766,18 @@
*/
public void moveRuleItemPackage(String newPackage, String uuid, String explanation) {
try {
- RuleItem item = loadRuleByUUID( uuid );
+ AssetItem item = loadRuleByUUID( uuid );
String oldPackage = item.getPackageName();
- RulePackageItem sourcePkg = loadRulePackage( oldPackage );
- RulePackageItem destPkg = loadRulePackage( newPackage );
+ PackageItem sourcePkg = loadRulePackage( oldPackage );
+ PackageItem destPkg = loadRulePackage( newPackage );
String sourcePath = item.node.getPath();
- String destPath = destPkg.node.getPath() + "/" + RulePackageItem.RULES_FOLDER_NAME + "/" + item.getName();
+ String destPath = destPkg.node.getPath() + "/" + PackageItem.RULES_FOLDER_NAME + "/" + item.getName();
this.session.move(sourcePath , destPath );
item.checkout();
- item.node.setProperty( RuleItem.PACKAGE_NAME_PROPERTY, newPackage );
+ item.node.setProperty( AssetItem.PACKAGE_NAME_PROPERTY, newPackage );
item.checkin( explanation );
sourcePkg.checkin( explanation );
Modified: labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/DslItemTestCase.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/DslItemTestCase.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/DslItemTestCase.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -4,7 +4,7 @@
import junit.framework.TestCase;
import org.drools.repository.DslItem;
-import org.drools.repository.RuleItem;
+import org.drools.repository.AssetItem;
import org.drools.repository.RulesRepository;
import org.drools.repository.RulesRepositoryException;
@@ -32,7 +32,7 @@
//try constructing a DslItem object with the wrong node type
try {
//Get a reference to a node of the incorrect type
- RuleItem ruleItem1 = this.getRepo().loadDefaultRulePackage().addRule("test rule", "test guts");
+ AssetItem ruleItem1 = this.getRepo().loadDefaultRulePackage().addRule("test rule", "test guts");
//this should fail
DslItem dslItem2 = new DslItem(getRepo(), ruleItem1.getNode());
Modified: labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RuleItemTestCase.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RuleItemTestCase.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RuleItemTestCase.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -13,7 +13,7 @@
return RepositorySession.getRepository();
}
- private RulePackageItem getDefaultPackage() {
+ private PackageItem getDefaultPackage() {
return getRepo().loadDefaultRulePackage();
}
@@ -23,7 +23,7 @@
Thread.sleep(500); //MN: need this sleep to get the correct date
- RuleItem ruleItem1 = getDefaultPackage().addRule("testRuleItem", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testRuleItem", "test content");
assertNotNull(ruleItem1);
assertNotNull(ruleItem1.getNode());
@@ -42,7 +42,7 @@
try {
DslItem dslItem = getRepo().addDsl("testRuleItem", "content here");
- new RuleItem(getRepo(), dslItem.getNode());
+ new AssetItem(getRepo(), dslItem.getNode());
fail("Exception not thrown for node of type: " + dslItem.getNode().getPrimaryNodeType().getName());
}
catch(RulesRepositoryException e) {
@@ -55,7 +55,7 @@
public void testGetContent() {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetContent", "test content");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetContent", "test content");
ruleItem1.updateRuleContent( "test content" );
assertNotNull(ruleItem1);
@@ -64,7 +64,7 @@
}
public void testGetURI() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testGetURI", "blah");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testGetURI", "blah");
ruleItem1.updateRuleContentURI( "foo/bar" );
ruleItem1.checkin( "ha !" );
assertNotNull(ruleItem1);
@@ -73,7 +73,7 @@
}
public void testUpdateContent() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testUpdateContent", "test description");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testUpdateContent", "test description");
ruleItem1.updateRuleContent( "test content" );
ruleItem1.checkin( "yeah" );
@@ -85,7 +85,7 @@
assertEquals("yeah !", ruleItem1.getCheckinComment());
- RuleItem prev = (RuleItem) ruleItem1.getPredecessorVersionsIterator().next();
+ AssetItem prev = (AssetItem) ruleItem1.getPredecessorVersionsIterator().next();
assertEquals("test content", prev.getRuleContent());
assertFalse("yeah !".equals(prev.getCheckinComment()));
@@ -96,7 +96,7 @@
public void testCategories() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testAddTag", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testAddTag", "test content");
getRepo().loadCategory( "/" ).addCategory( "testAddTagTestTag", "description" );
@@ -115,7 +115,7 @@
//now test retrieve by tags
List result = getRepo().findRulesByCategory("testAddTagTestTag");
assertEquals(1, result.size());
- RuleItem retItem = (RuleItem) result.get( 0 );
+ AssetItem retItem = (AssetItem) result.get( 0 );
assertEquals("testAddTag", retItem.getName());
ruleItem1.updateRuleContent( "foo" );
@@ -125,11 +125,11 @@
assertEquals(1, result.size());
- ruleItem1 = (RuleItem) result.get( 0 );
+ ruleItem1 = (AssetItem) result.get( 0 );
assertEquals(2, ruleItem1.getCategories().size());
assertEquals("foo", ruleItem1.getRuleContent());
- RuleItem prev = (RuleItem) ruleItem1.getPrecedingVersion();
+ AssetItem prev = (AssetItem) ruleItem1.getPrecedingVersion();
assertNotNull(prev);
}
@@ -145,7 +145,7 @@
assertEquals(2, rules.size());
for ( Iterator iter = rules.iterator(); iter.hasNext(); ) {
- RuleItem element = (RuleItem) iter.next();
+ AssetItem element = (AssetItem) iter.next();
assertTrue(element.getName().startsWith( "testFindRulesByCategory" ));
}
@@ -153,7 +153,7 @@
public void testRemoveTag() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testRemoveTag", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testRemoveTag", "test content");
getRepo().loadCategory( "/" ).addCategory( "TestRemoveCategory", "description" );
@@ -176,7 +176,7 @@
}
public void testGetTags() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testGetTags", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testGetTags", "test content");
List tags = ruleItem1.getCategories();
assertNotNull(tags);
@@ -192,7 +192,7 @@
}
public void testSetStateString() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testSetStateString", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testSetStateString", "test content");
ruleItem1.updateState("TestState1");
assertNotNull(ruleItem1.getState());
@@ -205,7 +205,7 @@
}
public void testSetStateStateItem() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("foobar", "test description");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("foobar", "test description");
StateItem stateItem1 = getRepo().getState("TestState1");
ruleItem1.updateState(stateItem1);
@@ -220,7 +220,7 @@
}
public void testGetState() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testGetState", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testGetState", "test content");
StateItem stateItem1 = ruleItem1.getState();
assertNull(stateItem1);
@@ -236,14 +236,14 @@
public void testToString() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testToString", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testToString", "test content");
assertNotNull(ruleItem1.toString());
}
public void testGetLastModifiedOnCheckin() throws Exception {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testGetLastModified", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testGetLastModified", "test content");
Calendar cal = Calendar.getInstance();
long before = cal.getTimeInMillis();
@@ -266,7 +266,7 @@
public void testGetDateEffective() {
- RuleItem ruleItem1 = getDefaultPackage().addRule("testGetDateEffective", "test content");
+ AssetItem ruleItem1 = getDefaultPackage().addRule("testGetDateEffective", "test content");
//it should be initialized to null
assertTrue(ruleItem1.getDateEffective() == null);
@@ -281,7 +281,7 @@
public void testGetDateExpired() {
try {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetDateExpired", "test content");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetDateExpired", "test content");
//it should be initialized to null
assertTrue(ruleItem1.getDateExpired() == null);
@@ -300,7 +300,7 @@
public void testSaveAndCheckinDescriptionAndTitle() throws Exception {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetDescription", "");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetDescription", "");
ruleItem1.checkin( "version0" );
//it should be "" to begin with
@@ -337,7 +337,7 @@
public void testGetPrecedingVersion() {
getRepo().loadCategory( "/" ).addCategory( "foo", "ka" );
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetPrecedingVersion", "descr");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetPrecedingVersion", "descr");
ruleItem1.checkin( "version0" );
assertTrue(ruleItem1.getPrecedingVersion() == null);
@@ -348,7 +348,7 @@
ruleItem1.checkin( "boo" );
- RuleItem predecessorRuleItem = (RuleItem) ruleItem1.getPrecedingVersion();
+ AssetItem predecessorRuleItem = (AssetItem) ruleItem1.getPrecedingVersion();
assertNotNull(predecessorRuleItem);
@@ -357,7 +357,7 @@
ruleItem1.updateRuleContentURI( "foobar" );
ruleItem1.checkin( "two changes" );
- predecessorRuleItem = (RuleItem) ruleItem1.getPrecedingVersion();
+ predecessorRuleItem = (AssetItem) ruleItem1.getPrecedingVersion();
assertNotNull(predecessorRuleItem);
assertEquals(1, predecessorRuleItem.getCategories().size());
CategoryItem cat = (CategoryItem) predecessorRuleItem.getCategories().get( 0 );
@@ -375,22 +375,22 @@
ruleItem1.updateRuleContent("newer lhs");
ruleItem1.checkin( "another" );
- predecessorRuleItem = (RuleItem) ruleItem1.getPrecedingVersion();
+ predecessorRuleItem = (AssetItem) ruleItem1.getPrecedingVersion();
assertNotNull(predecessorRuleItem);
assertEquals("new content", predecessorRuleItem.getRuleContent());
- predecessorRuleItem = (RuleItem) predecessorRuleItem.getPrecedingVersion();
+ predecessorRuleItem = (AssetItem) predecessorRuleItem.getPrecedingVersion();
assertNotNull(predecessorRuleItem);
assertEquals("test content", predecessorRuleItem.getRuleContent());
}
public void testGetSucceedingVersion() {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetSucceedingVersion", "test description");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetSucceedingVersion", "test description");
ruleItem1.checkin( "version0" );
assertEquals("1", ruleItem1.getVersionNumber());
- RuleItem succeedingRuleItem = (RuleItem) ruleItem1.getSucceedingVersion();
+ AssetItem succeedingRuleItem = (AssetItem) ruleItem1.getSucceedingVersion();
assertTrue(succeedingRuleItem == null);
ruleItem1.updateRuleContent("new content");
@@ -398,16 +398,16 @@
assertEquals("2", ruleItem1.getVersionNumber());
- RuleItem predecessorRuleItem = (RuleItem) ruleItem1.getPrecedingVersion();
+ AssetItem predecessorRuleItem = (AssetItem) ruleItem1.getPrecedingVersion();
assertEquals(null, predecessorRuleItem.getRuleContent());
- succeedingRuleItem = (RuleItem) predecessorRuleItem.getSucceedingVersion();
+ succeedingRuleItem = (AssetItem) predecessorRuleItem.getSucceedingVersion();
assertNotNull(succeedingRuleItem);
assertEquals(ruleItem1.getRuleContent(), succeedingRuleItem.getRuleContent());
}
public void testGetSuccessorVersionsIterator() {
try {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetSuccessorVersionsIterator", "test content");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetSuccessorVersionsIterator", "test content");
ruleItem1.checkin( "version0" );
Iterator iterator = ruleItem1.getSuccessorVersionsIterator();
@@ -421,11 +421,11 @@
assertNotNull(iterator);
assertFalse(iterator.hasNext());
- RuleItem predecessorRuleItem = (RuleItem) ruleItem1.getPrecedingVersion();
+ AssetItem predecessorRuleItem = (AssetItem) ruleItem1.getPrecedingVersion();
iterator = predecessorRuleItem.getSuccessorVersionsIterator();
assertNotNull(iterator);
assertTrue(iterator.hasNext());
- RuleItem nextRuleItem = (RuleItem) iterator.next();
+ AssetItem nextRuleItem = (AssetItem) iterator.next();
assertEquals("new content", nextRuleItem.getRuleContent());
assertFalse(iterator.hasNext());
@@ -435,10 +435,10 @@
iterator = predecessorRuleItem.getSuccessorVersionsIterator();
assertNotNull(iterator);
assertTrue(iterator.hasNext());
- nextRuleItem = (RuleItem) iterator.next();
+ nextRuleItem = (AssetItem) iterator.next();
assertEquals("new content", nextRuleItem.getRuleContent());
assertTrue(iterator.hasNext());
- nextRuleItem = (RuleItem)iterator.next();
+ nextRuleItem = (AssetItem)iterator.next();
assertEquals("newer content", nextRuleItem.getRuleContent());
assertFalse(iterator.hasNext());
}
@@ -449,7 +449,7 @@
public void testGetPredecessorVersionsIterator() {
try {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetPredecessorVersionsIterator", "test description");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetPredecessorVersionsIterator", "test description");
ruleItem1.checkin( "version0" );
Iterator iterator = ruleItem1.getPredecessorVersionsIterator();
@@ -469,7 +469,7 @@
iterator = ruleItem1.getPredecessorVersionsIterator();
assertNotNull(iterator);
assertTrue(iterator.hasNext());
- RuleItem nextRuleItem = (RuleItem) iterator.next();
+ AssetItem nextRuleItem = (AssetItem) iterator.next();
assertEquals("test content", nextRuleItem.getRuleContent());
@@ -480,14 +480,14 @@
iterator = ruleItem1.getPredecessorVersionsIterator();
assertNotNull(iterator);
assertTrue(iterator.hasNext());
- nextRuleItem = (RuleItem) iterator.next();
+ nextRuleItem = (AssetItem) iterator.next();
assertTrue(iterator.hasNext());
assertEquals("new content", nextRuleItem.getRuleContent());
- nextRuleItem = (RuleItem) iterator.next();
+ nextRuleItem = (AssetItem) iterator.next();
assertEquals("test content", nextRuleItem.getRuleContent());
- assertEquals(null, ((RuleItem) iterator.next()).getRuleContent());
+ assertEquals(null, ((AssetItem) iterator.next()).getRuleContent());
}
catch(Exception e) {
@@ -496,15 +496,15 @@
}
public void testGetTitle() {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetTitle", "test content");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetTitle", "test content");
assertEquals("testGetTitle", ruleItem1.getTitle());
}
public void testDublinCoreProperties() {
- RulePackageItem pkg = getRepo().createRulePackage( "testDublinCore", "wa" );
+ PackageItem pkg = getRepo().createRulePackage( "testDublinCore", "wa" );
- RuleItem ruleItem = pkg.addRule( "testDublinCoreProperties", "yeah yeah yeah" );
+ AssetItem ruleItem = pkg.addRule( "testDublinCoreProperties", "yeah yeah yeah" );
ruleItem.updateCoverage( "b" );
assertEquals("b",ruleItem.getCoverage());
@@ -512,7 +512,7 @@
ruleItem.checkin( "woo" );
pkg = getRepo().loadRulePackage( "testDublinCore" );
- ruleItem = (RuleItem) pkg.getRules().next();
+ ruleItem = (AssetItem) pkg.getRules().next();
assertEquals("b", ruleItem.getCoverage());
assertEquals("me", ruleItem.getLastContributor());
@@ -523,7 +523,7 @@
}
public void testGetFormat() {
- RuleItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetFormat", "test content");
+ AssetItem ruleItem1 = getRepo().loadDefaultRulePackage().addRule("testGetFormat", "test content");
assertEquals("DRL", ruleItem1.getFormat());
Modified: labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulePackageItemTestCase.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulePackageItemTestCase.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulePackageItemTestCase.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -26,7 +26,7 @@
try {
//calls constructor
- RulePackageItem rulePackageItem1 = repo.createRulePackage("testRulePackage", "desc");
+ PackageItem rulePackageItem1 = repo.createRulePackage("testRulePackage", "desc");
assertNotNull(rulePackageItem1);
assertEquals("testRulePackage", rulePackageItem1.getName());
@@ -34,7 +34,7 @@
assertTrue(it.hasNext());
while (it.hasNext()) {
- RulePackageItem pack = (RulePackageItem) it.next();
+ PackageItem pack = (PackageItem) it.next();
if (pack.getName().equals( "testRulePackage" )) {
return;
}
@@ -49,7 +49,7 @@
//try constructing with node of wrong type
try {
DslItem dslItem = repo.addDsl("testRulePackageItem", "content");
- RulePackageItem rulePackageItem2 = new RulePackageItem(repo, dslItem.getNode());
+ PackageItem rulePackageItem2 = new PackageItem(repo, dslItem.getNode());
fail("Exception not thrown for node of type: " + dslItem.getNode().getPrimaryNodeType().getName());
}
catch(RulesRepositoryException e) {
@@ -69,10 +69,10 @@
public void testBaselinePackage() throws Exception {
RulesRepository repo = getRepo();
- RulePackageItem pack = repo.createRulePackage( "testBaselinePackage", "for testing baselines" );
+ PackageItem pack = repo.createRulePackage( "testBaselinePackage", "for testing baselines" );
- RuleItem rule1 = pack.addRule( "rule 1", "yeah" );
- RuleItem rule2 = pack.addRule( "rule 2", "foobar" );
+ AssetItem rule1 = pack.addRule( "rule 1", "yeah" );
+ AssetItem rule2 = pack.addRule( "rule 2", "foobar" );
StateItem state = repo.getState( "deployed" );
@@ -94,7 +94,7 @@
pack.createBaseline( "another", state );
- RulePackageItem prev = (RulePackageItem) pack.getPrecedingVersion();
+ PackageItem prev = (PackageItem) pack.getPrecedingVersion();
assertEquals(2, iteratorToList( prev.getRules() ).size());
}
@@ -102,9 +102,9 @@
/** Continues to show how multi dimensional versioning works */
public void testPackageBaselineWithRuleChanges() throws Exception {
String packName = StackUtil.getCurrentMethodName();
- RulePackageItem pack = getRepo().createRulePackage( packName, "yeah" );
+ PackageItem pack = getRepo().createRulePackage( packName, "yeah" );
- RuleItem rule = pack.addRule( "foobar", "waah" );
+ AssetItem rule = pack.addRule( "foobar", "waah" );
rule.updateRuleContent( "this is something" );
rule.checkin( "something" );
@@ -114,18 +114,18 @@
pack = getRepo().loadRulePackage( packName );
- rule = (RuleItem) pack.getRules().next();
+ rule = (AssetItem) pack.getRules().next();
rule.updateRuleContent( "blah" );
rule.checkin( "woot" );
pack.createBaseline( "yeah", state );
pack = getRepo().loadRulePackage( packName );
- rule = (RuleItem) pack.getRules().next();
+ rule = (AssetItem) pack.getRules().next();
assertEquals("blah", rule.getRuleContent());
- RulePackageItem prev = (RulePackageItem) pack.getPrecedingVersion();
- rule = (RuleItem) prev.getRules().next();
+ PackageItem prev = (PackageItem) pack.getPrecedingVersion();
+ rule = (AssetItem) prev.getRules().next();
assertEquals("this is something", rule.getRuleContent());
}
@@ -136,7 +136,7 @@
public void testLoadRulePackageItem() {
- RulePackageItem rulePackageItem = getRepo().createRulePackage("testLoadRuleRuleItem", "desc");
+ PackageItem rulePackageItem = getRepo().createRulePackage("testLoadRuleRuleItem", "desc");
rulePackageItem = getRepo().loadRulePackage("testLoadRuleRuleItem");
assertNotNull(rulePackageItem);
@@ -157,16 +157,16 @@
* This will test getting rules of specific versions out of a package.
*/
public void testPackageRuleVersionExtraction() throws Exception {
- RulePackageItem pack = getRepo().createRulePackage( "package extractor", "foo" );
+ PackageItem pack = getRepo().createRulePackage( "package extractor", "foo" );
- RuleItem rule1 = pack.addRule( "rule number 1", "yeah man" );
+ AssetItem rule1 = pack.addRule( "rule number 1", "yeah man" );
rule1.checkin( "version0" );
- RuleItem rule2 = pack.addRule( "rule number 2", "no way" );
+ AssetItem rule2 = pack.addRule( "rule number 2", "no way" );
rule2.checkin( "version0" );
- RuleItem rule3 = pack.addRule( "rule number 3", "yes way" );
+ AssetItem rule3 = pack.addRule( "rule number 3", "yes way" );
rule3.checkin( "version0" );
getRepo().save();
@@ -202,21 +202,21 @@
rules = iteratorToList( pack.getRules(getRepo().getState( "draft" )) );
assertEquals(1, rules.size());
- RuleItem rule = (RuleItem) rules.get( 0 );
+ AssetItem rule = (AssetItem) rules.get( 0 );
assertEquals("new content", rule.getRuleContent());
//get the previous one via state
rules = iteratorToList( pack.getRules(getRepo().getState( "foobar" )) );
assertEquals(1, rules.size());
- RuleItem prior = (RuleItem) rules.get( 0 );
+ AssetItem prior = (AssetItem) rules.get( 0 );
assertFalse("new content".equals( prior.getRuleContent() ));
}
public void testDuplicatePackageName() throws Exception {
- RulePackageItem pack = getRepo().createRulePackage( "dupePackageTest", "testing for dupe" );
+ PackageItem pack = getRepo().createRulePackage( "dupePackageTest", "testing for dupe" );
assertNotNull(pack.getName());
try {
@@ -230,7 +230,7 @@
public void testLoadRulePackageItemByUUID() throws Exception {
- RulePackageItem rulePackageItem = getRepo().createRulePackage("testLoadRuleRuleItemByUUID", "desc");
+ PackageItem rulePackageItem = getRepo().createRulePackage("testLoadRuleRuleItemByUUID", "desc");
String uuid = null;
uuid = rulePackageItem.getNode().getUUID();
@@ -251,16 +251,16 @@
}
public void testAddRuleRuleItem() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testAddRuleRuleItem","desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testAddRuleRuleItem","desc");
- RuleItem ruleItem1 = rulePackageItem1.addRule("testAddRuleRuleItem", "test description");
+ AssetItem ruleItem1 = rulePackageItem1.addRule("testAddRuleRuleItem", "test description");
ruleItem1.updateRuleContent( "test content" );
ruleItem1.checkin( "updated the rule content" );
Iterator rulesIt = rulePackageItem1.getRules();
assertNotNull(rulesIt);
- RuleItem first = (RuleItem) rulesIt.next();
+ AssetItem first = (AssetItem) rulesIt.next();
assertFalse(rulesIt.hasNext());
assertEquals("testAddRuleRuleItem", first.getName());
@@ -272,10 +272,10 @@
List rules = iteratorToList( rulesIt );
assertEquals(1, rules.size());
- assertEquals("testAddRuleRuleItem", ((RuleItem)rules.get(0)).getName());
- assertEquals("new lhs", ((RuleItem)rules.get(0)).getRuleContent());
+ assertEquals("testAddRuleRuleItem", ((AssetItem)rules.get(0)).getName());
+ assertEquals("new lhs", ((AssetItem)rules.get(0)).getRuleContent());
- RuleItem ruleItem2 = rulePackageItem1.addRule("testAddRuleRuleItem2", "test content");
+ AssetItem ruleItem2 = rulePackageItem1.addRule("testAddRuleRuleItem2", "test content");
rules = iteratorToList(rulePackageItem1.getRules());
assertNotNull(rules);
@@ -293,7 +293,7 @@
}
public void testAddFunctionFunctionItem() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testAddFunctionFunctionItem", "desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testAddFunctionFunctionItem", "desc");
FunctionItem functionItem1 = getRepo().addFunction("test function", "test content");
@@ -322,7 +322,7 @@
}
public void testAddFunctionFunctionItemBoolean() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testAddFunctionFunctionItemBoolean", "desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testAddFunctionFunctionItemBoolean", "desc");
FunctionItem functionItem1 = getRepo().addFunction("testAddFunctionFunctionItemBoolean", "test content");
@@ -352,7 +352,7 @@
}
public void testGetFunctions() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testGetFunctions", "desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testGetFunctions", "desc");
FunctionItem functionItem1 = getRepo().addFunction("testGetFunctions", "test content");
@@ -373,18 +373,18 @@
}
public void testGetRules() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testGetRules", "desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testGetRules", "desc");
- RuleItem ruleItem1 = rulePackageItem1.addRule("testGetRules", "desc" );
+ AssetItem ruleItem1 = rulePackageItem1.addRule("testGetRules", "desc" );
ruleItem1.updateRuleContent( "test lhs content" );
List rules = iteratorToList(rulePackageItem1.getRules());
assertNotNull(rules);
assertEquals(1, rules.size());
- assertEquals("testGetRules", ((RuleItem)rules.get(0)).getName());
+ assertEquals("testGetRules", ((AssetItem)rules.get(0)).getName());
- RuleItem ruleItem2 = rulePackageItem1.addRule("testGetRules2", "desc" );
+ AssetItem ruleItem2 = rulePackageItem1.addRule("testGetRules2", "desc" );
ruleItem2.updateRuleContent( "test lhs content" );
rules = iteratorToList(rulePackageItem1.getRules());
@@ -392,7 +392,7 @@
assertEquals(2, rules.size());
//now lets test loading rule
- RuleItem loaded = rulePackageItem1.loadRule( "testGetRules" );
+ AssetItem loaded = rulePackageItem1.loadRule( "testGetRules" );
assertNotNull(loaded);
assertEquals("testGetRules", loaded.getName());
assertEquals("desc", loaded.getDescription());
@@ -401,9 +401,9 @@
}
public void testToString() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testToStringPackage", "desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testToStringPackage", "desc");
- RuleItem ruleItem1 = rulePackageItem1.addRule("testToStringPackage", "test lhs content" );
+ AssetItem ruleItem1 = rulePackageItem1.addRule("testToStringPackage", "test lhs content" );
ruleItem1.updateRuleContent( "test lhs content" );
assertNotNull(rulePackageItem1.toString());
@@ -411,15 +411,15 @@
}
public void testRemoveRule() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testRemoveRule", "desc");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testRemoveRule", "desc");
- RuleItem ruleItem1 = rulePackageItem1.addRule("testRemoveRule", "test lhs content" );
+ AssetItem ruleItem1 = rulePackageItem1.addRule("testRemoveRule", "test lhs content" );
ruleItem1.updateRuleContent( "test lhs content" );
Iterator rulesIt = rulePackageItem1.getRules();
- RuleItem next = (RuleItem) rulesIt.next();
+ AssetItem next = (AssetItem) rulesIt.next();
assertFalse(rulesIt.hasNext());
assertEquals("testRemoveRule", next.getName());
@@ -430,17 +430,17 @@
List rules = iteratorToList(rulePackageItem1.getRules());
assertNotNull(rules);
assertEquals(1, rules.size());
- assertEquals("testRemoveRule", ((RuleItem)rules.get(0)).getName());
- assertEquals("new lhs", ((RuleItem)rules.get(0)).getRuleContent());
+ assertEquals("testRemoveRule", ((AssetItem)rules.get(0)).getName());
+ assertEquals("new lhs", ((AssetItem)rules.get(0)).getRuleContent());
- RuleItem ruleItem2 = rulePackageItem1.addRule("testRemoveRule2", "test lhs content");
+ AssetItem ruleItem2 = rulePackageItem1.addRule("testRemoveRule2", "test lhs content");
//remove the rule, make sure the other rule in the pacakge stays around
rulePackageItem1.removeRule(ruleItem1.getName());
rulePackageItem1.rulesRepository.save();
rules = iteratorToList(rulePackageItem1.getRules());
assertEquals(1, rules.size());
- assertEquals("testRemoveRule2", ((RuleItem)rules.get(0)).getName());
+ assertEquals("testRemoveRule2", ((AssetItem)rules.get(0)).getName());
//remove the rule that is following the head revision, make sure the pacakge is now empty
rulePackageItem1.removeRule(ruleItem2.getName());
@@ -453,7 +453,7 @@
public void testRemoveFunction() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testRemoveFunction", "yayayaya");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testRemoveFunction", "yayayaya");
FunctionItem functionItem1 = getRepo().addFunction("testRemoveFunction", "test content");
@@ -490,7 +490,7 @@
public void testGetFormat() {
- RulePackageItem rulePackageItem1 = getRepo().createRulePackage("testGetFormat", "woot");
+ PackageItem rulePackageItem1 = getRepo().createRulePackage("testGetFormat", "woot");
assertNotNull(rulePackageItem1);
assertEquals("Rule Package", rulePackageItem1.getFormat());
Modified: labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulesRepositoryTestCase.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulesRepositoryTestCase.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/RulesRepositoryTestCase.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -25,14 +25,14 @@
Iterator it = repo.listPackages();
boolean foundDefault = false;
while(it.hasNext()) {
- RulePackageItem item = (RulePackageItem) it.next();
+ PackageItem item = (PackageItem) it.next();
if (item.getName().equals( RulesRepository.DEFAULT_PACKAGE )) {
foundDefault = true;
}
}
assertTrue(foundDefault);
- RulePackageItem def = repo.loadDefaultRulePackage();
+ PackageItem def = repo.loadDefaultRulePackage();
assertNotNull(def);
assertEquals("default", def.getName());
@@ -41,10 +41,10 @@
public void testAddVersionARule() throws Exception {
RulesRepository repo = RepositorySession.getRepository();
- RulePackageItem pack = repo.createRulePackage( "testAddVersionARule", "description" );
+ PackageItem pack = repo.createRulePackage( "testAddVersionARule", "description" );
repo.save();
- RuleItem rule = pack.addRule( "my rule", "foobar" );
+ AssetItem rule = pack.addRule( "my rule", "foobar" );
assertEquals("my rule", rule.getName());
rule.updateRuleContent( "foo foo" );
@@ -55,7 +55,7 @@
rule.updateRuleContent( "foo bar" );
rule.checkin( "version1" );
- RulePackageItem pack2 = repo.loadRulePackage( "testAddVersionARule" );
+ PackageItem pack2 = repo.loadRulePackage( "testAddVersionARule" );
Iterator it = pack2.getRules();
@@ -64,7 +64,7 @@
assertFalse(it.hasNext());
- RuleItem prev = (RuleItem) rule.getPrecedingVersion();
+ AssetItem prev = (AssetItem) rule.getPrecedingVersion();
assertEquals("foo bar", rule.getRuleContent());
assertEquals("foo foo", prev.getRuleContent());
@@ -77,14 +77,14 @@
public void testLoadRuleByUUID() throws Exception {
RulesRepository repo = RepositorySession.getRepository();
- RulePackageItem rulePackageItem = repo.loadDefaultRulePackage();
- RuleItem rule = rulePackageItem.addRule( "testLoadRuleByUUID", "this is a description");
+ PackageItem rulePackageItem = repo.loadDefaultRulePackage();
+ AssetItem rule = rulePackageItem.addRule( "testLoadRuleByUUID", "this is a description");
repo.save();
String uuid = rule.getNode().getUUID();
- RuleItem loaded = repo.loadRuleByUUID(uuid);
+ AssetItem loaded = repo.loadRuleByUUID(uuid);
assertNotNull(loaded);
assertEquals("testLoadRuleByUUID", loaded.getName());
assertEquals( "this is a description", loaded.getDescription());
@@ -97,7 +97,7 @@
- RuleItem reload = repo.loadRuleByUUID( uuid );
+ AssetItem reload = repo.loadRuleByUUID( uuid );
assertEquals("testLoadRuleByUUID", reload.getName());
assertEquals("xxx", reload.getRuleContent());
System.out.println(reload.getVersionNumber());
@@ -122,7 +122,7 @@
Calendar effectiveDate = Calendar.getInstance();
Calendar expiredDate = Calendar.getInstance();
expiredDate.setTimeInMillis(effectiveDate.getTimeInMillis() + (1000 * 60 * 60 * 24));
- RuleItem ruleItem1 = rulesRepository.loadDefaultRulePackage().addRule("testAddRuleCalendarCalendar", "desc");
+ AssetItem ruleItem1 = rulesRepository.loadDefaultRulePackage().addRule("testAddRuleCalendarCalendar", "desc");
ruleItem1.updateDateEffective( effectiveDate );
ruleItem1.updateDateExpired( expiredDate );
@@ -196,14 +196,14 @@
RulesRepository rulesRepository = RepositorySession.getRepository();
- RulePackageItem rulePackageItem1 = rulesRepository.createRulePackage("testListPackages", "desc");
+ PackageItem rulePackageItem1 = rulesRepository.createRulePackage("testListPackages", "desc");
Iterator it = rulesRepository.listPackages();
assertTrue(it.hasNext());
boolean found = false;
while ( it.hasNext() ) {
- RulePackageItem element = (RulePackageItem) it.next();
+ PackageItem element = (PackageItem) it.next();
if (element.getName().equals( "testListPackages" ))
{
found = true;
@@ -216,8 +216,8 @@
public void testMoveRulePackage() throws Exception {
RulesRepository repo = RepositorySession.getRepository();
- RulePackageItem pkg = repo.createRulePackage( "testMove", "description" );
- RuleItem r = pkg.addRule( "testMove", "description" );
+ PackageItem pkg = repo.createRulePackage( "testMove", "description" );
+ AssetItem r = pkg.addRule( "testMove", "description" );
r.checkin( "version0" );
assertEquals("testMove", r.getPackageName());
@@ -235,12 +235,12 @@
pkg = repo.loadRulePackage( "testMove2" );
assertEquals(1, iteratorToList( pkg.getRules() ).size());
- r = (RuleItem) pkg.getRules().next();
+ r = (AssetItem) pkg.getRules().next();
assertEquals("testMove", r.getName());
assertEquals("testMove2", r.getPackageName());
assertEquals("explanation", r.getCheckinComment());
- RuleItem p = (RuleItem) r.getPrecedingVersion();
+ AssetItem p = (AssetItem) r.getPrecedingVersion();
assertEquals("testMove", p.getPackageName());
assertEquals("version0", p.getCheckinComment());
Modified: labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/ScalabilityTest.java
===================================================================
--- labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/ScalabilityTest.java 2006-12-11 18:02:20 UTC (rev 8231)
+++ labs/jbossrules/trunk/drools-repository/src/test/java/org/drools/repository/ScalabilityTest.java 2006-12-11 18:02:27 UTC (rev 8232)
@@ -12,7 +12,7 @@
import javax.jcr.UnsupportedRepositoryOperationException;
import org.apache.jackrabbit.core.TransientRepository;
-import org.drools.repository.RuleItem;
+import org.drools.repository.AssetItem;
import org.drools.repository.RulesRepository;
import org.drools.repository.RulesRepositoryException;
import org.drools.repository.VersionableItem;
@@ -47,13 +47,13 @@
System.out.println("list size is: " + list.size());
start = System.currentTimeMillis();
- RuleItem item = (RuleItem) list.get( 0 );
+ AssetItem item = (AssetItem) list.get( 0 );
item.updateRuleContent( "this is a description" );
item.checkin( "newer" );
System.out.println("time to update and version: " + (System.currentTimeMillis() - start));
start = System.currentTimeMillis();
- item = (RuleItem) list.get( 42 );
+ item = (AssetItem) list.get( 42 );
item.updateRuleContent( "this is a description" );
item.updateRuleContent( "wooooooooooooooooooooooooooooooooooot" );
item.checkin( "latest" );
@@ -103,7 +103,7 @@
if (i % 500 == 0) {
repo.getSession().save();
for ( Iterator iter = list.iterator(); iter.hasNext(); ) {
- RuleItem element = (RuleItem) iter.next();
+ AssetItem element = (AssetItem) iter.next();
element.getNode().checkin();
}
list.clear();
@@ -128,7 +128,7 @@
System.out.println("ADDING rule: " + ruleName);
- RuleItem item = repo.loadDefaultRulePackage().addRule( ruleName, "Foo(bar == " + i + ")panic(" + i + ");" );
+ AssetItem item = repo.loadDefaultRulePackage().addRule( ruleName, "Foo(bar == " + i + ")panic(" + i + ");" );
item.addCategory( cat );
list.add( item );
More information about the jboss-svn-commits
mailing list