org.drools.repository.ModuleItem.getAssets java code examples

/**
 * This will change the status of this module, and all the contained
 * assets. No new versions are created of anything.
 *
 * @param newState The status tag to change it to.
 */
public void changeStatus(String newState) {
  StateItem stateItem = rulesRepository.getState(newState);
  updateState(stateItem);
  for (Iterator<AssetItem> iter = getAssets(); iter.hasNext(); ) {
    iter.next().updateState(stateItem);
  }
}

/**
 * This will change the status of this module, and all the contained
 * assets. No new versions are created of anything.
 *
 * @param newState The status tag to change it to.
 */
public void changeStatus(String newState) {
  StateItem stateItem = rulesRepository.getState(newState);
  updateState(stateItem);
  for (Iterator<AssetItem> iter = getAssets(); iter.hasNext(); ) {
    iter.next().updateState(stateItem);
  }
}

private void checkInAssetIfNecessary(boolean force) {
  if(!(this instanceof ModuleItem)) {
    return;
  }
  Iterator<AssetItem> assets = ((ModuleItem)this).getAssets();
  while(assets.hasNext()) {
    AssetItem asset = assets.next();
         if(force || !assetHasHistory(asset)) {
      asset.checkout();
      asset.checkin("Package[" + this.getTitle() + "] checked in");
    }
  }
}

private void checkInAssetIfNecessary(boolean force) {
  if(!(this instanceof ModuleItem)) {
    return;
  }
  Iterator<AssetItem> assets = ((ModuleItem)this).getAssets();
  while(assets.hasNext()) {
    AssetItem asset = assets.next();
         if(force || !assetHasHistory(asset)) {
      asset.checkout();
      asset.checkin("Package[" + this.getTitle() + "] checked in");
    }
  }
}

/**
 * Copy a package to the target name.
 */
public String copyModule(String sourceModuleName,
             String destModuleName) {
  ModuleItem source = loadModule(sourceModuleName);
  try {
    String destPath = source.getNode().getParent().getPath() + "/" + destModuleName;
    if (this.getAreaNode(MODULE_AREA).hasNode(destModuleName)) {
      throw new RulesRepositoryException("Destination already exists.");
    }
    this.session.getWorkspace().copy(source.getNode().getPath(),
        destPath);
    ModuleItem newModuleItem = loadModule(destModuleName);
    newModuleItem.updateTitle(destModuleName);
    for (Iterator iter = newModuleItem.getAssets(); iter.hasNext(); ) {
      AssetItem as = (AssetItem) iter.next();
      as.updateStringProperty(destModuleName,
          AssetItem.MODULE_NAME_PROPERTY);
    }
    save();
    return newModuleItem.getUUID();
  } catch (RepositoryException e) {
    log.error(e.getMessage(),
        e);
    throw new RulesRepositoryException(e);
  }
}

for (Iterator iter = newModuleItem.getAssets(); iter.hasNext(); ) {
  AssetItem as = (AssetItem) iter.next();
  as.updateStringProperty(newModuleName,

for (Iterator iter = newModuleItem.getAssets(); iter.hasNext(); ) {
  AssetItem as = (AssetItem) iter.next();
  as.updateStringProperty(newModuleName,

/**
 * Copy a package to the target name.
 */
public String copyModule(String sourceModuleName,
             String destModuleName) {
  ModuleItem source = loadModule(sourceModuleName);
  try {
    String destPath = source.getNode().getParent().getPath() + "/" + destModuleName;
    if (this.getAreaNode(MODULE_AREA).hasNode(destModuleName)) {
      throw new RulesRepositoryException("Destination already exists.");
    }
    this.session.getWorkspace().copy(source.getNode().getPath(),
        destPath);
    ModuleItem newModuleItem = loadModule(destModuleName);
    newModuleItem.updateTitle(destModuleName);
    for (Iterator iter = newModuleItem.getAssets(); iter.hasNext(); ) {
      AssetItem as = (AssetItem) iter.next();
      as.updateStringProperty(destModuleName,
          AssetItem.MODULE_NAME_PROPERTY);
    }
    save();
    return newModuleItem.getUUID();
  } catch (RepositoryException e) {
    log.error(e.getMessage(),
        e);
    throw new RulesRepositoryException(e);
  }
}

@Test
public void testAddRuleRuleItem() {
    ModuleItem rulePackageItem1 = getRepo().createModule("testAddRuleRuleItem","desc");
    AssetItem ruleItem1 = rulePackageItem1.addAsset("testAddRuleRuleItem", "test description");
    ruleItem1.updateContent( "test content" );
    ruleItem1.checkin( "updated the rule content" );
    Iterator rulesIt = rulePackageItem1.getAssets();
    assertNotNull(rulesIt);
    AssetItem first = (AssetItem) rulesIt.next();
    assertFalse(rulesIt.hasNext());
    assertEquals("testAddRuleRuleItem", first.getName());
    //test that it is following the head revision
    ruleItem1.updateContent("new lhs");
    ruleItem1.checkin( "updated again" );
    rulesIt = rulePackageItem1.getAssets();
    assertNotNull(rulesIt);
    List rules = iteratorToList( rulesIt );
    assertEquals(1, rules.size());
    assertEquals("testAddRuleRuleItem", ((AssetItem)rules.get(0)).getName());
    assertEquals("new lhs", ((AssetItem)rules.get(0)).getContent());
    AssetItem ruleItem2 = rulePackageItem1.addAsset("testAddRuleRuleItem2", "test content");
    rules = iteratorToList(rulePackageItem1.getAssets());
    assertNotNull(rules);
    assertEquals(2, rules.size());
}

@Test
public void testRemoveRule() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testRemoveRule", "desc");
  AssetItem ruleItem1 = rulePackageItem1.addAsset("testRemoveRule", "test lhs content" );
  ruleItem1.updateContent( "test lhs content" );
  Iterator rulesIt = rulePackageItem1.getAssets();
  AssetItem next = (AssetItem) rulesIt.next();
  assertFalse(rulesIt.hasNext());
  assertEquals("testRemoveRule", next.getName());
  ruleItem1.updateContent("new lhs");
  List rules = iteratorToList(rulePackageItem1.getAssets());
  assertNotNull(rules);
  assertEquals(1, rules.size());
  assertEquals("testRemoveRule", ((AssetItem)rules.get(0)).getName());
  assertEquals("new lhs", ((AssetItem)rules.get(0)).getContent());
  AssetItem ruleItem2 = rulePackageItem1.addAsset("testRemoveRule2", "test lhs content");
  //remove the rule, make sure the other rule in the pacakge stays around
  rulePackageItem1.loadAsset(ruleItem1.getName()).remove();
  rulePackageItem1.rulesRepository.save();
  rules = iteratorToList(rulePackageItem1.getAssets());
  assertEquals(1, rules.size());
  assertEquals("testRemoveRule2", ((AssetItem)rules.get(0)).getName());
  //remove the rule that is following the head revision, make sure the pacakge is now empty
  rulePackageItem1.loadAsset(ruleItem2.getName()).remove();
  rules = iteratorToList(rulePackageItem1.getAssets());
  assertNotNull(rules);
  assertEquals(0, rules.size());
}

       iteratorToList( pkg.getAssets() ).size() );
       iteratorToList( pkg.getAssets() ).size() );
       iteratorToList( pkg.getAssets() ).size() );
r = (AssetItem) pkg.getAssets().next();
assertEquals( "testMove",
       r.getName() );

/**
 * This is showing how to copy a package with standard JCR
 */
@Test
public void testPackageCopy() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem pkg = repo.createModule( "testPackageCopy", "this is something" );
  AssetItem it1 = pkg.addAsset( "testPackageCopy1", "la" );
  AssetItem it2 = pkg.addAsset( "testPackageCopy2", "la" );
  it1.updateContent( "new content" );
  it2.updateContent( "more content" );
  it1.checkin( "c" );
  it2.checkin( "c" );
  it1 = pkg.loadAsset( "testPackageCopy1" );
  List hist1 = iteratorToList( it1.getHistory() );
  System.out.println(hist1.size());
  repo.getSession().getWorkspace().copy( pkg.getNode().getPath(), pkg.getNode().getPath() + "_");
  ModuleItem pkg2 = repo.loadModule( "testPackageCopy_" );
  assertNotNull(pkg2);
  assertEquals(2, iteratorToList( pkg2.getAssets() ).size() );
  AssetItem it1_ = pkg2.loadAsset( "testPackageCopy1" );
  it1.updateContent( "new content2" );
  it1.checkin( "la" );
  it1_ = pkg2.loadAsset( "testPackageCopy1" );
  assertEquals("new content", it1_.getContent());
}

@Test
public void testGetRules() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testGetRules", "desc");
  assertFalse(rulePackageItem1.containsAsset("goober"));
  AssetItem ruleItem1 = rulePackageItem1.addAsset("testGetRules", "desc" );
  ruleItem1.updateContent( "test lhs content" );
  assertTrue(rulePackageItem1.containsAsset( "testGetRules" ));
  assertFalse(rulePackageItem1.containsAsset( "XXXXYYYYZZZZ" ));
  List rules = iteratorToList(rulePackageItem1.getAssets());
  assertNotNull(rules);
  assertEquals(1, rules.size());
  assertEquals("testGetRules", ((AssetItem)rules.get(0)).getName());
  AssetItem ruleItem2 = rulePackageItem1.addAsset("testGetRules2", "desc" );
  ruleItem2.updateContent( "test lhs content" );
  rules = iteratorToList(rulePackageItem1.getAssets());
  assertNotNull(rules);
  assertEquals(2, rules.size());
  //now lets test loading rule
  AssetItem loaded = rulePackageItem1.loadAsset( "testGetRules" );
  assertNotNull(loaded);
  assertEquals("testGetRules", loaded.getName());
  assertEquals("desc", loaded.getDescription());
}

@Test
public void testAddVersionARule() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem pack = repo.createModule( "testAddVersionARule",
                      "description" );
  repo.save();
  AssetItem rule = pack.addAsset( "my rule",
                  "foobar" );
  assertEquals( "my rule",
         rule.getName() );
  rule.updateContent( "foo foo" );
  rule.checkin( "version0" );
  pack.addAsset( "other rule",
          "description" );
  rule.updateContent( "foo bar" );
  rule.checkin( "version1" );
  ModuleItem pack2 = repo.loadModule( "testAddVersionARule" );
  Iterator it = pack2.getAssets();
  it.next();
  it.next();
  assertFalse( it.hasNext() );
  AssetItem prev = (AssetItem) rule.getPrecedingVersion();
  assertEquals( "foo bar",
         rule.getContent() );
  assertEquals( "foo foo",
         prev.getContent() );
}

@Test
public void testDublinCoreProperties() {
  ModuleItem pkg = getRepo().createModule( "testDublinCore", "wa" );
  AssetItem ruleItem = pkg.addAsset( "testDublinCoreProperties", "yeah yeah yeah" );
  ruleItem.updateCoverage( "b" );
  assertEquals("b",ruleItem.getCoverage());
  ruleItem.checkin( "woo" );
  pkg = getRepo().loadModule( "testDublinCore" );
  ruleItem = (AssetItem) pkg.getAssets().next();
  assertEquals("b", ruleItem.getCoverage());
  assertEquals("", ruleItem.getExternalRelation());
  assertEquals("", ruleItem.getExternalSource());
}

@Test
public void testAddRuleItemFromGlobalArea() {
  AssetItem ruleItem1 = loadGlobalArea().addAsset("testAddRuleItemFromGlobalAreaRuleItem", "test description");
  ruleItem1.updateContent( "test content" );
  ruleItem1.checkin( "updated the rule content" );
  
  ModuleItem rulePackageItem2 = getRepo().createModule("testAddRuleItemFromGlobalArea1","desc");
  AssetItem linkedRuleItem1 = rulePackageItem2.addAssetImportedFromGlobalArea(ruleItem1.getName());
  linkedRuleItem1.updateContent( "test content for linked" );
  linkedRuleItem1.checkin( "updated the rule content for linked" );
  //test that it is following the head revision
  ruleItem1.updateContent("new lhs");
  ruleItem1.checkin( "updated again" );
  
  Iterator rulesIt2 = rulePackageItem2.getAssets();
  List rules2 = iteratorToList(rulesIt2);
  assertEquals(1, rules2.size());
  AssetItem ai = (AssetItem) rules2.get(0);
  assertTrue(ai.getName().equals("testAddRuleItemFromGlobalAreaRuleItem"));
  assertEquals("new lhs", ai.getContent());
  assertEquals("test description", ai.getDescription());
  assertEquals("updated again", ai.getCheckinComment());
}

       iteratorToList( dest.getAssets() ).size() );
AssetItem item2 = (AssetItem) dest.getAssets().next();

@Test
public void testRenamePackage() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem original = repo.createModule( "testRenamePackage",
                        "asset" );
  List packagesOriginal = iteratorToList( repo.listModules() );
  AssetItem item = repo.loadModule( "testRenamePackage" ).addAsset( "testRenameAssetSource",
                                    "desc" );
  item.updateContent( "la" );
  item.checkin( "" );
  String uuid = repo.renameModule( original.getUUID(),
                   "testRenamePackage2" );
  ModuleItem pkg = repo.loadModuleByUUID( uuid );
  assertEquals( "testRenamePackage2",
         pkg.getName() );
  List assets = iteratorToList( repo.loadModule( "testRenamePackage2" ).getAssets() );
  assertEquals( 1,
         assets.size() );
  item = (AssetItem) assets.get( 0 );
  assertEquals( "testRenameAssetSource",
         item.getName() );
  assertEquals( "la",
         item.getContent() );
  assertEquals( "testRenamePackage2",
         item.getModuleName() );
  List packageFinal = iteratorToList( repo.listModules() );
  assertEquals( packagesOriginal.size(),
         packageFinal.size() );
}

@Test
public void testRenameAsset() throws Exception {
  RulesRepository repo = getRepo();
  repo.createModule( "testRenameAsset",
            "asset" );
  AssetItem item = repo.loadModule( "testRenameAsset" ).addAsset( "testRenameAssetSource",
                                   "desc" );
  item.updateContent( "la" );
  item.checkin( "" );
  String uuid = repo.renameAsset( item.getUUID(),
                  "testRename2" );
  item = repo.loadAssetByUUID( uuid );
  assertEquals( "testRename2",
         item.getName() );
  assertEquals( "testRename2",
         item.getTitle() );
  List assets = iteratorToList( repo.loadModule( "testRenameAsset" ).getAssets() );
  assertEquals( 1,
         assets.size() );
  item = (AssetItem) assets.get( 0 );
  assertEquals( "testRename2",
         item.getName() );
  assertEquals( "la",
         item.getContent() );
}

  @Test
  public void testPackageCheckinConfig() {
    ModuleItem item = getRepo().createModule( "testPackageCheckinConfig", "description" );

    AssetItem rule = item.addAsset( "testPackageCheckinConfig", "w" );
    rule.checkin( "goo" );

    assertEquals(1, iteratorToList( item.getAssets() ).size());
    updateHeader( "la", item );
    item.checkin( "woot" );

    updateHeader( "we", item );
    item.checkin( "gah" );

//        PackageItem pre = (PackageItem) item.getPrecedingVersion();
//        assertNotNull(pre);
//        assertEquals("la", getHeader(pre));

    AssetItem rule_ = getRepo().loadAssetByUUID( rule.getUUID() );
    assertEquals(rule.getVersionNumber(), rule_.getVersionNumber());

    item = getRepo().loadModule( "testPackageCheckinConfig");
    long v = item.getVersionNumber();
    item.updateCheckinComment( "x" );
    getRepo().save();

    assertEquals(v, item.getVersionNumber());
  }

Javadoc

Return an iterator for the rules in this module

Popular methods of ModuleItem

addAsset
This adds an asset to the current physical module (you can move it later). With the given category.
containsAsset
Returns true if this module contains an asset of the given name.
getName
Return the name of the module.
getStringProperty
listAssetsByFormat
This will load an iterator for assets of the given format type.
loadAsset
Load a specific asset by name.
updateStringProperty
<init>
Constructs an object of type ModuleItem corresponding the specified node
checkin
checkout
createSubModule
Creates a nested package.
ensureMixinType

Popular in Java

Creating JSON documents from java classes using gson
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
notifyDataSetChanged (ArrayAdapter)
onRequestPermissionsResult (Fragment)
Graphics2D (java.awt)
This Graphics2D class extends the Graphics class to provide more sophisticated control overgraphics
BufferedReader (java.io)
Wraps an existing Reader and buffers the input. Expensive interaction with the underlying reader is
PrintWriter (java.io)
Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
HashMap (java.util)
HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
Stack (java.util)
Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables u
IsNull (org.hamcrest.core)
Is the value null?
CodeWhisperer alternatives

How to use getAssetsmethodin org.drools.repository.ModuleItem

Best Java code snippets using org.drools.repository.ModuleItem.getAssets (Showing top 20 results out of 315)

How to use
getAssets
method
in
org.drools.repository.ModuleItem