How to use

RulesRepository

in

org.drools.repository

/**
 * This will return or create the default module for assets that have no
 * home yet.
 */
public ModuleItem loadDefaultModule() throws RulesRepositoryException {
  Node folderNode = this.getAreaNode(MODULE_AREA);
  try {
    if (folderNode.hasNode(DEFAULT_PACKAGE)) {
      return loadModule(DEFAULT_PACKAGE);
    } else {
      return createModule(DEFAULT_PACKAGE,
          "");
    }
  } catch (RepositoryException e) {
    throw new RulesRepositoryException(e);
  }
}

public void migrate(RulesRepository repo) throws RepositoryException {
  log.info("AUTO MIGRATION: Performing drools.package migration...");
  ModuleIterator pkgs = repo.listModules();
  boolean performed = false;
  while(pkgs.hasNext()) {
    performed = true;
    ModuleItem pkg = (ModuleItem) pkgs.next();
    migratePackage(pkg);
    String[] snaps = repo.listModuleSnapshots(pkg.getName());
    if (snaps != null) {
      for (int i = 0; i < snaps.length; i++) {
        ModuleItem snap = repo.loadModuleSnapshot(pkg.getName(), snaps[i]);
        migratePackage(snap);
      }
    }
  }
  if (performed) {
    repo.getSession().getRootNode().getNode(RulesRepository.RULES_REPOSITORY_NAME).addNode("drools.package.migrated", "nt:folder");
    repo.save();
    log.info("AUTO MIGRATION: drools.package migration completed.");
  }
}

public AssetItemPageResult findAssetsByCategory(String categoryTag,
                        int skip,
                        int numRowsToReturn) throws RulesRepositoryException {
  return this.findAssetsByCategory(categoryTag,
      false,
      skip,
      numRowsToReturn);
}

private Node getMetaDataTypeNode(String metadataType)
    throws RepositoryException {
  Node schemaNode = getAreaNode(SCHEMA_AREA);
  return addNodeIfNew(
      addNodeIfNew(schemaNode,
          METADATA_TYPE_AREA,
          "nt:folder"),
      metadataType,
      "nt:file");
}

public void removeWorkspace(String workspace) {
  try {
    Node schemaNode = addNodeIfNew(this.session.getRootNode().getNode(RULES_REPOSITORY_NAME),
        SCHEMA_AREA,
        "nt:folder");
    Node workspaceAreaNode = addNodeIfNew(schemaNode,
        WORKSPACE_AREA,
        "nt:folder");
    Node workspaceNode = workspaceAreaNode.getNode(workspace);
    workspaceNode.remove();
    this.getSession().save();
  } catch (Exception e) {
    log.error(e.getMessage(),
        e);
    throw new RulesRepositoryException(e);
  }
}

@Test
public void testIgnoreState() throws Exception {
  ModuleItem pack = getRepo().createModule( "package testIgnoreState", "foo" );
  getRepo().createState( "x" );
  AssetItem rule1 = pack.addAsset( "rule number 1", "yeah man" );
  rule1.updateState( "x" );
  rule1.checkin( "version0" );
  AssetItem rule2 = pack.addAsset( "rule number 2", "no way" );
  rule2.updateState( "x" );
  rule2.checkin( "version0" );
  AssetItem rule3 = pack.addAsset( "rule number 3", "yes way" );
  getRepo().createState( "disabled" );
  rule3.updateState( "disabled" );
  rule3.checkin( "version0" );
  getRepo().save();
  Iterator result = pack.getAssetsWithStatus( getRepo().getState( "x" ), getRepo().getState( "disabled" ) );
  List l = iteratorToList( result );
  assertEquals(2, l.size());
}

public void testCategoriesAndSnapshots() throws Exception {
  RulesRepository repo = getRepo();
  repo.loadCategory( "/" ).addCategory( "testCategoriesAndSnapshots",
                     "X" );
  ModuleItem pkg = repo.createModule( "testCategoriesAndSnapshots",
                     "" );
  pkg.addAsset( "testCat1",
         "/testCategoriesAndSnapshots",
         "drl" );
  repo.save();
  List items = repo.findAssetsByCategory( "/testCategoriesAndSnapshots",
                      0,
                      -1 ).assets;
  repo.createModuleSnapshot( "testCategoriesAndSnapshots",
                "SNAP 1" );
  items = repo.findAssetsByCategory( "testCategoriesAndSnapshots",
                    0,
                    -1 ).assets;
  assertTrue( repo.containsSnapshot( "testCategoriesAndSnapshots",
                    "SNAP 1" ) );
  assertFalse( repo.containsSnapshot( "testCategoriesAndSnapshots",
                    "SNAP XXXX" ) );
  assertFalse( repo.containsSnapshot( "gooberWhhewasssllllelelelelele",

@Test
public void testShareableNodes() throws Exception {
  RulesRepository repo = getRepo();
  AssetItem item = repo.loadDefaultModule().addAsset("testShareableNodeOriginal", "desc");
  item.updateContent("la");
  item.getNode().addMixin("mix:shareable");
  ModuleItem source = repo.createModule("testShareableNodesPackage", "desc");
  repo.save();
  source.checkout();
  Session session = repo.getSession();
  Workspace workspace = session.getWorkspace();
  String path = "/drools:repository/drools:package_area/testShareableNodesPackage/assets/testShareableNodeShared";
  workspace.clone(workspace.getName(), item.getNode().getPath(), path, false);
  repo.save();
  AssetItem originalItem = repo.loadDefaultModule().loadAsset("testShareableNodeOriginal");
  AssetItem sharedItem = repo.loadModule("testShareableNodesPackage").loadAsset("testShareableNodeShared");
  assertTrue( originalItem.getContent().equals("la"));
  assertTrue( sharedItem.getContent().equals("la"));
  originalItem.remove();
}

@Test
public void testPackageRemove() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem p = repo.createModule("removeMe", "");
  AssetItem a = p.addAsset("Whee", "");
  a.updateContent("yeah");
  a.checkin("la");
  p.addAsset("Waa", "");
  repo.save();
  ModuleItem pkgNested = p.createSubModule("NestedGoodness");
  assertNotNull(pkgNested);
  int n = iteratorToList(repo.listModules()).size();
  p = repo.loadModule("removeMe");
  p.remove();
  repo.save();
  int n_ = iteratorToList(repo.listModules()).size();
  assertEquals(n - 1, n_);
}

  @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 testFindAssetsByState() throws Exception {
  RulesRepository repo = getRepo();
  repo.loadCategory( "/" ).addCategory( "testFindAssetsByStateCat",
                     "X" );
  ModuleItem pkg = repo.createModule( "testFindAssetsByStatePac",
                     "" );
  pkg.addAsset( "testCat1",
         "drl" );
  repo.save();
  AssetItemPageResult apl = repo.findAssetsByState( "Draft",
                        false,
                        0,

ModuleItem rulePackageItem = repo.loadDefaultModule();
AssetItem rule = rulePackageItem.addAsset( "testLoadRuleByUUID",
                      "this is a description" );
repo.save();
AssetItem loaded = repo.loadAssetByUUID( uuid );
assertNotNull( loaded );
assertEquals( "testLoadRuleByUUID",
AssetItem reload = repo.loadAssetByUUID( uuid );
assertEquals( "testLoadRuleByUUID",
       reload.getName() );
  repo.loadAssetByUUID( "01010101-0101-0101-0101-010101010101" );
  fail( "Exception not thrown loading rule package that was not created." );
} catch ( RulesRepositoryException e ) {
AssetItem asset1 = repo.loadDefaultModule().addAsset( "testMultiSession",
                            "description" );
asset1.updateContent( "yeah" );
uuid = asset1.getUUID();
asset1.updateState( "Draft" );
repo.save();
Session s2 = repo.getSession().getRepository().login( new SimpleCredentials( "fdd",
                                       "password".toCharArray() ) );

@Test
public void testFindAssetsByCategory() throws Exception {
  RulesRepository repo = getRepo();
  repo.loadCategory( "/" ).addCategory( "testFindAssetsByCategoryUsingFilterCat",
                     "X" );
  ModuleItem pkg = repo.createModule( "testFindAssetsByCategoryUsingFilterPack",
                     "" );
  pkg.addAsset( "testCat1",
  repo.save();
  List items = repo.findAssetsByCategory( "/testFindAssetsByCategoryUsingFilterCat",
                      0,
                      -1 ).assets;
  AssetItemPageResult apl = repo.findAssetsByCategory( "/testFindAssetsByCategoryUsingFilterCat",
                          false,
                          0,
  repo.save();
  apl = repo.findAssetsByCategory( "/testFindAssetsByCategoryUsingFilterCat",
                   0,
                   -1 );
  int skip = 0;
  while ( hasNext ) {
    apl = repo.findAssetsByCategory( "/testFindAssetsByCategoryUsingFilterCat",
                     skip,

@Test
public void testFormatOtherThanDroolsPackage() {
  ModuleItem rulePackageItem1 = getRepo().createModule(
      "testFormatOtherThanDroolsPackage", "woot");
  assertNotNull(rulePackageItem1);
  // PACKAGE_FORMAT is the default module format
  assertEquals(ModuleItem.MODULE_FORMAT, rulePackageItem1.getFormat());
  rulePackageItem1.updateFormat("soaservice");
  ModuleItem item = getRepo().loadModule(
      "testFormatOtherThanDroolsPackage");
  assertEquals("soaservice", item.getFormat());
}

@Test
public void testFindByState() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem pkg = repo.createModule( "testFindByStatePackage",
                     "heheheh" );
  AssetItem asset1 = pkg.addAsset( "asset1",
                   "" );
  AssetItem asset2 = pkg.addAsset( "asset2",
                   "" );
  repo.createState( "testFindByState" );
  repo.save();
  asset1.updateState( "testFindByState" );
  asset2.updateState( "testFindByState" );
  asset1.checkin( "" );
  asset2.checkin( "" );
  AssetItemPageResult result = repo.findAssetsByState( "testFindByState",
                         true,
                         0,
                         -1 );
  assertEquals( 2,
         result.assets.size() );
}

@Test
public void testMiscProperties() {
  ModuleItem item = getRepo().createModule( "testHeader", "ya" );
  updateHeader( "new header", item );
  item.updateExternalURI( "boo" );
  getRepo().save();
  assertEquals("new header", getHeader(item));
  item = getRepo().loadModule("testHeader");
  assertEquals("new header", getHeader(item));
  assertEquals("boo", item.getExternalURI());
}

repo.loadDefaultModule().addAsset( "findRulesByNamex1",
                  "X" );
repo.loadDefaultModule().addAsset( "findRulesByNamex2",
                  "X" );
repo.save();
List list = iteratorToList( repo.findAssetsByName( "findRulesByNamex1" ) );
assertEquals( 1,
       list.size() );
list = iteratorToList( repo.findAssetsByName( "findRulesByNamex2" ) );
assertEquals( 1,
       list.size() );
list = iteratorToList( repo.findAssetsByName( "findRulesByNamex%" ) );
assertEquals( 2,
       list.size() );
repo.createModuleSnapshot( RulesRepository.DEFAULT_PACKAGE,
              "testFindRulesByName" );
repo.save();
list = iteratorToList( repo.findAssetsByName( "findRulesByNamex2" ) );
AssetItem item = (AssetItem) list.get( 0 );
assertEquals( "findRulesByNamex2",
list = iteratorToList( repo.findAssetsByName( "findRulesByNamex%" ) );
assertEquals( 2,
       list.size() );

CategoryItem root = repo.loadCategory( "/" );
root.addCategory( "testCatRename",
         "" );
repo.loadCategory( "testCatRename" ).addCategory( "testRename",
                         "" );
repo.renameCategory( "testCatRename/testRename",
           "testAnother" );
CategoryItem cat = repo.loadCategory( "testCatRename/testAnother" );
assertNotNull( cat );
try {
  repo.loadCategory( "testCatRename/testRename" );
  fail( "should not exist." );
} catch ( RulesRepositoryException e ) {
ModuleItem pkg = repo.createModule( "testCategoryRename",
                   "" );
AssetItem asset = pkg.addAsset( "fooBar",
cat = repo.loadCategory( "testCatRename/testAnother" );
AssetItemPageResult as = repo.findAssetsByCategory( "testCatRename/testAnother",
                       0,
                       -1 );
repo.renameCategory( "testCatRename/testAnother",
           "testYetAnother" );
as = repo.findAssetsByCategory( "testCatRename/testYetAnother",
                0,

@Test
public void testRemoveCategoryUneeded() {
  RulesRepository repo = getRepo();
  repo.loadCategory("/").addCategory("testRemoveCat", "a");
  AssetItem as = repo.loadDefaultModule().addAsset("testRemoveCategory", "a", "testRemoveCat", "drl");
  as.checkin("a");
  as.updateCategoryList(new String[] {});
  as.checkin("a");
  as = repo.loadDefaultModule().loadAsset("testRemoveCategory");
  assertEquals(0, as.getCategories().size());
  repo.loadCategory("testRemoveCat").remove();
  repo.save();
}

@Test
public void testCategoriesPagination() {
    ModuleItem pkg = getRepo().createModule("testPagination", "");
    getRepo().loadCategory( "/" ).addCategory( "testPagedTag", "description" );
    a.checkin("");
    AssetItemPageResult result = getRepo().findAssetsByCategory("testPagedTag", 0, -1);
    assertTrue(result.currentPosition > 0);
    assertEquals(5, result.assets.size());
    result = getRepo().findAssetsByCategory("testPagedTag", 0, 2);
    assertTrue(result.currentPosition > 0);
    assertEquals(true, result.hasNext);
    assertEquals("testPage2", ((AssetItem) result.assets.get(1)).getName());
    result = getRepo().findAssetsByCategory("testPagedTag", 2, 2);
    assertTrue(result.currentPosition > 0);
    assertEquals(true, result.hasNext);
    assertEquals("testPage4", ((AssetItem) result.assets.get(1)).getName());
    result = getRepo().findAssetsByCategory("testPagedTag", 2, 3);
    assertTrue(result.currentPosition > 0);
    assertEquals(false, result.hasNext);