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

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 List l =new LinkedList()
Collections.emptyList()
new ArrayList()
Smart code suggestions by Tabnine
}

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

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

/**
 * Return true if the binary is "up to date".
 *
 * @return
 */
public boolean isBinaryUpToDate() {
  try {
    return this.node.hasProperty(BINARY_UP_TO_DATE) && node.getProperty(BINARY_UP_TO_DATE).getBoolean();
  } catch (RepositoryException e) {
    log.error("fail to get drools:binaryUpToDate of " + getName(),
        e);
    throw new RulesRepositoryException(e);
  }
}

/**
 * Return true if the binary is "up to date".
 *
 * @return
 */
public boolean isBinaryUpToDate() {
  try {
    return this.node.hasProperty(BINARY_UP_TO_DATE) && node.getProperty(BINARY_UP_TO_DATE).getBoolean();
  } catch (RepositoryException e) {
    log.error("fail to get drools:binaryUpToDate of " + getName(),
        e);
    throw new RulesRepositoryException(e);
  }
}

private void setUpPackageItem() {
  packageItem = mock( ModuleItem.class );
  when( packageItem.getName() ).thenReturn( "mock" );
}

/**
 * This will permanently delete this module.
 */
public void remove() {
  checkIsUpdateable();
  try {
    log.info("USER:" + getCurrentUserName() + " REMOVEING module [" + getName() + "]");
    this.node.remove();
  } catch (RepositoryException e) {
    throw new RulesRepositoryException("Was not able to delete module.",
        e);
  }
}

/**
 * This will permanently delete this module.
 */
public void remove() {
  checkIsUpdateable();
  try {
    log.info("USER:" + getCurrentUserName() + " REMOVEING module [" + getName() + "]");
    this.node.remove();
  } catch (RepositoryException e) {
    throw new RulesRepositoryException("Was not able to delete module.",
        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 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.");
  }
}

@Test
public void testRulePackageItem() throws Exception {
  RulesRepository repo = getRepo();
  //calls constructor
  ModuleItem rulePackageItem1 = repo.createModule("testRulePackage", "desc");
  assertNotNull(rulePackageItem1);
  assertEquals("testRulePackage", rulePackageItem1.getName());
  Iterator it = getRepo().listModules();
  assertTrue(it.hasNext());
  while (it.hasNext()) {
    ModuleItem pack = (ModuleItem) it.next();
    if (pack.getName().equals( "testRulePackage" )) {
      return;
    }
  }
  fail("should have picked up the testRulePackage but didnt.");
}

@Test
public void testListPackages() {
  RulesRepository rulesRepository = getRepo();
  rulesRepository.createModule( "testListPackages",
                  "desc" );
  assertTrue( rulesRepository.containsModule( "testListPackages" ) );
  assertFalse( rulesRepository.containsModule( "XXXXXXX" ) );
  Iterator it = rulesRepository.listModules();
  assertTrue( it.hasNext() );
  boolean found = false;
  //listPackages() should not return the global area even though the global area is a package.
  boolean foundGlobalArea = false;
  while ( it.hasNext() ) {
    ModuleItem element = (ModuleItem) it.next();
    if ( element.getName().equals( "testListPackages" ) ) {
      found = true;
    }
    
    if ( element.getName().equals(RulesRepository.GLOBAL_AREA) ) {
      foundGlobalArea = true;
    }
   }
  assertTrue( found );
  assertFalse( foundGlobalArea );
}

@Test
public void testGetPackageItem() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem def = repo.loadDefaultModule();
  AssetItem asset = repo.loadDefaultModule().addAsset("testPackageItem", "test content");
  ModuleItem pkg = asset.getModule();
  assertEquals(def.getName(), pkg.getName());
  assertEquals(def.getUUID(), pkg.getUUID());
}

@Test
public void testDefaultPackage() throws Exception {
  RulesRepository repo = getRepo();
  Iterator it = repo.listModules();
  boolean foundDefault = false;
  while ( it.hasNext() ) {
    ModuleItem item = (ModuleItem) it.next();
    if ( item.getName().equals( RulesRepository.DEFAULT_PACKAGE ) ) {
      foundDefault = true;
    }
  }
  assertTrue( foundDefault );
  ModuleItem def = repo.loadDefaultModule();
  assertNotNull( def );
  assertEquals( RulesRepository.DEFAULT_PACKAGE,
         def.getName() );
  String userId = repo.getSession().getUserID();
  assertNotNull( userId );
  assertFalse( userId.equals( "" ) );
  MigrateDroolsPackage mig = new MigrateDroolsPackage();
  assertFalse( mig.needsMigration( repo ) );
  assertTrue( repo.initialized );
}

@Test
public void testGetPackageItemHistorical() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem pkg = repo.createModule("testGetPackageItemHistorical", "");
  AssetItem asset = pkg.addAsset("whee", "");
  asset.checkin("");
  assertNotNull(asset.getModule());
  repo.createModuleSnapshot(pkg.getName(), "SNAP");
  ModuleItem pkg_ = repo.loadModuleSnapshot(pkg.getName(), "SNAP");
  AssetItem asset_ = pkg_.loadAsset("whee");
  ModuleItem pkg__ = asset_.getModule();
  assertTrue(pkg__.isSnapshot());
  assertTrue(pkg_.isSnapshot());
  assertFalse(pkg.isSnapshot());
  assertEquals(pkg.getName(), pkg__.getName());
  asset.updateDescription("yeah !");
  asset.checkin("new");
  asset = pkg.loadAsset("whee");
  assertNotNull(asset.getModule());
  AssetHistoryIterator it = asset.getHistory();
  while(it.hasNext()) {
    AssetItem as = it.next();
    if (as.getVersionNumber() > 0) {
      System.err.println(as.getVersionNumber());
      System.err.println(as.getModuleName());
      assertNotNull(as.getModule());
      assertEquals(pkg.getName(), as.getModule().getName());
    }
  }
}

@Test
public void testDuplicatePackageName() throws Exception {
  ModuleItem pack = getRepo().createModule( "dupePackageTest", "testing for dupe" );
  assertNotNull(pack.getName());
  try {
    getRepo().createModule( "dupePackageTest", "this should fail" );
    fail("Should not be able to add a package of the same name.");
  } catch (RulesRepositoryException e) {
    assertNotNull(e.getMessage());
  }
}

String name = getDefaultPackage().getName();
getRepo().createModuleSnapshot(getDefaultPackage().getName(), "SNAP");
ModuleItem pkgSnap = getRepo().loadModuleSnapshot(getDefaultPackage().getName(), "SNAP");
AssetItem assetSnap = pkgSnap.loadAsset("testGetPackageItemHistoricalForShareableAsset");
ModuleItem pkgSnap1 = assetSnap.getModule();
assertTrue(pkgSnap.isSnapshot());
assertFalse(getDefaultPackage().isSnapshot());
assertEquals(getDefaultPackage().getName(), pkgSnap1.getName());
assertFalse(linkedPkg.isSnapshot());
assertFalse(getDefaultPackage().isSnapshot());
assertEquals(getDefaultPackage().getName(), linkedPkg.getName());

@Test
public void testAssetItemCreation() throws Exception {
    Calendar now = Calendar.getInstance();
    Thread.sleep(500); //MN: need this sleep to get the correct date
    AssetItem ruleItem1 = getDefaultPackage().addAsset("testRuleItem", "test content");
    assertNotNull(ruleItem1);
    assertNotNull(ruleItem1.getNode());
    assertEquals("testRuleItem", ruleItem1.getName());
    assertNotNull(ruleItem1.getCreatedDate());
    assertTrue(now.before( ruleItem1.getCreatedDate() ));
    String packName = getDefaultPackage().getName();
    assertEquals(packName, ruleItem1.getModuleName());
    assertNotNull(ruleItem1.getUUID());
  //try constructing with node of wrong type
  try {
    ModuleItem pitem = getRepo().loadDefaultModule();
    new AssetItem(getRepo(), pitem.getNode());
    fail("Exception not thrown for node of wrong type");
  }
  catch(RulesRepositoryException e) {
    assertNotNull(e.getMessage());
  }
  catch(Exception e) {
    fail("Caught unexpected exception: " + e);
  }
}

@Test
public void testLoadRulePackageItemByUUID() throws Exception {
  ModuleItem rulePackageItem = getRepo().createModule("testLoadRuleRuleItemByUUID", "desc");
  String uuid = null;
    uuid = rulePackageItem.getNode().getUUID();
  rulePackageItem = getRepo().loadModuleByUUID(uuid);
  assertNotNull(rulePackageItem);
  assertEquals("testLoadRuleRuleItemByUUID", rulePackageItem.getName());
  // try loading rule package that was not created
  try {
    rulePackageItem = getRepo().loadModuleByUUID("01010101-0101-0101-0101-010101010101");
    fail("Exception not thrown loading rule package that was not created.");
  } catch (RulesRepositoryException e) {
    // that is OK!
    assertNotNull(e.getMessage());
  }
}

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

Javadoc

Return the name of the 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.
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
getAssets
Return an iterator for the rules in this module

Popular in Java

Making http requests using okhttp
getSupportFragmentManager (FragmentActivity)
getResourceAsStream (ClassLoader)
runOnUiThread (Activity)
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
Collections (java.util)
This class consists exclusively of static methods that operate on or return collections. It contains
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
ReentrantLock (java.util.concurrent.locks)
A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor
Manifest (java.util.jar)
The Manifest class is used to obtain attribute information for a JarFile and its entries.

How to use getNamemethodin org.drools.repository.ModuleItem

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

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