cmsresourcefilter.java

一个cms内容管理平台

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