001: /*
002: * File : $Source: /usr/local/cvs/opencms/src/org/opencms/file/CmsResourceFilter.java,v $
003: * Date : $Date: 2008-02-27 12:05:38 $
004: * Version: $Revision: 1.28 $
005: *
006: * This library is part of OpenCms -
007: * the Open Source Content Management System
008: *
009: * Copyright (c) 2002 - 2008 Alkacon Software GmbH (http://www.alkacon.com)
010: *
011: * This library is free software; you can redistribute it and/or
012: * modify it under the terms of the GNU Lesser General Public
013: * License as published by the Free Software Foundation; either
014: * version 2.1 of the License, or (at your option) any later version.
015: *
016: * This library is distributed in the hope that it will be useful,
017: * but WITHOUT ANY WARRANTY; without even the implied warranty of
018: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
019: * Lesser General Public License for more details.
020: *
021: * For further information about Alkacon Software GmbH, please see the
022: * company website: http://www.alkacon.com
023: *
024: * For further information about OpenCms, please see the
025: * project website: http://www.opencms.org
026: *
027: * You should have received a copy of the GNU Lesser General Public
028: * License along with this library; if not, write to the Free Software
029: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
030: */
031:
032: package org.opencms.file;
033:
034: import org.opencms.db.CmsResourceState;
035:
036: /**
037: * Provides filters for resource result sets obtained from requests to the OpenCms VFS.<p>
038: *
039: * Using the constant filters provided by this class
040: * you can control "special" behaviour
041: * of access to the VFS. For example, in the "Offline" project
042: * there can be deleted files, by using this filter you can control
043: * if deleted files should be included in a result set or not.<p>
044: *
045: * @author Michael Emmerich
046: * @author Alexander Kandzior
047: * @author Carsten Weinholz
048: * @author Jan Baudisch
049: *
050: * @version $Revision: 1.28 $
051: *
052: * @since 6.0.0
053: */
054: public final class CmsResourceFilter {
055:
056: /**
057: * Filter to display all resources.<p>
058: *
059: * This filter uses the following rules:
060: * <ul>
061: * <li>Includes: Resources marked as deleted.</li>
062: * <li>Includes: Resources outside the 'time window' set with release and expiration date.</li>
063: * <li>Includes: Resources marked as 'invisible' using permissions.</li>
064: * </ul>
065: */
066: public static final CmsResourceFilter ALL = new CmsResourceFilter();
067:
068: /**
069: * Filter to display all modified (new/changed/deleted) resources.<p>
070: */
071: public static final CmsResourceFilter ALL_MODIFIED = ALL
072: .addExcludeState(CmsResource.STATE_UNCHANGED);
073:
074: /**
075: * Default filter to display resources for the online project.<p>
076: *
077: * This filter uses the following rules:
078: * <ul>
079: * <li>Excludes: Resources marked as deleted.</li>
080: * <li>Excludes: Resources outside the 'time window' set with release and expiration date.</li>
081: * <li>Includes: Resources marked as 'invisible' using permissions.</li>
082: * </ul>
083: */
084: public static final CmsResourceFilter DEFAULT = ALL
085: .addExcludeState(CmsResource.STATE_DELETED)
086: .addRequireTimerange();
087:
088: /**
089: * Default filter to display files for the online project.<p>
090: */
091: public static final CmsResourceFilter DEFAULT_FILES = DEFAULT
092: .addRequireFile();
093:
094: /**
095: * Default filter to display folders for the online project.<p>
096: */
097: public static final CmsResourceFilter DEFAULT_FOLDERS = DEFAULT
098: .addRequireFolder();
099:
100: /**
101: * Filter to display resources ignoring the release and expiration dates.<p>
102: *
103: * This filter uses the following rules:
104: * <ul>
105: * <li>Excludes: Resources marked as deleted.</li>
106: * <li>Includes: Resources outside the 'time window' set with release and expiration date.</li>
107: * <li>Includes: Resources marked as 'invisible' using permissions.</li>
108: * </ul>
109: */
110: public static final CmsResourceFilter IGNORE_EXPIRATION = ALL
111: .addExcludeState(CmsResource.STATE_DELETED);
112:
113: /**
114: * Filter to display only visible resources.<p>
115: *
116: * This filter used the following rules:
117: * <ul>
118: * <li>Includes: Resources marked as deleted.</li>
119: * <li>Includes: Resources outside the 'time window' set with release and expiration date.</li>
120: * <li>Excludes: Resources marked as 'invisible' using permissions.</li>
121: * </ul>
122: */
123: public static final CmsResourceFilter ONLY_VISIBLE = ALL
124: .addRequireVisible();
125:
126: /**
127: * Filter to display only visible and not deleted resources.<p>
128: *
129: * This filter used the following rules:
130: * <ul>
131: * <li>Excludes: Resources marked as deleted.</li>
132: * <li>Includes: Resources outside the 'time window' set with release and expiration date.</li>
133: * <li>Excludes: Resources marked as 'invisible' using permissions.</li>
134: * </ul>
135: */
136: public static final CmsResourceFilter ONLY_VISIBLE_NO_DELETED = ONLY_VISIBLE
137: .addExcludeState(CmsResource.STATE_DELETED);
138:
139: private static final int EXCLUDED = 2;
140:
141: private static final int IGNORED = 0;
142:
143: private static final int REQUIRED = 1;
144:
145: /** The cache id for this filter. */
146: private String m_cacheId;
147:
148: /** The required start date for the timerange of the expire date. */
149: private long m_expireAfter;
150:
151: /** The required end data for the timerange of the expire date. */
152: private long m_expireBefore;
153:
154: /** Indicates if the expire date is used (true) or ignored (false). */
155: private boolean m_filterExpire;
156:
157: /** Indicates if the resource flag is filtered (true) or not (false). */
158: private int m_filterFlags;
159:
160: /** Indicates if the date of the last modification is used (true) or ignored (false). */
161: private boolean m_filterLastModified;
162:
163: /** Indicates if the release date is used (true) or ignored (false). */
164: private boolean m_filterRelease;
165:
166: /** Indicates if the resource state (unchanged/new/deleted/modified) is filtered (true) or not (false). */
167: private int m_filterState;
168:
169: /** Indicates if the resource valid timerage is used (true) or ignored (false). */
170: private boolean m_filterTimerange;
171:
172: /** Indicates if the resource type is filtered (true) or not (false). */
173: private int m_filterType;
174:
175: /** Indicates if the visible permission is used (true) or ignored (false). */
176: private boolean m_filterVisible;
177:
178: /** The required/excluded flags for filtering resources. */
179: private int m_flags;
180:
181: /** The required start date for the timerange of the last modification date. */
182: private long m_modifiedAfter;
183:
184: /** The required end data for the timerange of the last modification date. */
185: private long m_modifiedBefore;
186:
187: /** Indicates if the filter should return only folders. */
188: private Boolean m_onlyFolders;
189:
190: /** The required start date for the timerange of the release date. */
191: private long m_releaseAfter;
192:
193: /** The required end data for the timerange of the release date. */
194: private long m_releaseBefore;
195:
196: /** The required/excluded state for filtering resources. */
197: private CmsResourceState m_state;
198:
199: /** The required/excluded type for filtering resources. */
200: private int m_type;
201:
202: /**
203: * Hides the public contructor.<p>
204: */
205: private CmsResourceFilter() {
206:
207: m_filterState = IGNORED;
208: m_state = null;
209:
210: m_filterType = IGNORED;
211: m_type = -1;
212:
213: m_filterFlags = IGNORED;
214: m_flags = -1;
215:
216: m_filterVisible = false;
217:
218: m_filterTimerange = false;
219: m_filterLastModified = false;
220: m_filterRelease = false;
221: m_filterExpire = false;
222: m_modifiedAfter = 0L;
223: m_modifiedBefore = 0L;
224: m_releaseAfter = 0L;
225: m_releaseBefore = 0L;
226: m_expireAfter = 0L;
227: m_expireBefore = 0L;
228:
229: updateCacheId();
230: }
231:
232: /**
233: * Returns a new CmsResourceFilter requiring the given type.<p>
234: *
235: * @param type the required resource type
236: * @return a filter requiring the given type
237: */
238: public static CmsResourceFilter requireType(int type) {
239:
240: return new CmsResourceFilter().addRequireType(type);
241: }
242:
243: /**
244: * Returns an extended filter in order to avoid the given flags in the filtered resources.<p>
245: *
246: * @param flags the resource flags to exclude
247: * @return a filter excluding the given resource flags
248: */
249: public CmsResourceFilter addExcludeFlags(int flags) {
250:
251: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
252:
253: extendedFilter.m_flags = flags;
254: extendedFilter.m_filterFlags = EXCLUDED;
255: extendedFilter.updateCacheId();
256:
257: return extendedFilter;
258: }
259:
260: /**
261: * Returns an extended filter in order to avoid the given type in the filtered resources.<p>
262: *
263: * @param state the resource state to exclude
264: * @return a filter excluding the given resource state
265: */
266: public CmsResourceFilter addExcludeState(CmsResourceState state) {
267:
268: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
269:
270: extendedFilter.m_state = state;
271: extendedFilter.m_filterState = EXCLUDED;
272: extendedFilter.updateCacheId();
273:
274: return extendedFilter;
275: }
276:
277: /**
278: * Returns an extended filter to guarantee all filtered resources ignoring the time range (released and not expired) window.<p>
279: *
280: * This is the reverse of {@link #addRequireTimerange()}.<p>
281: *
282: * @return a filter excluding invalid resources
283: */
284: public CmsResourceFilter addExcludeTimerange() {
285:
286: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
287:
288: extendedFilter.m_filterTimerange = false;
289: extendedFilter.updateCacheId();
290:
291: return extendedFilter;
292: }
293:
294: /**
295: * Returns an extended filter in order to avoid the given type in the filtered resources.<p>
296: *
297: * @param type the resource type to exclude
298: * @return a filter excluding the given resource type
299: */
300: public CmsResourceFilter addExcludeType(int type) {
301:
302: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
303:
304: extendedFilter.m_type = type;
305: extendedFilter.m_filterType = EXCLUDED;
306: extendedFilter.updateCacheId();
307:
308: return extendedFilter;
309: }
310:
311: /**
312: * Returns an extended filter to restrict the results to resources that expire in the given timerange.<p>
313: *
314: * @param time the required time
315: * @return a filter to restrict the results to resources that expire in the given timerange
316: */
317: public CmsResourceFilter addRequireExpireAfter(long time) {
318:
319: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
320:
321: extendedFilter.m_filterExpire = true;
322: extendedFilter.m_expireAfter = time;
323: extendedFilter.updateCacheId();
324:
325: return extendedFilter;
326: }
327:
328: /**
329: * Returns an extended filter to restrict the results to resources that expire in the given timerange.<p>
330: *
331: * @param time the required time
332: * @return a filter to restrict the results to resources that expire in the given timerange
333: */
334: public CmsResourceFilter addRequireExpireBefore(long time) {
335:
336: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
337:
338: extendedFilter.m_filterExpire = true;
339: extendedFilter.m_expireBefore = time;
340: extendedFilter.updateCacheId();
341:
342: return extendedFilter;
343: }
344:
345: /**
346: * Returns an extended filter that requires all returned resources to be files.<p>
347: *
348: * @return an extended filter that requires all returned resources to be files
349: */
350: public CmsResourceFilter addRequireFile() {
351:
352: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
353:
354: extendedFilter.m_onlyFolders = Boolean.FALSE;
355: extendedFilter.updateCacheId();
356:
357: return extendedFilter;
358: }
359:
360: /**
361: * Returns an extended filter to guarantee a distinct resource flags of the filtered resources.<p>
362: *
363: * @param flags the required resource flags
364: * @return a filter requiring the given resource flags
365: */
366: public CmsResourceFilter addRequireFlags(int flags) {
367:
368: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
369:
370: extendedFilter.m_flags = flags;
371: extendedFilter.m_filterFlags = REQUIRED;
372: extendedFilter.updateCacheId();
373:
374: return extendedFilter;
375: }
376:
377: /**
378: * Returns an extended filter that requires all returned resources to be folders.<p>
379: *
380: * @return an extended filter that requires all returned resources to be folders
381: */
382: public CmsResourceFilter addRequireFolder() {
383:
384: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
385:
386: extendedFilter.m_onlyFolders = Boolean.TRUE;
387: extendedFilter.updateCacheId();
388:
389: return extendedFilter;
390: }
391:
392: /**
393: * Returns an extended filter to restrict the results to resources modified in the given timerange.<p>
394: *
395: * @param time the required time
396: * @return a filter to restrict the results to resources modified in the given timerange
397: */
398: public CmsResourceFilter addRequireLastModifiedAfter(long time) {
399:
400: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
401:
402: extendedFilter.m_filterLastModified = true;
403: extendedFilter.m_modifiedAfter = time;
404: extendedFilter.updateCacheId();
405:
406: return extendedFilter;
407: }
408:
409: /**
410: * Returns an extended filter to restrict the results to resources modified in the given timerange.<p>
411: *
412: * @param time the required time
413: * @return a filter to restrict the results to resources modified in the given timerange
414: */
415: public CmsResourceFilter addRequireLastModifiedBefore(long time) {
416:
417: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
418:
419: extendedFilter.m_filterLastModified = true;
420: extendedFilter.m_modifiedBefore = time;
421: extendedFilter.updateCacheId();
422:
423: return extendedFilter;
424: }
425:
426: /**
427: * Returns an extended filter to restrict the results to resources that are released in the given timerange.<p>
428: *
429: * @param time the required time
430: * @return a filter to restrict the results to resources that are released in the given timerange
431: */
432: public CmsResourceFilter addRequireReleaseAfter(long time) {
433:
434: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
435:
436: extendedFilter.m_filterRelease = true;
437: extendedFilter.m_releaseAfter = time;
438: extendedFilter.updateCacheId();
439:
440: return extendedFilter;
441: }
442:
443: /**
444: * Returns an extended filter to restrict the results to resources that are released in the given timerange.<p>
445: *
446: * @param time the required time
447: * @return a filter to restrict the results to resources that are released in the given timerange
448: */
449: public CmsResourceFilter addRequireReleaseBefore(long time) {
450:
451: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
452:
453: extendedFilter.m_filterRelease = true;
454: extendedFilter.m_releaseBefore = time;
455: extendedFilter.updateCacheId();
456:
457: return extendedFilter;
458: }
459:
460: /**
461: * Returns an extended filter to guarantee a distinct resource state of the filtered resources.<p>
462: *
463: * @param state the required resource state
464: * @return a filter requiring the given resource state
465: */
466: public CmsResourceFilter addRequireState(CmsResourceState state) {
467:
468: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
469:
470: extendedFilter.m_state = state;
471: extendedFilter.m_filterState = REQUIRED;
472: extendedFilter.updateCacheId();
473:
474: return extendedFilter;
475: }
476:
477: /**
478: * Returns an extended filter to guarantee all filtered resources are valid (released and not expired).<p>
479: *
480: * @return a filter excluding invalid resources
481: */
482: public CmsResourceFilter addRequireTimerange() {
483:
484: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
485:
486: extendedFilter.m_filterTimerange = true;
487: extendedFilter.updateCacheId();
488:
489: return extendedFilter;
490: }
491:
492: /**
493: * Returns an extended filter to guarantee a distinct resource type of the filtered resources.<p>
494: *
495: * @param type the required resource type
496: * @return a filter requiring the given resource type
497: */
498: public CmsResourceFilter addRequireType(int type) {
499:
500: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
501:
502: extendedFilter.m_type = type;
503: extendedFilter.m_filterType = REQUIRED;
504: extendedFilter.updateCacheId();
505:
506: return extendedFilter;
507: }
508:
509: /**
510: * Returns an extended filter to guarantee all filtered resources are visible.<p>
511: *
512: * @return a filter excluding invisible resources
513: */
514: public CmsResourceFilter addRequireVisible() {
515:
516: CmsResourceFilter extendedFilter = (CmsResourceFilter) clone();
517:
518: extendedFilter.m_filterVisible = true;
519: extendedFilter.updateCacheId();
520:
521: return extendedFilter;
522: }
523:
524: /**
525: * @see java.lang.Object#clone()
526: */
527: public Object clone() {
528:
529: CmsResourceFilter filter = new CmsResourceFilter();
530:
531: filter.m_cacheId = m_cacheId;
532: filter.m_expireAfter = m_expireAfter;
533: filter.m_expireBefore = m_expireBefore;
534: filter.m_filterExpire = m_filterExpire;
535: filter.m_filterFlags = m_filterFlags;
536: filter.m_filterLastModified = m_filterLastModified;
537: filter.m_filterRelease = m_filterRelease;
538: filter.m_filterState = m_filterState;
539: filter.m_filterTimerange = m_filterTimerange;
540: filter.m_filterType = m_filterType;
541: filter.m_filterVisible = m_filterVisible;
542: filter.m_flags = m_flags;
543: filter.m_modifiedAfter = m_modifiedAfter;
544: filter.m_modifiedBefore = m_modifiedBefore;
545: filter.m_onlyFolders = m_onlyFolders;
546: filter.m_releaseAfter = m_releaseAfter;
547: filter.m_releaseBefore = m_releaseBefore;
548: filter.m_state = m_state;
549: filter.m_type = m_type;
550:
551: return filter;
552: }
553:
554: /**
555: * return if the stored flags should be excluded while filtering resources.<p>
556: *
557: * @return if the flags should be excluded
558: */
559: public boolean excludeFlags() {
560:
561: return m_filterFlags == EXCLUDED;
562: }
563:
564: /**
565: * return if the stored state should be excluded while filtering resources.<p>
566: *
567: * @return if the state should be excluded
568: */
569: public boolean excludeState() {
570:
571: return m_filterState == EXCLUDED;
572: }
573:
574: /**
575: * Returns if the stored type should be excluded while filtering resources.<p>
576: *
577: * @return if the type should be excluded
578: */
579: public boolean excludeType() {
580:
581: return m_filterType == EXCLUDED;
582: }
583:
584: /**
585: * Returns the unique cache id for this filter.<p>
586: *
587: * @return the unique cache id for this filter
588: */
589: public String getCacheId() {
590:
591: return m_cacheId;
592: }
593:
594: /**
595: * Returns the start of the expire time range for this filter.<p>
596: *
597: * @return start of the expire time range for this filter
598: */
599: public long getExpireAfter() {
600:
601: return m_expireAfter;
602: }
603:
604: /**
605: * Returns the end of the expire time range for this filter.<p>
606: *
607: * @return the end of the expire time range for this filter
608: */
609: public long getExpireBefore() {
610:
611: return m_expireBefore;
612: }
613:
614: /**
615: * Returns the flags for this filter.<p>
616: *
617: * @return the flags for this filter
618: */
619: public int getFlags() {
620:
621: return m_flags;
622: }
623:
624: /**
625: * Returns the start of the modification time range for this filter.<p>
626: *
627: * @return start of the modification time range for this filter
628: */
629: public long getModifiedAfter() {
630:
631: return m_modifiedAfter;
632: }
633:
634: /**
635: * Returns the end of the modification time range for this filter.<p>
636: *
637: * @return the end of the modification time range for this filter
638: */
639: public long getModifiedBefore() {
640:
641: return m_modifiedBefore;
642: }
643:
644: /**
645: * Returns the state of the "only folders" flag.<p>
646: *
647: * If the result is <code>null</code>, then this flag is not set.<p>
648: *
649: * @return the state of the "only folders" flag
650: */
651: public Boolean getOnlyFolders() {
652:
653: return m_onlyFolders;
654: }
655:
656: /**
657: * Returns the start of the release time range for this filter.<p>
658: *
659: * @return start of the release time range for this filter
660: */
661: public long getReleaseAfter() {
662:
663: return m_releaseAfter;
664: }
665:
666: /**
667: * Returns the end of the release time range for this filter.<p>
668: *
669: * @return the end of the release time range for this filter
670: */
671: public long getReleaseBefore() {
672:
673: return m_releaseBefore;
674: }
675:
676: /**
677: * Returns the state for this filter.<p>
678: *
679: * @return the state for this filter
680: */
681: public CmsResourceState getState() {
682:
683: return m_state;
684: }
685:
686: /**
687: * Returns the type for this filter.<p>
688: *
689: * @return the type for this filter
690: */
691: public int getType() {
692:
693: return m_type;
694: }
695:
696: /**
697: * Check if deleted resources should be filtered.<p>
698: *
699: * @return true if deleted resources should be included, false otherwise
700: */
701: public boolean includeDeleted() {
702:
703: return (m_filterState == IGNORED)
704: || ((m_filterState == REQUIRED) && m_state.isDeleted())
705: || ((m_filterState == EXCLUDED) && !m_state.isDeleted());
706: }
707:
708: /**
709: * Validates if a CmsResource fits to all filer settings.<p>
710: *
711: * Please note that the "visible permission" setting of the filter is NOT checked
712: * in this method since the permission information is not part of the resource.
713: * The visible permission information in the filter will be used in the permission
714: * checks
715: *
716: * @param context the current request context
717: * @param resource the resource to be validated
718: * @return true if the resource passes all validations, false otherwise
719: */
720: public boolean isValid(CmsRequestContext context,
721: CmsResource resource) {
722:
723: if (this == ALL) {
724: // shortcut for "ALL" filter where nothing is filtered
725: return true;
726: }
727:
728: // check for required resource state
729: switch (m_filterState) {
730: case EXCLUDED:
731: if (resource.getState().equals(m_state)) {
732: return false;
733: }
734: break;
735: case REQUIRED:
736: if (!resource.getState().equals(m_state)) {
737: return false;
738: }
739: break;
740: default:
741: // ignored
742: }
743:
744: // check for required resource state
745: switch (m_filterFlags) {
746: case EXCLUDED:
747: if ((resource.getFlags() & m_flags) != 0) {
748: return false;
749: }
750: break;
751: case REQUIRED:
752: if ((resource.getFlags() & m_flags) != m_flags) {
753: return false;
754: }
755: break;
756: default:
757: // ignored
758: }
759:
760: // check for required resource type
761: switch (m_filterType) {
762: case EXCLUDED:
763: if (resource.getTypeId() == m_type) {
764: return false;
765: }
766: break;
767: case REQUIRED:
768: if (resource.getTypeId() != m_type) {
769: return false;
770: }
771: break;
772: default:
773: // ignored
774: }
775:
776: if (m_onlyFolders != null) {
777: if (m_onlyFolders.booleanValue()) {
778: if (!resource.isFolder()) {
779: // only folder resource are allowed
780: return false;
781: }
782: } else {
783: if (resource.isFolder()) {
784: // no folder resources are allowed
785: return false;
786: }
787: }
788: }
789:
790: // check if the resource was last modified within the given time range
791: if (m_filterLastModified) {
792: if ((m_modifiedAfter > 0L)
793: && (resource.getDateLastModified() < m_modifiedAfter)) {
794: return false;
795: }
796: if ((m_modifiedBefore > 0L)
797: && (resource.getDateLastModified() > m_modifiedBefore)) {
798: return false;
799: }
800: }
801:
802: // check if the resource expires within the given time range
803: if (m_filterExpire) {
804: if ((m_expireAfter > 0L)
805: && (resource.getDateExpired() < m_expireAfter)) {
806: return false;
807: }
808: if ((m_expireBefore > 0L)
809: && (resource.getDateExpired() > m_expireBefore)) {
810: return false;
811: }
812: }
813:
814: // check if the resource is released within the given time range
815: if (m_filterRelease) {
816: if ((m_releaseAfter > 0L)
817: && (resource.getDateReleased() < m_releaseAfter)) {
818: return false;
819: }
820: if ((m_releaseBefore > 0L)
821: && (resource.getDateReleased() > m_releaseBefore)) {
822: return false;
823: }
824: }
825:
826: // check if the resource is currently released and not expired
827: if (m_filterTimerange
828: && !resource.isReleasedAndNotExpired(context
829: .getRequestTime())) {
830: return false;
831: }
832:
833: // everything is ok, so return true
834: return true;
835: }
836:
837: /**
838: * Returns if the stored flags is required while filtering resources.<p>
839: *
840: * @return if the flags is required
841: */
842: public boolean requireFlags() {
843:
844: return m_filterFlags == REQUIRED;
845: }
846:
847: /**
848: * Returns if the stored state is required while filtering resources.<p>
849: *
850: * @return if the state is required
851: */
852: public boolean requireState() {
853:
854: return m_filterState == REQUIRED;
855: }
856:
857: /**
858: * Returns if the release timerange of the resource should be required.<p>
859: *
860: * @return true if the release timerange of the resource should be required
861: */
862: public boolean requireTimerange() {
863:
864: return m_filterTimerange;
865: }
866:
867: /**
868: * Returns if the stored type is required while filtering resources.<p>
869: *
870: * @return true if the type is required
871: */
872: public boolean requireType() {
873:
874: return m_filterType == REQUIRED;
875: }
876:
877: /**
878: * Returns if the visible permission should be required for resources.<p>
879: *
880: * @return true if the visible permission is required, false if the visible permission is ignored
881: */
882: public boolean requireVisible() {
883:
884: return m_filterVisible;
885: }
886:
887: /**
888: * Returns the name of the filter, if it is one of the filters used as a constant of this class and
889: * a default message otherwise.<p>
890: *
891: * @return the name of the filter
892: */
893: public String toString() {
894:
895: if (this .equals(CmsResourceFilter.ALL)) {
896: return "ALL";
897: } else if (this .equals(CmsResourceFilter.ALL_MODIFIED)) {
898: return "ALL_MODIFIED";
899: } else if (this .equals(CmsResourceFilter.DEFAULT)) {
900: return "DEFAULT";
901: } else if (this .equals(CmsResourceFilter.DEFAULT_FILES)) {
902: return "DEFAULT_FILES";
903: } else if (this .equals(CmsResourceFilter.DEFAULT_FOLDERS)) {
904: return "DEFAULT_FOLDERS";
905: } else if (this .equals(CmsResourceFilter.IGNORE_EXPIRATION)) {
906: return "IGNORE_EXPIRATION";
907: } else if (this .equals(CmsResourceFilter.ONLY_VISIBLE)) {
908: return "ONLY_VISIBLE";
909: } else if (this
910: .equals(CmsResourceFilter.ONLY_VISIBLE_NO_DELETED)) {
911: return "ONLY_VISIBLE_NO_DELETED";
912: } else {
913: return "Nonstandard Resource Filter";
914: }
915: }
916:
917: /**
918: * Recalculates the cache id.<p>
919: */
920: private void updateCacheId() {
921:
922: StringBuffer result = new StringBuffer(32);
923: if (m_filterVisible) {
924: result.append(" Vi");
925: }
926: if (m_filterTimerange) {
927: result.append(" Ti");
928: }
929: switch (m_filterState) {
930: case REQUIRED:
931: result.append(" Sr");
932: result.append(m_state);
933: break;
934: case EXCLUDED:
935: result.append(" Sx");
936: result.append(m_state);
937: break;
938: default:
939: // ignored
940: }
941: switch (m_filterFlags) {
942: case REQUIRED:
943: result.append(" Fr");
944: result.append(m_flags);
945: break;
946: case EXCLUDED:
947: result.append(" Fx");
948: result.append(m_flags);
949: break;
950: default:
951: // ignored
952: }
953: switch (m_filterType) {
954: case REQUIRED:
955: result.append(" Tr");
956: result.append(m_type);
957: break;
958: case EXCLUDED:
959: result.append(" Tx");
960: result.append(m_type);
961: break;
962: default:
963: // ignored
964: }
965: if (m_onlyFolders != null) {
966: if (m_onlyFolders.booleanValue()) {
967: result.append(" Fo");
968: } else {
969: result.append(" Fi");
970: }
971: }
972: if (m_filterLastModified) {
973: result.append(" Lt");
974: result.append(m_modifiedAfter);
975: result.append("-");
976: result.append(m_modifiedBefore);
977: }
978: if (m_filterExpire) {
979: result.append(" Ex");
980: result.append(m_expireAfter);
981: result.append("-");
982: result.append(m_expireBefore);
983: }
984: if (m_filterRelease) {
985: result.append(" Re");
986: result.append(m_releaseAfter);
987: result.append("-");
988: result.append(m_releaseBefore);
989: }
990: m_cacheId = result.toString();
991: }
992: }
|