How to use

ModuleItem

in

org.drools.repository

public static void updateHeader(String h, ModuleItem pkg) {
  pkg.checkout();
  AssetItem as = null;
  if (pkg.containsAsset("drools")) {
    as = pkg.loadAsset("drools");
  } else {
    as = pkg.addAsset("drools", "");
  }
  as.updateContent(h);
  //as.checkin("");
}

this.checkout();
log.info("USER: {} CREATEING submodule [{}] under [{}]",
    new Object[]{getCurrentUserName(), subModuleName, getName()});
Node subModulesNode;
try {
    false);
return new ModuleItem(this.rulesRepository,
    ruleSubPackageNode);

private void migratePackage(ModuleItem pkg) {
  if (!pkg.containsAsset("drools")) {
    AssetItem asset = pkg.addAsset("drools", "");
    asset.updateFormat("package");
    asset.updateContent(pkg.getStringProperty(ModuleItem.HEADER_PROPERTY_NAME));
    asset.checkin("");
  }
}

/**
 * Set this to indicate if the binary is up to date, or not.
 */
public void updateBinaryUpToDate(boolean status) {
  try {
    checkIsUpdateable();
    this.checkout();
    node.setProperty(BINARY_UP_TO_DATE,
        status);
  } catch (RepositoryException e) {
    log.error("fail to update drools:binaryUpToDate of " + getName(),
        e);
  }
}

public void updateCategoryRules(String keys,
                String values) throws RulesRepositoryException {
  //System.out.println("(updateCategoryRules) keys: " + keys + " Values: " + values );
  try {
    this.checkout();
    this.updateStringProperty(keys,
        CATEGORY_RULE_KEYS_PROPERTY_NAME);
    this.updateStringProperty(values,
        CATEGORY_RULE_VALUES_PROPERTY_NAME);
  } catch (Exception e) {
    log.error("Caught Exception",
        e);
    throw new RulesRepositoryException(e);
  }
}

@Override
public ModuleItem getPrecedingVersion() throws RulesRepositoryException {
  try {
    Node precedingVersionNode = this.getPrecedingVersionNode();
    if (precedingVersionNode != null) {
      return new ModuleItem(this.rulesRepository,
          precedingVersionNode);
    } else {
      return null;
    }
  } catch (Exception e) {
    log.error("Caught exception",
        e);
    throw new RulesRepositoryException(e);
  }
}

try {
  ModuleItem itemOriginal = loadModuleByUUID(uuid);
  log.info("Renaming module: " + itemOriginal.getNode().getPath() + " to " + newModuleName);
  Node node = itemOriginal.getNode();
  String sourcePath = node.getPath();
  String destPath = node.getParent().getPath() + "/" + newModuleName;
  itemOriginal.updateTitle(newModuleName);
  itemOriginal.checkin("Renamed module " + itemOriginal.getName());
  for (Iterator iter = newModuleItem.getAssets(); iter.hasNext(); ) {
    AssetItem as = (AssetItem) iter.next();
    as.updateStringProperty(newModuleName,
  return itemOriginal.getUUID();
} catch (RepositoryException e) {
  log.error(e.getMessage(),

assertFalse(pkg.isSnapshot());
AssetItem it1 = pkg.addAsset( "testPackageCopy1", "la" );
AssetItem it2 = pkg.addAsset( "testPackageCopy2", "la" );
assertEquals(2, iteratorToList(pkg.listAssetsByFormat( new String[] {"drl"} )).size());
repo.createModuleSnapshot( "testPackageSnapshot", "PROD 2.0" );
assertTrue(pkgLoaded.isSnapshot());
assertEquals("PROD 2.0", pkgLoaded.getSnapshotName());
assertEquals("testPackageSnapshot", pkgLoaded.getName());
ModuleItem _pkgLoaded = repo.loadModuleByUUID( pkgLoaded.getUUID() );
assertNotNull(_pkgLoaded);
assertEquals(pkgLoaded.getCreatedDate(), _pkgLoaded.getCreatedDate());
assertEquals(pkgLoaded.getName(), _pkgLoaded.getName());
List loadedAssets = iteratorToList( pkgLoaded.getAssets() );
List _loadedAssets = iteratorToList( _pkgLoaded.getAssets() );
assertEquals(loadedAssets.size(), _loadedAssets.size());
it1.checkin( "X" );
assertFalse(it1.getVersionNumber()==  ver1 );
AssetItem it3 = pkg.addAsset( "testPackageCopy3", "x" );
it3.updateFormat( "drl" );
it3.checkin( "a" );
assertEquals(3, iteratorToList( pkg.listAssetsByFormat( new String[] {"drl"} )).size());
List snapAssets = iteratorToList( pkg2.getAssets() );

RulesRepository repo = RepositorySessionUtil.getRepository();
ModuleItem pkg = repo.createModule("testRestDelete", "", ModuleItem.MODULE_FORMAT);
pkg.updateStringProperty("This is some header", ModuleItem.HEADER_PROPERTY_NAME);
repo.save();
AssetItem asset1 = pkg.addAsset("asset1", "");
asset1.updateContent("this is content");
asset1.updateFormat("drl");
api.delete("packages/testRestDelete/asset1.drl");
List l = RulesRepositoryTest.iteratorToList(pkg.listAssetsByFormat(new String[] {"drl"}));
assertEquals(0, l.size());
l = RulesRepositoryTest.iteratorToList(pkg.listArchivedAssets());
assertEquals(1, l.size());
AssetItem ass = pkg.loadAsset("asset1");
assertEquals("123", ass.getContent());
assertEquals("new comment", ass.getCheckinComment());
assertFalse(ass.isArchived());
l = RulesRepositoryTest.iteratorToList(pkg.listAssetsByFormat(new String[] {"drl"}));
assertEquals(1, l.size());

AssetItem item = pkg.addAsset( "testVersionedAssetItemIteratorAsset1", "" );
item.updateFormat( "xyz" );
item.checkin( "la" );
item = pkg.addAsset( "testVersionedAssetItemIteratorAsset2", "wee" );
item.updateFormat( "xyz" );
item.checkin( "la" );
item = pkg.addAsset( "testVersionedAssetItemIteratorAsset3", "wee" );
item.updateFormat( "ABC" );
item.checkin( "version 1" );
pkg.updateDependency("testVersionedAssetItemIteratorAsset3?version=2");
pkg.checkin("Update dependency");
pkg.checkout();
pkg.checkin("version 3");
String[] dependencies = pkg.getDependencies();
assertEquals(dependencies.length, 3);
AssetItemIterator it = pkg.listAssetsByFormat( new String[] {"xyz", "ABC"} );
List list = iteratorToList( it );
assertEquals(3, list.size());
it = pkg.listAssetsByFormat( new String[] {"ABC"} );
assertTrue(it instanceof VersionedAssetItemIterator);
list = iteratorToList( it );

public static String getHeader(ModuleItem pkg) {
  if (pkg.containsAsset("drools")) {
    return pkg.loadAsset("drools").getContent();
  } else {
    return "";
  }
}

@Test
public void testAddAssetTrailingWhitespace() {
  ModuleItem pkg = getRepo().createModule("testAddAssetTrailingWhitespace","desc");
  pkg.addAsset("wee ", "");
  assertNotNull(pkg.loadAsset("wee"));
}

pkg.updateStringProperty("This is some header", ModuleItem.HEADER_PROPERTY_NAME);
repo.save();
AssetItem asset1 = pkg.addAsset("asset1", "");
asset1.updateContent("this is content");
asset1.updateFormat("drl");
AssetItem asset2 = pkg.addAsset("asset2", "");
ByteArrayInputStream in = new ByteArrayInputStream("abc".getBytes());
asset2.updateBinaryContentAttachment(in);
api.put("packages/testRestPut/asset1.drl", Calendar.getInstance(), new ByteArrayInputStream("qaz".getBytes()), "a new comment");
AssetItem asset1_ = pkg.loadAsset("asset1");
assertEquals("qaz", asset1_.getContent());
assertEquals("a new comment", asset1_.getCheckinComment());
AssetItem asset2_ = pkg.loadAsset("asset2");
assertEquals("def", new String(asset2_.getBinaryContentAsBytes()));
assertEquals("a new comment", asset2_.getCheckinComment());
assertEquals("whee", pkg.getStringProperty(ModuleItem.HEADER_PROPERTY_NAME));

@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());
}

RulesRepository repo = RepositorySessionUtil.getRepository();
ModuleItem pkg = repo.createModule("testRestGetBasics", "", ModuleItem.MODULE_FORMAT);
pkg.updateStringProperty("This is some header", ModuleItem.HEADER_PROPERTY_NAME);
repo.save();
AssetItem asset1 = pkg.addAsset("asset1", "");
asset1.updateContent("this is content");
asset1.updateFormat("drl");
asset1.checkin("");
AssetItem asset2 = pkg.addAsset("asset2", "");
asset2.updateContent("this is content");
asset2.updateFormat("xml");
asset2.checkin("");
AssetItem asset3 = pkg.addAsset("asset3", "");
ByteArrayInputStream in = new ByteArrayInputStream("abc".getBytes());
asset3.updateBinaryContentAttachment(in);
Response res = api.get(url);
assertNotNull(res.lastModified);
assertEquals(pkg.getLastModified(), res.lastModified);
ByteArrayOutputStream out = new ByteArrayOutputStream();
res.writeData(out);
assertEquals(pkg.getStringProperty(ModuleItem.HEADER_PROPERTY_NAME), dotPackage);

  @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());
  }
  

@Test
public void testRemoveShareableAsset() throws Exception {
  AssetItem asset = loadGlobalArea().addAsset("testRemoveShareableAssetAsset", "desc");
  asset.updateContent("la");
  asset.checkin("initial");
  AssetItem linkedAsset = getDefaultPackage().addAssetImportedFromGlobalArea(asset.getName());
  linkedAsset.updateContent("laa");
  linkedAsset.checkin("second");
  // REVISIT: the shared asset can not be removed unless no asset refers to it.
  // asset.remove();
  linkedAsset.remove();
  try {
    AssetItem linkedAsset1 = getDefaultPackage().loadAsset("testRemoveShareableAssetAsset");
    fail("Did not get expected exception");
  } catch (RulesRepositoryException e) {
  }
  AssetItem asset1 = loadGlobalArea().loadAsset("testRemoveShareableAssetAsset");
  assertTrue(asset.getUUID().equals(asset1.getUUID()));
}

@Test
public void testImportExportWithShareableNodes() throws Exception {
  RulesRepository repo = getRepo();
  AssetItem item = repo.loadDefaultModule().addAsset("testImportExportShareableNodeOriginal", "desc");
  item.updateContent("la");
  ModuleItem.ensureMixinType(item, "mix:shareable");
  ModuleItem source = repo.createModule("testImportExportShareableNodesPackage", "desc");
  repo.save();
  source.checkout();
  Session session = item.getNode().getSession();
  Workspace workspace = session.getWorkspace();
  String path = "/drools:repository/drools:package_area/testImportExportShareableNodesPackage/assets/testImportExportShareableNodeShared";
  workspace.clone(workspace.getName(), item.getNode().getPath(), path, false);
  repo.save();
  byte[] repository_backup;
  ByteArrayOutputStream bout = new ByteArrayOutputStream();
  repo.exportRepositoryToStream(bout);
  repository_backup = bout.toByteArray();
  assertNotNull(repository_backup);
  repo.importRulesRepositoryFromStream(new ByteArrayInputStream(
      repository_backup));
  assertTrue(repo.containsModule("testImportExportShareableNodesPackage"));
  assertTrue(repo.loadModule("testImportExportShareableNodesPackage").containsAsset("testImportExportShareableNodeOriginal"));
}

@Test
public void testShareableNodesWithQuery() throws Exception {
  RulesRepository repo = getRepo();
  AssetItem item = repo.loadGlobalArea().addAsset("testShareableNodesWithQueryOriginal", "desc");
  item.updateFormat("xyz");
  item.getNode().addMixin("mix:shareable");
  ModuleItem source = repo.createModule("testShareableNodesWithQueryPackage", "desc");
  repo.save();
  AssetItemIterator it = repo.loadGlobalArea().queryAssets( "drools:format='xyz'" );
  List list = iteratorToList( it );
  assertEquals(1, list.size());
  assertTrue(list.get( 0 ) instanceof AssetItem);
  
  source.checkout();
  Session session = repo.getSession();
  Workspace workspace = session.getWorkspace();
  String path = "/drools:repository/drools:package_area/testShareableNodesWithQueryPackage/assets/testShareableNodesWithQueryShared";
  workspace.clone(workspace.getName(), item.getNode().getPath(), path, false);
  repo.save();
  AssetItem originalItem = repo.loadGlobalArea().loadAsset("testShareableNodesWithQueryOriginal");
  AssetItem sharedItem = repo.loadModule("testShareableNodesWithQueryPackage").loadAsset("testShareableNodesWithQueryShared");
  assertTrue( originalItem.getFormat().equals("xyz"));
  assertTrue( sharedItem.getFormat().equals("xyz"));
  it = repo.loadGlobalArea().queryAssets( "drools:format='xyz'" );
  list = iteratorToList( it );
  assertEquals(1, list.size());
  assertTrue(list.get( 0 ) instanceof AssetItem);
}

getRepo().save();
String[] dependencies = item.getDependencies();
assertEquals(dependencies.length, 0);
AssetItem rule = item.addAsset("testDependenciesWithHistoricalVersionAsset1", "w");
dependencies = item.getDependencies();
assertEquals(dependencies.length, 1);
assertEquals(
    dependencies[0]);
item.checkout();
item.checkin("v1");
ModuleItem historicalPackage = getRepo().loadModule("testDependenciesWithHistoricalVersion", 2);
dependencies = historicalPackage.getDependencies();
assertEquals(1, dependencies.length);
    dependencies[0]);
item.checkout();
item.checkin("v2");
historicalPackage = getRepo().loadModule("testDependenciesWithHistoricalVersion", 3);
dependencies = historicalPackage.getDependencies();
assertEquals(1, dependencies.length);