Codota Logo
RulesRepository.createModule
Code IndexAdd Codota to your IDE (free)

How to use
createModule
method
in
org.drools.repository.RulesRepository

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

  • Common ways to obtain RulesRepository
private void myMethod () {
RulesRepository r =
  • Codota IconSession session;new RulesRepository(session)
  • Smart code suggestions by Codota
}
origin: org.drools/guvnor-repository

/**
 * Adds a module to the repository.
 *
 * @param name        what to name the node added
 * @param description what description to use for the node
 * @return a ModuleItem, encapsulating the created node
 * @throws RulesRepositoryException
 */
public ModuleItem createModule(String name,
                 String description) throws RulesRepositoryException {
  //TODO: As we are moving towards a generic repository, create a module that is default to drools_package format
  //may not be correct.
  return createModule(name,
      description,
      ModuleItem.MODULE_FORMAT,
      null,
      "Initial");
}
origin: org.chtijbug.drools/guvnor-repository

/**
 * Adds a module to the repository.
 *
 * @param name        what to name the node added
 * @param description what description to use for the node
 * @param format      module format.
 * @return a ModuleItem, encapsulating the created node
 * @throws RulesRepositoryException
 */
public ModuleItem createModule(String name,
                 String description,
                 String format) throws RulesRepositoryException {
  return createModule(name,
      description,
      format,
      null,
      "Initial");
}
origin: org.chtijbug.drools/guvnor-repository

/**
 * Adds a module to the repository.
 *
 * @param name        what to name the node added
 * @param description what description to use for the node
 * @return a ModuleItem, encapsulating the created node
 * @throws RulesRepositoryException
 */
public ModuleItem createModule(String name,
                 String description) throws RulesRepositoryException {
  //TODO: As we are moving towards a generic repository, create a module that is default to drools_package format
  //may not be correct.
  return createModule(name,
      description,
      ModuleItem.MODULE_FORMAT,
      null,
      "Initial");
}
origin: org.drools/guvnor-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);
  }
}
origin: org.chtijbug.drools/guvnor-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);
  }
}
origin: org.chtijbug.drools/guvnor-repository

/**
 * @return an Iterator which will provide RulePackageItem's. This will show
 *         aLL the modules, only returning latest versions, by default.
 */
public ModuleIterator listModules() {
  Node folderNode = this.getAreaNode(MODULE_AREA);
  try {
    synchronized (RulesRepository.class) {
      if (!folderNode.hasNode(DEFAULT_PACKAGE)) {
        createModule(DEFAULT_PACKAGE,
            "The default rule package");
        folderNode = this.getAreaNode(MODULE_AREA);
      }
    }
    return new ModuleIterator(this,
        folderNode.getNodes());
  } catch (RepositoryException e) {
    throw new RulesRepositoryException(e);
  }
}
origin: org.chtijbug.drools/guvnor-repository

@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());
  }
}
origin: org.chtijbug.drools/guvnor-repository

@Test
public void testListPackages() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem item = repo.createModule( "testListPackages1", "lalalala" );
  assertNotNull(item.getCreator());
  item.updateStringProperty( "goo", "whee" );
  assertEquals("goo", item.getStringProperty( "whee" ));
  assertFalse(item.getCreator().equals( "" ));
  List list = iteratorToList( repo.listModules() );
  int prevSize = list.size();
  repo.createModule( "testListPackages2", "abc" );
  list = iteratorToList( repo.listModules() );
  assertEquals(prevSize + 1, list.size());
}
origin: org.chtijbug.drools/guvnor-repository

@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.");
}
origin: org.chtijbug.drools/guvnor-repository

@Test
public void testAddAssetTrailingWhitespace() {
  ModuleItem pkg = getRepo().createModule("testAddAssetTrailingWhitespace","desc");
  pkg.addAsset("wee ", "");
  assertNotNull(pkg.loadAsset("wee"));
}
origin: org.chtijbug.drools/guvnor-repository

@Test
public void testToString() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testToStringPackage", "desc");
  AssetItem ruleItem1 = rulePackageItem1.addAsset("testToStringPackage", "test lhs content" );
  ruleItem1.updateContent( "test lhs content" );
  assertNotNull(rulePackageItem1.toString());
}
origin: org.chtijbug.drools/guvnor-webapp-core

@Test
public void testGetWithSpaces() throws Exception {
  RulesRepository repo = RepositorySessionUtil.getRepository();
  ModuleItem pkg = repo.createModule("testRestGetSpaces", "", ModuleItem.MODULE_FORMAT);
  AssetItem ass = pkg.addAsset("some space", "");
  ass.updateFormat("drl");
  ass.checkin("hey");
  RestAPI api = new RestAPI(repo);
  api.setAssetValidator(new AssetValidator());
  String url = "packages/testRestGetSpaces";
  Response res = api.get(url);
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  res.writeData(out);
  assertTrue(new String(out.toByteArray()).indexOf("\\ ") > -1);
  url = "packages/testRestGetSpaces/some space.drl";
  res = api.get(url);
  assertNotNull(res.lastModified);
}
origin: org.chtijbug.drools/guvnor-repository

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

origin: org.chtijbug.drools/guvnor-repository

@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_);
}
origin: org.chtijbug.drools/guvnor-repository

@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());
}
origin: org.chtijbug.drools/guvnor-repository

@Test
public void testGetFormatAndUpToDate() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testGetFormat",
      "woot");
  assertNotNull(rulePackageItem1);
  assertEquals(ModuleItem.MODULE_FORMAT, rulePackageItem1.getFormat());
  assertFalse(rulePackageItem1.isBinaryUpToDate());
  rulePackageItem1.updateBinaryUpToDate(true);
  assertTrue(rulePackageItem1.isBinaryUpToDate());
  rulePackageItem1.updateBinaryUpToDate(false);
  assertFalse(rulePackageItem1.isBinaryUpToDate());
}
origin: org.chtijbug.drools/guvnor-repository

@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());
}
origin: org.chtijbug.drools/guvnor-repository

@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());
  }
}
origin: org.chtijbug.drools/guvnor-repository

@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());
  }
}
origin: org.chtijbug.drools/guvnor-repository

@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());
}
org.drools.repositoryRulesRepositorycreateModule

Javadoc

Adds a module to the repository.

Popular methods of RulesRepository

  • loadModule
    Loads a Module for the specified module name and version. Will throw an exception if the specified m
  • save
    Save any pending changes.
  • <init>
    This requires a JCR session be setup, and the repository be configured.
  • findAssetsByCategory
    This will retrieve a list of RuleItem objects - that are allocated to the provided category. Only th
  • findAssetsByName
    This will search assets, looking for matches against the name.
  • findAssetsByState
    Finds the AssetItem's linked to the requested state. Similar to finding by category.
  • getAreaNode
  • getSession
  • getState
    Gets a StateItem for the specified state name. If a node for the specified state does not yet exist,
  • listModuleSnapshots
    Return a list of the snapshots available for the given module name.
  • listModules
  • loadAssetByUUID
    Loads an asset by its UUID (generally the fastest way to load something).
  • listModules,
  • loadAssetByUUID,
  • loadCategory,
  • loadGlobalArea,
  • loadModuleByUUID,
  • loadModuleSnapshot,
  • loadState,
  • addNodeIfNew,
  • checkForDataMigration

Popular in Java

  • Updating database using SQL prepared statement
  • requestLocationUpdates (LocationManager)
  • setRequestProperty (URLConnection)
    Sets the general request property. If a property with the key already exists, overwrite its value wi
  • onCreateOptionsMenu (Activity)
  • Collection (java.util)
    Collection is the root of the collection hierarchy. It defines operations on data collections and t
  • Collections (java.util)
    This class consists exclusively of static methods that operate on or return collections. It contains
  • NoSuchElementException (java.util)
    Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
  • StringTokenizer (java.util)
    The string tokenizer class allows an application to break a string into tokens. The tokenization met
  • ConcurrentHashMap (java.util.concurrent)
    A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updat
  • AtomicInteger (java.util.concurrent.atomic)
    An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now