/**
   * This will create a new asset. It will be saved, but not checked in. The initial state will be
   * the draft state. Returns the UUID of the asset.
   */
  public String createNewRule(
      NewAssetWithContentConfiguration<? extends PortableObject> configuration)
      throws SerializationException {

    final String assetName = configuration.getAssetName();
    final String description = configuration.getDescription();
    final String initialCategory = configuration.getInitialCategory();
    final String packageName = configuration.getPackageName();
    final String format = configuration.getFormat();
    final PortableObject content = configuration.getContent();

    log.info(
        "USER:"******" CREATING new asset name ["
            + assetName
            + "] in package ["
            + packageName
            + "]");

    try {

      // Create new Asset
      ModuleItem pkg = rulesRepository.loadModule(packageName);
      AssetItem assetItem = pkg.addAsset(assetName, description, initialCategory, format);

      // Set the Assets content - no need to use AssetTemplateCreator().applyPreBuiltTemplates() as
      // we are provided a model
      // Use a transient Asset object so we can use ContentHandler to convert between model and
      // persisted format correctly.
      Asset asset = new AssetPopulator().populateFrom(assetItem);
      ContentHandler handler = ContentManager.getHandler(assetItem.getFormat());
      asset.setContent(content);
      handler.storeAssetContent(asset, assetItem);

      rulesRepository.save();

      push("categoryChange", initialCategory);
      push("packageChange", pkg.getName());

      return assetItem.getUUID();

    } catch (RulesRepositoryException e) {
      // If we want to display an explicit error message of "duplicate asset", we can achieve this
      // in client error handler.
      /*            if ( e.getCause() instanceof ItemExistsException ) {
          return "DUPLICATE";
      }*/
      log.error(
          "An error occurred creating new asset ["
              + assetName
              + "] in package ["
              + packageName
              + "]: ",
          e);
      throw new SerializationException(e.getMessage());
    }
  }
 // The Asset is being effectively added to the target package so treat as though the Content is
 // being added
 private void attachmentAdded(AssetItem item) {
   ICanHasAttachment attachmentHandler = null;
   ContentHandler contentHandler = ContentManager.getHandler(item.getFormat());
   if (contentHandler instanceof ICanHasAttachment) {
     attachmentHandler = (ICanHasAttachment) contentHandler;
     try {
       attachmentHandler.onAttachmentAdded(item);
     } catch (IOException ioe) {
       log.error("Unable to remove asset attachment", ioe);
     }
   }
 }
  private ModuleItem handlePackageItem(AssetItem item, Asset asset) throws SerializationException {
    ModuleItem packageItem = item.getModule();

    ContentHandler handler = ContentManager.getHandler(asset.getFormat());
    handler.retrieveAssetContent(asset, item);

    asset.setReadonly(asset.getMetaData().isHasSucceedingVersion() || asset.isArchived());

    if (packageItem.isSnapshot()) {
      asset.setReadonly(true);
    }
    return packageItem;
  }
示例#4
0
  /** Builds assets that are "rule" assets (ie things that are not functions etc). */
  protected void buildAsset(AssetItem asset) {
    ContentHandler contentHandler = ContentManager.getHandler(asset.getFormat());

    if (contentHandler instanceof ICompilable && !asset.getDisabled()) {
      try {
        compile(asset, (ICompilable) contentHandler);
      } catch (DroolsParserException e) {
        errorLogger.addError(asset, e.getMessage());
        throw new RulesRepositoryException(e);
      } catch (IOException e) {
        errorLogger.addError(asset, e.getMessage());
      }
    }
  }
  private PackageItem handlePackageItem(AssetItem item, RuleAsset asset)
      throws SerializationException {
    PackageItem pkgItem = item.getPackage();

    ContentHandler handler = ContentManager.getHandler(asset.metaData.format);
    handler.retrieveAssetContent(asset, pkgItem, item);

    asset.isreadonly = asset.metaData.hasSucceedingVersion;

    if (pkgItem.isSnapshot()) {
      asset.isreadonly = true;
    }
    return pkgItem;
  }
  private void addRuleAssetToVerifier() {

    ContentHandler handler = ContentManager.getHandler(ruleAsset.getFormat());

    if (!(handler instanceof IRuleAsset)) {
      throw new IllegalStateException("IRuleAsset Expected");
    }

    RuleModel model = (RuleModel) ruleAsset.getContent();

    String brl = BRXMLPersistence.getInstance().marshal(model);

    verifier.addResourcesToVerify(
        ResourceFactory.newByteArrayResource(brl.getBytes()), ResourceType.BRL);
  }
示例#7
0
  private void addDRLRulesToVerifier() {

    AssetItemIterator rules = packageItem.listAssetsByFormat(AssetFormats.DRL);

    while (rules.hasNext()) {
      AssetItem rule = rules.next();

      ContentHandler contentHandler = ContentManager.getHandler(rule.getFormat());
      if (contentHandler.isRuleAsset()) {
        IRuleAsset ruleAsset = (IRuleAsset) contentHandler;
        String drl = ruleAsset.getRawDRL(rule);
        verifier.addResourcesToVerify(
            ResourceFactory.newReaderResource(new StringReader(drl)), ResourceType.DRL);
      }
    }
  }
 /** Builds assets that are "rule" assets (ie things that are not functions etc). */
 private void buildAsset(AssetItem asset) {
   ContentHandler h = ContentManager.getHandler(asset.getFormat());
   if (h instanceof IRuleAsset) {
     try {
       ((IRuleAsset) h).compile(builder, asset, new ErrorLogger());
       if (builder.hasErrors()) {
         this.recordBuilderErrors(asset);
         // clear the errors, so we don't double report.
         builder.clearErrors();
       }
     } catch (DroolsParserException e) {
       throw new RulesRepositoryException(e);
     } catch (IOException e) {
       throw new RulesRepositoryException(e);
     }
   }
 }
  public String getDRL() {
    StringBuffer src = new StringBuffer();
    src.append("package " + this.pkg.getName() + "\n");
    src.append(ServiceImplementation.getDroolsHeader(this.pkg) + "\n\n");

    // now we load up the DSL files
    builder.setDSLFiles(
        BRMSPackageBuilder.getDSLMappingFiles(
            pkg,
            new BRMSPackageBuilder.DSLErrorEvent() {
              public void recordError(AssetItem asset, String message) {
                errors.add(new ContentAssemblyError(asset, message));
              }
            }));

    // do the functions and declared types.
    AssetItemIterator it =
        this.pkg.listAssetsByFormat(new String[] {AssetFormats.FUNCTION, AssetFormats.DRL_MODEL});
    while (it.hasNext()) {
      AssetItem func = (AssetItem) it.next();
      if (!func.isArchived()) {
        src.append(func.getContent() + "\n\n");
      }
    }

    // now the rules
    Iterator iter = pkg.getAssets();
    while (iter.hasNext()) {
      AssetItem asset = (AssetItem) iter.next();
      if (!asset.isArchived()) {

        ContentHandler h = ContentManager.getHandler(asset.getFormat());
        if (h instanceof IRuleAsset) {
          IRuleAsset ruleAsset = (IRuleAsset) h;
          ruleAsset.assembleDRL(builder, asset, src);
        }

        src.append("\n\n");
      }
    }

    return src.toString();
  }
 private ContentHandler getContentHandler(AssetItem repoAsset) {
   return ContentManager.getHandler(repoAsset.getFormat());
 }