* 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

*/

    /**

     * 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) {

        checkSecurityIsAdmin();

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

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

            path = "/";

        }

        path = cleanHTML( path );

        repository.loadCategory( path ).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";

            }

            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";

            }

            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 ) ) {

        }

    }

    @WebRemote

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

    public String[] listWorkspaces() {

      return repository.listWorkspaces();

    }

   

    @WebRemote

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

    public void createWorkspace(String workspace) {

      repository.createWorkspace(workspace);

    }

   

    @WebRemote

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

    public void removeWorkspace(String workspace) {

      repository.removeWorkspace(workspace);

    }

   

    /**

     * For the time being, module == package

     */

    @WebRemote

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

    public void updateWorkspace(String workspace, String[] selectedModules, String[] unselectedModules) {

      for(String moduleName : selectedModules) {

        PackageItem module = repository.loadPackage(moduleName);

        module.addWorkspace(workspace);

      }

      for(String moduleName : unselectedModules) {

        PackageItem module = repository.loadPackage(moduleName);

        module.removeWorkspace(workspace);

      }   

        repository.save();

    }

   

    /**

     * 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() {

        return listPackages( null);

    }

    @WebRemote

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

    public PackageConfigData[] listPackages(String workspace) {

        RepositoryFilter pf = new PackageFilter();

        return listPackages( false, workspace, pf );

    }

   

    @WebRemote

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

    public PackageConfigData[] listArchivedPackages() {

        return listArchivedPackages( null );

    }

   

    @WebRemote

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

    public PackageConfigData[] listArchivedPackages(String workspace) {

        RepositoryFilter pf = new PackageFilter();

        return listPackages( true, workspace, 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, String workspace, RepositoryFilter filter) {

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

        PackageIterator pkgs = repository.listPackages();

        handleIteratePackages( archive, workspace, filter, result, pkgs );

        sortPackages( result );

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

    }

    private PackageConfigData[] listSubPackages(PackageItem parentPkg, boolean archive, String workspace, RepositoryFilter filter) {

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

        PackageIterator pkgs = parentPkg.listSubPackages();

        handleIteratePackages( archive, workspace, filter, children, pkgs );

        sortPackages( children );

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

    }

    private void handleIteratePackages(boolean archive, String workspace, RepositoryFilter filter, List<PackageConfigData> result, PackageIterator pkgs) {

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

            data.workspace = pkg.getWorkspaces();

            handleIsPackagesListed( archive, workspace, filter, result, data );

            data.subPackages = listSubPackages( pkg, archive, null, filter );

        }

    }

    private void handleIsPackagesListed(boolean archive, String workspace, RepositoryFilter filter,

        List<PackageConfigData> result,

        PackageConfigData data) {

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

            && (workspace == null || isWorkspace(workspace, data.workspace)) ) {

            result.add( data );

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

            && (workspace == null || isWorkspace(workspace, data.workspace)) ) {

            result.add( data );

        }

    }

   

    private boolean isWorkspace(String workspace, String[] workspaces) {

      for(String w: workspaces) {

        if(w.equals(workspace)) {

          return true;

        }

      }     

      return false;

    }

    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 {

        // 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 AssetItemPageResult() );

            }

        }

        AssetItemPageResult result = repository.findAssetsByCategory( categoryPath, false, skip, numRows );

        TableDisplayHandler handler = new TableDisplayHandler( tableConfig );

        return handler.loadRuleListTable( result );

    }

    @WebRemote

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

    public TableDataResult loadRuleListForState(String stateName, int skip, int numRows, String tableConfig) throws SerializationException {

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

        RepositoryFilter filter = new AssetItemFilter();

        AssetItemPageResult result = repository.findAssetsByState( stateName, false, skip, numRows, filter );

        TableDisplayHandler handler = new TableDisplayHandler( tableConfig );

        return handler.loadRuleListTable( result );

    }

    @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;

                    }

                }

            }

        }

        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;

        }

        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 ) );

        }

        return assets.toArray( new RuleAsset[assets.size()] );

    }

    private RuleAsset loadAsset(AssetItem item) throws SerializationException {

        RuleAsset asset = new RuleAsset();

        asset.uuid = item.getUUID();

        asset.metaData = populateMetaData( item );

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

        handler.retrieveAssetContent( asset, item.getPackage(), item );

        return asset;

    }

    /**

     * read in the meta data, populating all dublin core and versioning stuff.

     */

    MetaData populateMetaData(VersionableItem item) {

        MetaData meta = new MetaData();

        meta.status = (item.getState() != null) ? item.getState().getName() : "";

        metaDataMapper.copyToMetaData( meta, item );

        meta.createdDate = calendarToDate( item.getCreatedDate() );

        meta.lastModifiedDate = calendarToDate( item.getLastModified() );

        meta.hasPreceedingVersion = item.getPrecedingVersion() != null;

        meta.hasSucceedingVersion = item.getSucceedingVersion() != null;

        return meta;

    }

    /**

     * Populate meta data with asset specific info.

     */

    MetaData populateMetaData(AssetItem item) {

        MetaData meta = populateMetaData( (VersionableItem) item );

        meta.packageName = item.getPackageName();

        meta.packageUUID = item.getPackage().getUUID();

        meta.setBinary( item.isBinary() );

        List categories = item.getCategories();

        fillMetaCategories( meta, categories );

        meta.dateEffective = calendarToDate( item.getDateEffective() );

        meta.dateExpired = calendarToDate( item.getDateExpired() );

        return meta;