cmsresourcefilter.java

OpenCms 是一个J2EE的产品

        return extendedFilter;
    }

    /**
     * Returns an extended filter to guarantee all filtered resources are visible.<p>
     * 
     * @return a filter excluding invisible resources
     */
    public CmsResourceFilter addRequireVisible() {

        CmsResourceFilter extendedFilter = (CmsResourceFilter)clone();

        extendedFilter.m_filterVisible = true;
        extendedFilter.updateCacheId();

        return extendedFilter;
    }

    /**
     * @see java.lang.Object#clone()
     */
    public Object clone() {

        CmsResourceFilter filter = new CmsResourceFilter();

        filter.m_cacheId = m_cacheId;
        filter.m_expireAfter = m_expireAfter;
        filter.m_expireBefore = m_expireBefore;
        filter.m_filterExpire = m_filterExpire;
        filter.m_filterFlags = m_filterFlags;
        filter.m_filterLastModified = m_filterLastModified;
        filter.m_filterRelease = m_filterRelease;
        filter.m_filterState = m_filterState;
        filter.m_filterTimerange = m_filterTimerange;
        filter.m_filterType = m_filterType;
        filter.m_filterVisible = m_filterVisible;
        filter.m_flags = m_flags;
        filter.m_modifiedAfter = m_modifiedAfter;
        filter.m_modifiedBefore = m_modifiedBefore;
        filter.m_onlyFolders = m_onlyFolders;
        filter.m_releaseAfter = m_releaseAfter;
        filter.m_releaseBefore = m_releaseBefore;
        filter.m_state = m_state;
        filter.m_type = m_type;

        return filter;
    }

    /**
     * return if the stored flags should be excluded while filtering resources.<p>
     * 
     * @return if the flags should be excluded
     */
    public boolean excludeFlags() {

        return m_filterFlags == EXCLUDED;
    }

    /**
     * return if the stored state should be excluded while filtering resources.<p>
     * 
     * @return if the state should be excluded
     */
    public boolean excludeState() {

        return m_filterState == EXCLUDED;
    }

    /**
     * Returns if the stored type should be excluded while filtering resources.<p>
     * 
     * @return if the type should be excluded
     */
    public boolean excludeType() {

        return m_filterType == EXCLUDED;
    }

    /**
     * Returns the unique cache id for this filter.<p>
     * 
     * @return the unique cache id for this filter
     */
    public String getCacheId() {

        return m_cacheId;
    }

    /**
     * Returns the start of the expire time range for this filter.<p>
     * 
     * @return start of the expire time range for this filter
     */
    public long getExpireAfter() {

        return m_expireAfter;
    }

    /**
     * Returns the end of the expire time range for this filter.<p>
     * 
     * @return the end of the expire time range for this filter
     */
    public long getExpireBefore() {

        return m_expireBefore;
    }

    /**
     * Returns the flags for this filter.<p>
     * 
     * @return the flags for this filter
     */
    public int getFlags() {

        return m_flags;
    }

    /**
     * Returns the start of the modification time range for this filter.<p>
     * 
     * @return start of the modification time range for this filter
     */
    public long getModifiedAfter() {

        return m_modifiedAfter;
    }

    /**
     * Returns the end of the modification time range for this filter.<p>
     * 
     * @return the end of the modification time range for this filter
     */
    public long getModifiedBefore() {

        return m_modifiedBefore;
    }

    /**
     * Returns the state of the "only folders" flag.<p>
     * 
     * If the result is <code>null</code>, then this flag is not set.<p>
     * 
     * @return the state of the "only folders" flag
     */
    public Boolean getOnlyFolders() {

        return m_onlyFolders;
    }

    /**
     * Returns the start of the release time range for this filter.<p>
     * 
     * @return start of the release time range for this filter
     */
    public long getReleaseAfter() {

        return m_releaseAfter;
    }

    /**
     * Returns the end of the release time range for this filter.<p>
     * 
     * @return the end of the release time range for this filter
     */
    public long getReleaseBefore() {

        return m_releaseBefore;
    }

    /**
     * Returns the state for this filter.<p>
     * 
     * @return the state for this filter
     */
    public int getState() {

        return m_state;
    }

    /**
     * Returns the type for this filter.<p>
     * 
     * @return the type for this filter
     */
    public int getType() {

        return m_type;
    }

    /**
     * Check if deleted resources should be filtered.<p>
     * 
     * @return true if deleted resources should be included, false otherwiese
     */
    public boolean includeDeleted() {

        return (m_filterState == IGNORED)
            || ((m_filterState == REQUIRED) && (m_state == CmsResource.STATE_DELETED))
            || ((m_filterState == EXCLUDED) && (m_state != CmsResource.STATE_DELETED));
    }

    /**
     * Validates if a CmsResource fits to all filer settings.<p>
     * 
     * Please note that the "visible permission" setting of the filter is NOT checked
     * in this method since the permission information is not part of the resource.
     * The visible permission information in the filter will be used in the permission
     * checks 
     *
     * @param context the current request context
     * @param resource the resource to be validated
     * @return true if the resource passes all validations, false otherwise
     */
    public boolean isValid(CmsRequestContext context, CmsResource resource) {

        if (this == ALL) {
            // shortcut for "ALL" filter where nothing is filtered
            return true;
        }

        // check for required resource state
        switch (m_filterState) {
            case EXCLUDED:
                if (resource.getState() == m_state) {
                    return false;
                }
                break;
            case REQUIRED:
                if (resource.getState() != m_state) {
                    return false;
                }
                break;
            default:
        // ignored
        }

        // check for required resource state
        switch (m_filterFlags) {
            case EXCLUDED:
                if ((resource.getFlags() & m_flags) != 0) {
                    return false;
                }
                break;
            case REQUIRED:
                if ((resource.getFlags() & m_flags) != m_flags) {
                    return false;
                }
                break;
            default:
        // ignored
        }

        // check for required resource type
        switch (m_filterType) {
            case EXCLUDED:
                if (resource.getTypeId() == m_type) {
                    return false;
                }
                break;
            case REQUIRED:
                if (resource.getTypeId() != m_type) {
                    return false;
                }
                break;
            default:
        // ignored
        }

        if (m_onlyFolders != null) {
            if (m_onlyFolders.booleanValue()) {
                if (!resource.isFolder()) {
                    // only folder resource are allowed
                    return false;
                }
            } else {
                if (resource.isFolder()) {
                    // no folder resources are allowed
                    return false;
                }
            }
        }

        // check if the resource was last modified within the given time range
        if (m_filterLastModified) {
            if (m_modifiedAfter > 0L && resource.getDateLastModified() < m_modifiedAfter) {
                return false;
            }
            if (m_modifiedBefore > 0L && resource.getDateLastModified() > m_modifiedBefore) {
                return false;
            }
        }

        // check if the resource expires within the given time range
        if (m_filterExpire) {
            if (m_expireAfter > 0L && resource.getDateExpired() < m_expireAfter) {
                return false;
            }
            if (m_expireBefore > 0L && resource.getDateExpired() > m_expireBefore) {
                return false;
            }
        }

        // check if the resource is released within the given time range
        if (m_filterRelease) {
            if (m_releaseAfter > 0L && resource.getDateReleased() < m_releaseAfter) {
                return false;
            }
            if (m_releaseBefore > 0L && resource.getDateReleased() > m_releaseBefore) {
                return false;
            }
        }

        // check if the resource is currently released and not expired
        if (m_filterTimerange
            && ((resource.getDateReleased() > context.getRequestTime()) || (resource.getDateExpired() < context.getRequestTime()))) {
            return false;
        }

        // everything is ok, so return true
        return true;
    }

    /**
     * Returns if the stored flags is required while filtering resources.<p>
     * 
     * @return if the flags is required
     */
    public boolean requireFlags() {

        return m_filterFlags == REQUIRED;
    }

    /**
     * Returns if the stored state is required while filtering resources.<p>
     * 
     * @return if the state is required
     */
    public boolean requireState() {

        return m_filterState == REQUIRED;
    }

    /**
     * Returns if the release timerange of the resource should be required.<p>
     * 
     * @return true if the release timerange of the resource should be required
     */
    public boolean requireTimerange() {

        return m_filterTimerange;
    }

    /**
     * Returns if the stored type is required while filtering resources.<p>
     * 
     * @return true if the type is required
     */
    public boolean requireType() {

        return m_filterType == REQUIRED;
    }

    /**
     * Returns if the visible permission should be required for resources.<p>
     * 
     * @return true if the visible permission is required, false if the visible permission is ignored
     */
    public boolean requireVisible() {

        return m_filterVisible;
    }

    /**
     * Returns the name of the filter, if it is one of the filters used as a constant of this class and
     * a default message otherwise.<p>
     * 
     * @return the name of the filter
     */
    public String toString() {

        if (this.equals(CmsResourceFilter.ALL)) {
            return "ALL";
        } else if (this.equals(CmsResourceFilter.ALL_MODIFIED)) {
            return "ALL_MODIFIED";
        } else if (this.equals(CmsResourceFilter.DEFAULT)) {
            return "DEFAULT";
        } else if (this.equals(CmsResourceFilter.DEFAULT_FILES)) {
            return "DEFAULT_FILES";
        } else if (this.equals(CmsResourceFilter.DEFAULT_FOLDERS)) {
            return "DEFAULT_FOLDERS";
        } else if (this.equals(CmsResourceFilter.IGNORE_EXPIRATION)) {
            return "IGNORE_EXPIRATION";
        } else if (this.equals(CmsResourceFilter.ONLY_VISIBLE)) {
            return "ONLY_VISIBLE";
        } else if (this.equals(CmsResourceFilter.ONLY_VISIBLE_NO_DELETED)) {
            return "ONLY_VISIBLE_NO_DELETED";
        } else {
            return "Nonstandard Resource Filter";
        }
    }

    /**
     * Recalculates the cache id.<p>
     */
    private void updateCacheId() {

        StringBuffer result = new StringBuffer(32);
        if (m_filterVisible) {
            result.append(" Vi");
        }
        if (m_filterTimerange) {
            result.append(" Ti");
        }
        switch (m_filterState) {
            case REQUIRED:
                result.append(" Sr");
                result.append(m_state);
                break;
            case EXCLUDED:
                result.append(" Sx");
                result.append(m_state);
                break;
            default:
        // ignored
        }
        switch (m_filterFlags) {
            case REQUIRED:
                result.append(" Fr");
                result.append(m_flags);
                break;
            case EXCLUDED:
                result.append(" Fx");
                result.append(m_flags);
                break;
            default:
        // ignored
        }
        switch (m_filterType) {
            case REQUIRED:
                result.append(" Tr");
                result.append(m_type);
                break;
            case EXCLUDED:
                result.append(" Tx");
                result.append(m_type);
                break;
            default:
        // ignored
        }
        if (m_onlyFolders != null) {
            if (m_onlyFolders.booleanValue()) {
                result.append(" Fo");
            } else {
                result.append(" Fi");
            }
        }
        if (m_filterLastModified) {
            result.append(" Lt");
            result.append(m_modifiedAfter);
            result.append("-");
            result.append(m_modifiedBefore);
        }
        if (m_filterExpire) {
            result.append(" Ex");
            result.append(m_expireAfter);
            result.append("-");
            result.append(m_expireBefore);
        }
        if (m_filterRelease) {
            result.append(" Re");
            result.append(m_releaseAfter);
            result.append("-");
            result.append(m_releaseBefore);
        }
        m_cacheId = result.toString();
    }
}