* Copyright 2005 JBoss Inc

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* This is the implementation of the repository service to drive the GWT based

* front end.

* Generally requests for this are passed through from RepositoryServiceServlet - and Seam manages instances of this.

*

* @author Michael Neale

*/

    implements

    RepositoryService {

    /**

     * Maximum number of rules to display in "list rules in package" method

     */

    private static final int            MAX_RULES_TO_SHOW_IN_PACKAGE_LIST = 5000;

    @In

    public RulesRepository              repository;

    private static final long           serialVersionUID                  = 510l;

    private static final DateFormat     dateFormatter                     = DateFormat.getInstance();

    private static final LoggingHelper         log                               = LoggingHelper.getLogger( ServiceImplementation.class );

    private MetaDataMapper              metaDataMapper                    = new MetaDataMapper();

    /**

     * Used for a simple cache of binary packages to avoid serialization from

     * the database - for test scenarios.

     */

    public static Map<String, RuleBase> ruleBaseCache                     = Collections.synchronizedMap( new HashMap<String, RuleBase>() );

    /**

     * This is used for pushing messages back to the client.

     */

    private static Backchannel          backchannel                       = new Backchannel();

    public RulesRepository getRulesRepository() {

        return this.repository;

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public String[] loadChildCategories(String categoryPath) {

        List<String> resultList = new ArrayList<String>();

        CategoryFilter filter = new CategoryFilter();

        CategoryItem item = repository.loadCategory( categoryPath );

        List children = item.getChildTags();

        for ( int i = 0; i < children.size(); i++ ) {

            String childCategoryName = ((CategoryItem) children.get( i )).getName();

            if ( filter.acceptNavigate( categoryPath,

                                        childCategoryName ) ) {

                resultList.add( childCategoryName );

            }

        }

        String[] resultArr = resultList.toArray( new String[resultList.size()] );

        return resultArr;

    }

    @WebRemote

    public Boolean createCategory(String path,

                                  String name,

                                  String description) {

        if ( Contexts.isSessionContextActive() ) {

            Identity.instance().checkPermission( new AdminType(),

                                                 RoleTypes.ADMIN );

        }

        log.info( "USER:" + getCurrentUserName() + " CREATING cateogory: [" + name + "] in path [" + path + "]" );

        if ( path == null || "".equals( path ) ) {

            path = "/";

        }

        path = cleanHTML( path );

        CategoryItem item = repository.loadCategory( path );

        item.addCategory( name,

                          description );

        repository.save();

        return Boolean.TRUE;

    }

    /**

     * 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.

     */

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public String createNewRule(String ruleName,

                                String description,

                                String initialCategory,

                                String initialPackage,

                                String format) throws SerializationException {

        if ( Contexts.isSessionContextActive() ) {

            Identity.instance().checkPermission( new PackageNameType( initialPackage ),

                                                 RoleTypes.PACKAGE_DEVELOPER );

        }

        log.info( "USER:" + getCurrentUserName() + " CREATING new asset name [" + ruleName + "] in package [" + initialPackage + "]" );

        try {

            PackageItem pkg = repository.loadPackage( initialPackage );

            AssetItem asset = pkg.addAsset( ruleName,

                                            description,

                                            initialCategory,

                                            format );

            applyPreBuiltTemplates( ruleName,

                                    format,

                                    asset );

            repository.save();

            push( "categoryChange",

                  initialCategory );

            push( "packageChange",

                  pkg.getName() );

            return asset.getUUID();

        } catch ( RulesRepositoryException e ) {

            if ( e.getCause() instanceof ItemExistsException ) {

                return "DUPLICATE";

            } else {

                log.error( "An error occurred creating new asset" + ruleName + "] in package [" + initialPackage + "]: ",

                           e );

                throw new SerializationException( e.getMessage() );

            }

        }

    }

    /**

     * This will create a new asset which refers to an existing asset

     */

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public String createNewImportedRule(String sharedAssetName,

                                        String initialPackage) throws SerializationException {

        if ( Contexts.isSessionContextActive() ) {

            Identity.instance().checkPermission( new PackageNameType( initialPackage ),

                                                 RoleTypes.PACKAGE_DEVELOPER );

        }

        log.info( "USER:" + repository.getSession().getUserID() + " CREATING shared asset imported from global area named [" + sharedAssetName + "] in package [" + initialPackage + "]" );

        try {

            PackageItem pkg = repository.loadPackage( initialPackage );

            AssetItem asset = pkg.addAssetImportedFromGlobalArea( sharedAssetName );

            repository.save();

            return asset.getUUID();

        } catch ( RulesRepositoryException e ) {

            if ( e.getCause() instanceof ItemExistsException ) {

                return "DUPLICATE";

            } else {

                log.error( "An error occurred creating shared asset" + sharedAssetName + "] in package [" + initialPackage + "]: ",

                           e );

                throw new SerializationException( e.getMessage() );

            }

        }

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public void deleteUncheckedRule(String uuid,

                                    String initialPackage) {

        if ( Contexts.isSessionContextActive() ) {

            Identity.instance().checkPermission( new AdminType(),

                                                 RoleTypes.PACKAGE_ADMIN );

        }

        AssetItem asset = repository.loadAssetByUUID( uuid );

        String pkgName = asset.getPackageName();

        asset.remove();

        repository.save();

        push( "packageChange",

              pkgName );

    }

    /**

     * For some format types, we add some sugar by adding a new template.

     */

    private void applyPreBuiltTemplates(String ruleName,

                                        String format,

                                        AssetItem asset) {

        if ( format.equals( AssetFormats.DSL_TEMPLATE_RULE ) ) {

            asset.updateContent( "when\n\nthen\n" );

        } else if ( format.equals( AssetFormats.FUNCTION ) ) {

            asset.updateContent( "function <returnType> " + ruleName + "(<args here>) {\n\n\n}" );

        } else if ( format.equals( AssetFormats.DSL ) ) {

            asset.updateContent( "[when]Condition sentence template {var}=" + "rule language mapping {var}\n" + "[then]Action sentence template=rule language mapping" );

        } else if ( format.equals( AssetFormats.DECISION_SPREADSHEET_XLS ) ) {

            asset.updateBinaryContentAttachment( this.getClass().getResourceAsStream( "/SampleDecisionTable.xls" ) );

            asset.updateBinaryContentAttachmentFileName( "SampleDecisionTable.xls" );

        } else if ( format.equals( AssetFormats.DRL ) ) {

            asset.updateContent( "when\n\t#conditions\nthen\n\t#actions" );

        } else if ( format.equals( AssetFormats.ENUMERATION ) ) {

        }

    }

    /**

     * Role-based Authorization check: This method only returns packages that the user has

     * permission to access. User has permission to access the particular package when:

     * The user has a package.readonly role or higher (i.e., package.admin, package.developer)

     * to this package.

     */

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public PackageConfigData[] listPackages() {

        RepositoryFilter pf = new PackageFilter();

        return listPackages( false,

                             pf );

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public PackageConfigData[] listArchivedPackages() {

        RepositoryFilter pf = new PackageFilter();

        return listPackages( true,

                             pf );

    }

    public PackageConfigData loadGlobalPackage() {

        PackageConfigData data = new PackageConfigData();

        PackageItem item = repository.loadGlobalArea();

        data.uuid = item.getUUID();

        data.header = getDroolsHeader( item );

        data.externalURI = item.getExternalURI();

        data.catRules = item.getCategoryRules();

        data.description = item.getDescription();

        data.archived = item.isArchived();

        data.name = item.getName();

        data.lastModified = item.getLastModified().getTime();

        data.dateCreated = item.getCreatedDate().getTime();

        data.checkinComment = item.getCheckinComment();

        data.lasContributor = item.getLastContributor();

        data.state = item.getStateDescription();

        data.isSnapshot = item.isSnapshot();

        if ( data.isSnapshot ) {

            data.snapshotName = item.getSnapshotName();

        }

        return data;

    }

    private PackageConfigData[] listPackages(boolean archive,

                                             RepositoryFilter filter) {

        List<PackageConfigData> result = new ArrayList<PackageConfigData>();

        PackageIterator pkgs = repository.listPackages();

        pkgs.setArchivedIterator( archive );

        while ( pkgs.hasNext() ) {

            PackageItem pkg = pkgs.next();

            PackageConfigData data = new PackageConfigData();

            data.uuid = pkg.getUUID();

            data.name = pkg.getName();

            data.archived = pkg.isArchived();

            if ( !archive && (filter == null || filter.accept( data,

                                                               RoleTypes.PACKAGE_READONLY )) ) {

                result.add( data );

            } else if ( archive && data.archived && (filter == null || filter.accept( data,

                                                                                      RoleTypes.PACKAGE_READONLY )) ) {

                result.add( data );

            }

            data.subPackages = listSubPackages( pkg,

                                                archive,

                                                filter );

        }

        sortPackages( result );

        return result.toArray( new PackageConfigData[result.size()] );

    }

    private PackageConfigData[] listSubPackages(PackageItem parentPkg,

                                                boolean archive,

                                                RepositoryFilter filter) {

        List<PackageConfigData> children = new LinkedList<PackageConfigData>();

        PackageIterator pkgs = parentPkg.listSubPackages();

        pkgs.setArchivedIterator( archive );

        while ( pkgs.hasNext() ) {

            PackageItem pkg = pkgs.next();

            PackageConfigData data = new PackageConfigData();

            data.uuid = pkg.getUUID();

            data.name = pkg.getName();

            data.archived = pkg.isArchived();

            if ( !archive && (filter == null || filter.accept( data,

                                                               RoleTypes.PACKAGE_READONLY )) ) {

                children.add( data );

            } else if ( archive && data.archived && (filter == null || filter.accept( data,

                                                                                      RoleTypes.PACKAGE_READONLY )) ) {

                children.add( data );

            }

            data.subPackages = listSubPackages( pkg,

                                                archive,

                                                filter );

        }

        sortPackages( children );

        return children.toArray( new PackageConfigData[children.size()] );

    }

    void sortPackages(List<PackageConfigData> result) {

        Collections.sort( result,

                          new Comparator<PackageConfigData>() {

                              public int compare(final PackageConfigData d1,

                                                 final PackageConfigData d2) {

                                  return d1.name.compareTo( d2.name );

                              }

                          } );

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    /**

     * loadRuleListForCategories

     *

     * Role-based Authorization check: This method only returns rules that the user has

     * permission to access. The user is considered to has permission to access the particular category when:

     * The user has ANALYST_READ role or higher (i.e., ANALYST) to this category

     */

    public TableDataResult loadRuleListForCategories(String categoryPath,

                                                     int skip,

                                                     int numRows,

                                                     String tableConfig) throws SerializationException {

        // love you

        // long time = System.currentTimeMillis();

        // First check the user has permission to access this categoryPath.

        if ( Contexts.isSessionContextActive() ) {

            if ( !Identity.instance().hasPermission( new CategoryPathType( categoryPath ),

                                                     RoleTypes.ANALYST_READ ) ) {

                TableDisplayHandler handler = new TableDisplayHandler( tableConfig );

                return handler.loadRuleListTable( new AssetPageList() );

            }

        }

        AssetPageList list = repository.findAssetsByCategory( categoryPath,

                                                              false,

                                                              skip,

                                                              numRows);

        TableDisplayHandler handler = new TableDisplayHandler( tableConfig );

        // log.debug("time for load: " + (System.currentTimeMillis() - time) );

        return handler.loadRuleListTable( list );

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public TableDataResult loadRuleListForState(String stateName,

                                                int skip,

                                                int numRows,

                                                String tableConfig) throws SerializationException {

        // love you

        // long time = System.currentTimeMillis();

      //TODO: May need to use a filter that acts on both package based and category based.

        RepositoryFilter filter = new AssetItemFilter();

        AssetPageList list = repository.findAssetsByState( stateName,

                                                           false,

                                                           skip,

                                                           numRows,

                                                           filter );

        TableDisplayHandler handler = new TableDisplayHandler( tableConfig );

        // log.debug("time for load: " + (System.currentTimeMillis() - time) );

        return handler.loadRuleListTable( list );

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public TableConfig loadTableConfig(String listName) {

        TableDisplayHandler handler = new TableDisplayHandler( listName );

        return handler.loadTableConfig();

    }

    /**

     * This actually does the hard work of loading up an asset based on its

     * format.

     *

     * Role-based Authorization check: This method can be accessed if user has

     * following permissions:

     * 1. The user has a ANALYST_READ role or higher (i.e., ANALYST) and this role has permission

     * to access the category which the asset belongs to.

     * Or.

     * 2. The user has a package.readonly role or higher (i.e., package.admin, package.developer)

     * and this role has permission to access the package which the asset belongs to.

     */

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public RuleAsset loadRuleAsset(String uuid) throws SerializationException {

        long time = System.currentTimeMillis();

        AssetItem item = repository.loadAssetByUUID( uuid );

        RuleAsset asset = new RuleAsset();

        asset.uuid = uuid;

        // load standard meta data

        asset.metaData = populateMetaData( item );

        //Verify if the user has permission to access the asset through package based permission.

        //If failed, then verify if the user has permission to access the asset through category

        //based permission

        if (Contexts.isSessionContextActive()) {

      boolean passed = false;

      try {

        Identity.instance().checkPermission(

            new PackageNameType(asset.metaData.packageName),

            RoleTypes.PACKAGE_READONLY);

      } catch (RuntimeException e) {

        if (asset.metaData.categories.length == 0) {

          Identity.instance().checkPermission(

              new CategoryPathType(null), RoleTypes.ANALYST_READ);

        } else {

          RuntimeException exception = null;

          for (String cat : asset.metaData.categories) {

            try {

              Identity.instance().checkPermission(

                  new CategoryPathType(cat),

                  RoleTypes.ANALYST_READ);

              passed = true;

            } catch (RuntimeException re) {

              exception = re;

            }

          }

          if (!passed) {

            throw exception;

          }

        }

      }

    }

        // get package header

        //      PackageItem pkgItem = repository

        //              .loadPackage(asset.metaData.packageName);

        PackageItem pkgItem = item.getPackage();

        // load the content

        ContentHandler handler = ContentManager.getHandler( asset.metaData.format );

        handler.retrieveAssetContent( asset,

                                      pkgItem,

                                      item );

       

        asset.isreadonly = asset.metaData.hasSucceedingVersion;

        if ( pkgItem.isSnapshot() ) {

            asset.isreadonly = true;

        }

        log.debug( "Package: " + pkgItem.getName() + ", asset: " + item.getName() + ". Load time taken for asset: " + (System.currentTimeMillis() - time) );

        UserInbox.recordOpeningEvent( item );

        return asset;

    }

    @WebRemote

    @Restrict("#{identity.loggedIn}")

    public RuleAsset[] loadRuleAssets(String[] uuids) throws SerializationException {

        return loadRuleAssets( Arrays.asList( uuids ) );

    }

    RuleAsset[] loadRuleAssets(Collection<String> uuids) throws SerializationException {

        if ( uuids == null ) {

            return null;

        }

        Collection<RuleAsset> assets = new HashSet<RuleAsset>();

        for ( String uuid : uuids ) {

            assets.add( loadRuleAsset( uuid ) );