KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jahia > views > engines > versioning > pages > PagesVersioningViewHelper


1 //
2
// ____.
3
// __/\ ______| |__/\. _______
4
// __ .____| | \ | +----+ \
5
// _______| /--| | | - \ _ | : - \_________
6
// \\______: :---| : : | : | \________>
7
// |__\---\_____________:______: :____|____:_____\
8
// /_____|
9
//
10
// . . . i n j a h i a w e t r u s t . . .
11
//
12

13 package org.jahia.views.engines.versioning.pages;
14
15 import java.util.ArrayList JavaDoc;
16 import java.util.HashSet JavaDoc;
17 import java.util.Set JavaDoc;
18
19 import javax.servlet.http.HttpServletRequest JavaDoc;
20
21 import org.jahia.content.ContentObject;
22 import org.jahia.content.PageReferenceableInterface;
23 import org.jahia.data.viewhelper.sitemap.SiteMapViewHelper;
24 import org.jahia.data.viewhelper.sitemap.TreeSiteMapViewHelper;
25 import org.jahia.exceptions.JahiaException;
26 import org.jahia.exceptions.JahiaSessionExpirationException;
27 import org.jahia.registries.ServicesRegistry;
28 import org.jahia.services.pages.ContentPage;
29 import org.jahia.services.sitemap.JahiaSiteMapService;
30 import org.jahia.services.usermanager.JahiaUser;
31 import org.jahia.services.version.ContentObjectEntryState;
32 import org.jahia.services.version.ContentTreeRevisionsVisitor;
33 import org.jahia.services.version.EntryLoadRequest;
34 import org.jahia.services.version.PageRevisionsCompositor;
35 import org.jahia.services.version.RevisionEntrySet;
36 import org.jahia.services.version.RevisionsComparator;
37 import org.jahia.content.JahiaObject;
38 import java.io.Serializable JavaDoc;
39 import org.jahia.views.engines.JahiaEngineCommonData;
40
41 /**
42  *
43  * <p>Title: Helper for Pages Versioning Engine </p>
44  * <p>Description: </p>
45  * <p>Copyright: Copyright (c) 2002</p>
46  * <p>Company: </p>
47  * @author Khue Nguyen
48  * @version 1.0
49  */

50 public class PagesVersioningViewHelper implements Serializable JavaDoc {
51
52     private static org.apache.log4j.Logger logger =
53             org.apache.log4j.Logger.getLogger(PagesVersioningViewHelper.class);
54
55     private static final String JavaDoc CLASS_NAME =
56             PagesVersioningViewHelper.class.getName();
57
58     public static final int UNDO_STAGING_OPERATION = 1;
59     public static final int RESTORE_ARCHIVE_CONTENT_OPERATION = 2;
60     public static final int RESTORE_DELETED_PAGES = 3;
61
62     /** The operation type **/
63     private int operationType = RESTORE_ARCHIVE_CONTENT_OPERATION;
64
65     /** The selected page **/
66     private ContentPage page;
67
68     /** The selected revisionEntrySet **/
69     private RevisionEntrySet revisionEntrySet;
70
71     /** lower revision date limit **/
72     private long fromRevisionDate;
73
74     /** upper revision date limit **/
75     private long toRevisionDate;
76
77     /** the site map display Date **/
78     private long siteMapDisplayDate;
79
80     /** nb max of revisions to display **/
81     private int nbMaxOfRevisions = -1;
82
83     /** Exact restore **/
84     private boolean exactRestore = true;
85
86     private boolean applyPageMoveWhenRestore = false;
87
88     /** the type of revisions **/
89     private int typeOfRevisions =
90             PageRevisionsCompositor.CURRENT_PAGE_MODIFICATION_REVISIONS;
91
92     /** the page level **/
93     private int pageLevel = 1;
94
95     private int sortOrder = RevisionsComparator.DESC_ORDER;
96
97     private int sortAttribute = RevisionsComparator.SORT_BY_DATE;
98
99     // Site map selected pages
100
private Set JavaDoc selectedPages = new HashSet JavaDoc();
101
102     // Selected pages to restore
103
private ArrayList JavaDoc pagesToRestore = new ArrayList JavaDoc();
104
105     /** The site Map View Helper **/
106     private SiteMapViewHelper siteMapViewHelper;
107
108     /** The Revisions Handler **/
109     private ContentTreeRevisionsVisitor contentTreeRevisionsVisitor;
110
111     /**
112      *
113      * @param request
114      * @param engineCommonData
115      * @throws JahiaException
116      */

117     public PagesVersioningViewHelper(){
118     }
119
120     /**
121      *
122      * @param page
123      * @throws JahiaException
124      */

125     public PagesVersioningViewHelper(ContentPage page)
126     throws JahiaException {
127         this.page = page;
128     }
129
130     public ContentPage getPage(){
131         return this.page;
132     }
133
134     /**
135      * Return the internal ContentTreeRevisionsVisitor,
136      * Create it if not exist
137      * @return
138      */

139     public ContentTreeRevisionsVisitor getContentTreeRevisionsVisitor(
140             JahiaUser user, EntryLoadRequest loadRequest, String JavaDoc operationMode){
141
142         if ( this.contentTreeRevisionsVisitor == null ){
143             this.contentTreeRevisionsVisitor =
144                 new PageRevisionsCompositor(getPage(),
145                 user,loadRequest,operationMode);
146         } else {
147             this.contentTreeRevisionsVisitor.setUser(user);
148             this.contentTreeRevisionsVisitor.setEntryLoadRequest(loadRequest);
149             this.contentTreeRevisionsVisitor.setOperationMode(operationMode);
150         }
151         return this.contentTreeRevisionsVisitor;
152     }
153
154     /**
155      * Return the content tree revisions visitor, can be null if not created !
156      * @return
157      */

158     public ContentTreeRevisionsVisitor getContentTreeRevisionsVisitor(){
159         return this.contentTreeRevisionsVisitor;
160     }
161
162     public int getOperationType(){
163         return this.operationType;
164     }
165
166     public void setOperationType(int type){
167         this.operationType = type;
168     }
169
170     public void setRevisionEntrySet(RevisionEntrySet revisionEntrySet){
171         this.revisionEntrySet = revisionEntrySet;
172     }
173
174     public RevisionEntrySet getRevisionEntrySet(){
175         return this.revisionEntrySet;
176     }
177
178     public void setFromRevisionDate(long date){
179         this.fromRevisionDate = date;
180     }
181
182     public Long JavaDoc getFromRevisionDate(){
183         return new Long JavaDoc(this.fromRevisionDate);
184     }
185
186     public Long JavaDoc getToRevisionDate(){
187         return new Long JavaDoc(this.toRevisionDate);
188     }
189
190     public void setToRevisionDate(long date){
191         this.toRevisionDate = date;
192     }
193
194     public Long JavaDoc getSiteMapDisplayDate(){
195         return new Long JavaDoc(this.siteMapDisplayDate);
196     }
197
198     public void setSiteMapDisplayDate(long date){
199         this.siteMapDisplayDate = date;
200     }
201
202     public Integer JavaDoc getNbMaxOfRevisions(){
203         return new Integer JavaDoc(this.nbMaxOfRevisions);
204     }
205
206     public String JavaDoc getNbMaxOfRevisionsAsStr(){
207         return String.valueOf(this.nbMaxOfRevisions);
208     }
209
210     public void setNbMaxOfRevisions(int value){
211         this.nbMaxOfRevisions = value;
212     }
213
214     public boolean exactRestore(){
215         return this.exactRestore;
216     }
217
218     public void setExactRestore(boolean value){
219         this.exactRestore = value;
220     }
221
222     public boolean applyPageMoveWhenRestore(){
223         return this.applyPageMoveWhenRestore;
224     }
225
226     public void setApplyPageMoveWhenRestore(boolean value){
227         this.applyPageMoveWhenRestore = value;
228     }
229
230     public Integer JavaDoc getTypeOfRevisions(){
231         return new Integer JavaDoc(this.typeOfRevisions);
232     }
233
234     public String JavaDoc getTypeOfRevisionsAsStr(){
235         return String.valueOf(this.typeOfRevisions);
236     }
237
238     public void setTypeOfRevisions(int value){
239         this.typeOfRevisions = value;
240     }
241
242     public Integer JavaDoc getPageLevel(){
243         return new Integer JavaDoc(this.pageLevel);
244     }
245
246     public String JavaDoc getPageLevelAsStr(){
247         return String.valueOf(this.pageLevel);
248     }
249
250     public void setPageLevel(int value){
251         this.pageLevel = value;
252     }
253
254     /**
255      * Sitemap selected pages
256      *
257      * @return
258      */

259     public Set JavaDoc getSelectedPages(){
260         return this.selectedPages;
261     }
262
263     /**
264      * Pages to restore, the array contains alternatively the language to restore
265      * followed by the page to restore
266      *
267      * @return
268      */

269     public ArrayList JavaDoc getPagesToRestore(){
270         return this.pagesToRestore;
271     }
272
273     /**
274      * Set the pages to restore
275      *
276      * @return
277      */

278     public void setPagesToRestore(ArrayList JavaDoc pages){
279         this.pagesToRestore = pages;
280     }
281
282     public int getInvertSortOrder(){
283         if ( this.getSortOrder() == RevisionsComparator.ASC_ORDER ){
284             return RevisionsComparator.DESC_ORDER;
285         }
286         return RevisionsComparator.ASC_ORDER;
287     }
288
289     public int getSortOrder(){
290         return this.sortOrder;
291     }
292
293     public void setSortOrder(int value){
294         this.sortOrder = value;
295     }
296
297     public int getSortAttribute(){
298         return this.sortAttribute;
299     }
300
301     public void setSortAttribute(int value){
302         this.sortAttribute = value;
303     }
304
305     public void loadSiteMapViewHelper(JahiaUser user, HttpServletRequest JavaDoc request)
306     throws JahiaSessionExpirationException{
307
308         if ( this.getSiteMapDisplayDate().longValue() == 0 ){
309             java.util.Date JavaDoc d = new java.util.Date JavaDoc();
310             this.setSiteMapDisplayDate(d.getTime());
311         }
312
313         int restoreVersion = new Long JavaDoc(this.getSiteMapDisplayDate().longValue()/1000L).intValue();
314         int pageInfosFlag = ContentPage.STAGING_PAGE_INFOS | ContentPage.ACTIVE_PAGE_INFOS;
315         if ( this.getRevisionEntrySet() != null ){
316             restoreVersion = this.getRevisionEntrySet().getVersionID();
317         }
318
319         JahiaEngineCommonData engineCommonData = null;
320             engineCommonData = (JahiaEngineCommonData)
321                     request.getAttribute(JahiaEngineCommonData.JAHIA_ENGINE_COMMON_DATA);
322         /*
323         JahiaPageTreeBuilder jpTreeBuilder =
324             new JahiaPageTreeBuilder(getPage(),
325                                 user,
326                                 engineCommonData.getParamBean().getEntryLoadRequest(),
327                                 engineCommonData.getParamBean().getOperationMode(),
328                                 true,
329                                 cpcResolver);
330
331         JTree jTree = jpTreeBuilder.getTree();*/

332
333         JahiaSiteMapService siteMapService = ServicesRegistry.getInstance().
334                 getJahiaSiteMapService();
335
336         // @todo another way
337
//siteMapService.removeUserSiteMap(getParamBean().getUser().getUserKey());
338

339
340
341         SiteMapViewHelper siteMapViewHelper = siteMapService.
342                 getTreeSiteMapViewHelper(user, getPage(),
343                 request.getSession().getId(),
344                 ContentPage.ARCHIVED_PAGE_INFOS,
345                 null, SiteMapViewHelper.DEFAULT_LEVEL, true);
346         this.siteMapViewHelper = siteMapViewHelper;
347
348         // by default select the page of the revision
349
try {
350             if ( getRevisionEntrySet() != null ){
351                 ContentObject contentObject = (ContentObject)
352                         JahiaObject.getInstance(
353                         getRevisionEntrySet().getObjectKey());
354
355                 int pageID = -1;
356                 getSelectedPages().clear();
357                 if ( contentObject instanceof ContentPage ){
358                     getSelectedPages().add(contentObject.getObjectKey());
359                     pageID = contentObject.getObjectKey().getIdInType();
360                 } else if ( contentObject instanceof PageReferenceableInterface ){
361                     ContentPage cp = ((PageReferenceableInterface)contentObject).getPage();
362                     getSelectedPages().add(cp.getObjectKey());
363                     pageID = cp.getObjectKey().getIdInType();
364                 }
365                 // expand the sitemap up to the selected page
366
((TreeSiteMapViewHelper)getSiteMapViewHelper()).expandToPage(pageID);
367             }
368         } catch ( Throwable JavaDoc t ){
369             logger.debug("Exception when defining selected page for the sitemap :",t);
370         }
371     }
372
373     public SiteMapViewHelper getSiteMapViewHelper(){
374         return this.siteMapViewHelper;
375     }
376
377     public void setSiteMapViewHelper(SiteMapViewHelper siteMapViewHelper){
378         this.siteMapViewHelper = siteMapViewHelper;
379     }
380
381     /**
382      *
383      * @param entryState
384      * @return
385      */

386     private int getPageInfoFlag(ContentObjectEntryState entryState){
387         if ( entryState == null ){
388             return -1;
389         }
390         if ( entryState.isActive() ){
391             return ContentPage.ACTIVE_PAGE_INFOS;
392         } else if ( entryState.isStaging() ){
393             return ContentPage.STAGING_PAGE_INFOS;
394         } else {
395             return ContentPage.ARCHIVED_PAGE_INFOS;
396         }
397     }
398 }
399
400
Popular Tags