How to use

loadModule

method

in

org.drools.repository.RulesRepository

/**
 * This will return the global area for assets that can be shared.
 */
public ModuleItem loadGlobalArea() throws RulesRepositoryException {
  return loadModule(GLOBAL_AREA);
}

@Test
public void testMigrate() throws Exception {
  RulesRepository repo = getRepo();
  Session sess = repo.getSession();
  sess.getRootNode().getNode(RulesRepository.RULES_REPOSITORY_NAME).getNode("drools.package.migrated").remove();
  sess.save();
  MigrateDroolsPackage mig = new MigrateDroolsPackage();
  ModuleItem pkg = repo.createModule("testMigratePackage", "");
  pkg.updateStringProperty("some header", ModuleItem.HEADER_PROPERTY_NAME);
  sess.save();
  repo.createModuleSnapshot("testMigratePackage", "SNAP1");
  repo.createModuleSnapshot("testMigratePackage", "SNAP2");
  assertTrue(mig.needsMigration(repo));
  mig.migrate(repo);
  assertFalse(repo.getSession().hasPendingChanges());
  assertFalse(mig.needsMigration(repo));
  pkg = repo.loadModule("testMigratePackage");
  assertTrue(pkg.containsAsset("drools"));
  AssetItem as = pkg.loadAsset("drools");
  assertEquals("some header", as.getContent());
  pkg = repo.loadModuleSnapshot("testMigratePackage", "SNAP1");
  assertTrue(pkg.containsAsset("drools"));
  as = pkg.loadAsset("drools");
  assertEquals("some header", as.getContent());
  pkg = repo.loadModuleSnapshot("testMigratePackage", "SNAP2");
  assertTrue(pkg.containsAsset("drools"));
  as = pkg.loadAsset("drools");
  assertEquals("some header", as.getContent());
}

/**
 * This will return the global area for assets that can be shared.
 */
public ModuleItem loadGlobalArea() throws RulesRepositoryException {
  return loadModule(GLOBAL_AREA);
}

/**
 * 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);
  }
}

/**
 * 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);
  }
}

/**
 * This moves an asset from one module to another, preserving history
 * etc etc.
 *
 * @param newModule  The destination module.
 * @param uuid        The UUID of the asset
 * @param explanation The reason (which will be added as the checkin message).
 */
public void moveRuleItemModule(String newModule,
                String uuid,
                String explanation) {
  try {
    AssetItem item = loadAssetByUUID(uuid);
    String sourcePath = item.node.getPath();
    String destPath = loadModule(newModule).node.getPath() + "/" + ModuleItem.ASSET_FOLDER_NAME + "/" + item.getName();
    this.session.move(sourcePath,
        destPath);
    this.session.save();
    item.checkout();
    item.node.setProperty(AssetItem.MODULE_NAME_PROPERTY,
        newModule);
    item.checkin(explanation);
  } catch (RepositoryException e) {
    throw new RulesRepositoryException(e);
  }
}

/**
 * This will get the module an asset item belongs to.
 */
public ModuleItem getModule() {
  try {
    if ( this.isHistoricalVersion() ) {
      return this.rulesRepository.loadModule( this.getModuleName() );
    }
    return new ModuleItem( this.rulesRepository,
                this.node.getParent().getParent() );
  } catch ( RepositoryException e ) {
    throw new RulesRepositoryException( e );
  }
}

  public void run() {
    try {
      //This returns different repository instances for different threads
      localRepo.copyModule("testConcurrentCopyPackage",
          "testConcurrentCopyPackage2");
      ModuleItem dest = localRepo.loadModule("testConcurrentCopyPackage2");
      assertNotNull(dest);
      randomSleep();
    } catch (RulesRepositoryException rre) {
      //expected
      System.out.println("Expected");
    } finally {
    }
  }
}

/**
 * This will get the module an asset item belongs to.
 */
public ModuleItem getModule() {
  try {
    if ( this.isHistoricalVersion() ) {
      return this.rulesRepository.loadModule( this.getModuleName() );
    }
    return new ModuleItem( this.rulesRepository,
                this.node.getParent().getParent() );
  } catch ( RepositoryException e ) {
    throw new RulesRepositoryException( e );
  }
}

@Test
public void testPostNewPackage() throws Exception {
  RulesRepository repo = RepositorySessionUtil.getRepository();
  RestAPI api = new RestAPI(repo);
  api.setAssetValidator(new AssetValidator());
  api.post("/packages/testPostNewPackage/.package", new ByteArrayInputStream("qaz".getBytes()), "This is a new package");
  ModuleItem pkg = repo.loadModule("testPostNewPackage");
  assertEquals("qaz", pkg.getStringProperty(ModuleItem.HEADER_PROPERTY_NAME));
  assertEquals("This is a new package", pkg.getCheckinComment());
}

@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 testLoadRulePackageItem() {
  ModuleItem rulePackageItem = getRepo().createModule("testLoadRuleRuleItem", "desc");
  rulePackageItem = getRepo().loadModule("testLoadRuleRuleItem");
  assertNotNull(rulePackageItem);
  assertEquals("testLoadRuleRuleItem", rulePackageItem.getName());
  assertEquals("desc", rulePackageItem.getDescription());
  assertEquals(ModuleItem.MODULE_FORMAT, rulePackageItem.getFormat());
  // try loading rule package that was not created
  try {
    rulePackageItem = getRepo().loadModule("anotherRuleRuleItem");
    fail("Exception not thrown loading rule package that was not created.");
  } catch (RulesRepositoryException e) {
    // that is OK!
    assertNotNull(e.getMessage());
  }
}

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

@Test 
public void testPackageWorkspaceProperty() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem item = repo.createModule( "testPackageWorkspaceProperty1", "lalalala" );
  getRepo().save();
  
  String[] workspaces = repo.loadModule(item.getName()).getWorkspaces();
  item.removeWorkspace("workspace1");
  
  workspaces = item.getWorkspaces();
  assertEquals(workspaces.length, 0);
  item.addWorkspace("workspace1");
  item.addWorkspace("workspace2");
  item.addWorkspace("workspace1");
  item.addWorkspace("workspace2");
  workspaces = item.getWorkspaces();
  assertEquals(workspaces.length, 2);
  
  item.removeWorkspace("workspace1");
  item.removeWorkspace("workspace3");
  workspaces = item.getWorkspaces();
  assertEquals(workspaces.length, 1);
  assertTrue((workspaces[0]).equals("workspace2"));
}

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