KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jahia > engines > updatefield > UpdateField_Engine


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 // EV 10.01.20001
14
15 package org.jahia.engines.updatefield;
16
17 import java.util.ArrayList JavaDoc;
18 import java.util.Enumeration JavaDoc;
19 import java.util.HashMap JavaDoc;
20 import java.util.HashSet JavaDoc;
21 import java.util.Iterator JavaDoc;
22 import java.util.Locale JavaDoc;
23 import java.util.Set JavaDoc;
24 import java.util.Vector JavaDoc;
25
26 import javax.servlet.http.HttpSession JavaDoc;
27
28 import org.jahia.content.ContentFieldXRefManager;
29 import org.jahia.data.JahiaData;
30 import org.jahia.data.events.JahiaEvent;
31 import org.jahia.data.fields.JahiaContentFieldFacade;
32 import org.jahia.data.fields.JahiaField;
33 import org.jahia.data.fields.LoadFlags;
34 import org.jahia.engines.EngineToolBox;
35 import org.jahia.engines.JahiaEngine;
36 import org.jahia.engines.lock.LockEngine;
37 import org.jahia.engines.rights.ManageRights;
38 import org.jahia.engines.shared.Page_Field;
39 import org.jahia.exceptions.JahiaException;
40 import org.jahia.exceptions.JahiaForbiddenAccessException;
41 import org.jahia.exceptions.JahiaSessionExpirationException;
42 import org.jahia.params.ParamBean;
43 import org.jahia.registries.ServicesRegistry;
44 import org.jahia.services.fields.ContentField;
45 import org.jahia.services.lock.LockKey;
46 import org.jahia.services.lock.LockService;
47 import org.jahia.services.sites.SiteLanguageSettings;
48 import org.jahia.services.usermanager.JahiaUser;
49 import org.jahia.services.version.ContentObjectEntryState;
50 import org.jahia.services.version.EntryLoadRequest;
51 import org.jahia.services.version.EntrySaveRequest;
52 import org.jahia.services.cache.HtmlCache;
53 import org.jahia.services.cache.CacheFactory;
54 import org.jahia.utils.JahiaObjectTool;
55 import org.jahia.utils.LanguageCodeConverters;
56
57 public class UpdateField_Engine implements JahiaEngine {
58
59     /** logging */
60     private static final org.apache.log4j.Logger logger =
61             org.apache.log4j.Logger.getLogger (UpdateField_Engine.class);
62
63     /** unique instance of this class */
64     private static UpdateField_Engine instance = null;
65
66     private static final String JavaDoc TEMPLATE_JSP = "update_field";
67     public static final String JavaDoc ENGINE_NAME = "updatefield";
68     private EngineToolBox toolBox;
69
70     /**
71      * Default constructor, creates a new <code>UpdateField_Engine</code> instance.
72      */
73     private UpdateField_Engine () {
74         logger.debug ("***** Starting "+UpdateField_Engine.class.getName() +" engine *****");
75         toolBox = EngineToolBox.getInstance ();
76     }
77
78     /**
79      * Returns the unique instance of this class
80      *
81      * @return the unique instance of this class
82      */
83     public static UpdateField_Engine getInstance () {
84         if (instance == null) {
85             instance = new UpdateField_Engine ();
86         }
87         return instance;
88     }
89
90     /**
91      * authoriseRender AK 19.12.2000
92      */
93     public boolean authoriseRender (ParamBean jParams) {
94         return toolBox.authoriseRender (jParams);
95     } // end authoriseRender
96
97     /**
98      * renderLink AK 19.12.2000 AK 04.01.2001 add the select parameter MJ 21.03.2001
99      * mode is now the first URL parameter
100      */
101     public String JavaDoc renderLink (ParamBean jParams, Object JavaDoc theObj)
102             throws JahiaException {
103         ContentField contentField = (ContentField) theObj;
104         String JavaDoc params = "?mode=display&fid=" + contentField.getID ();
105         return jParams.composeEngineUrl (ENGINE_NAME, params);
106     } // end renderLink
107
108     /**
109      * needsJahiaData AK 19.12.2000
110      */
111     public boolean needsJahiaData (ParamBean jParams) {
112         return false;
113     } // end needsJahiaData
114
115     /**
116      * handles the engine actions
117      *
118      * @param jParams a ParamBean object
119      * @param jData a JahiaData object (not mandatory)
120      */
121     public void handleActions (ParamBean jParams, JahiaData jData)
122             throws JahiaException,
123             JahiaSessionExpirationException,
124             JahiaForbiddenAccessException {
125         // initalizes the hashmap
126 HashMap JavaDoc engineMap = initEngineMap (jParams);
127
128         // checks if the user has the right to display the engine
129 JahiaField theField = (JahiaField) engineMap.get ("theField");
130         JahiaUser theUser = jParams.getUser ();
131         if (theField.checkAdminAccess (theUser)) {
132             engineMap.put ("adminAccess", Boolean.TRUE);
133             engineMap.put ("enableRightView", Boolean.TRUE);
134             engineMap.put ("writeAccess", Boolean.TRUE);
135         } else if (theField.checkWriteAccess (theUser)) {
136             engineMap.put ("writeAccess", Boolean.TRUE);
137         }
138
139         if (engineMap.get ("writeAccess") != null) {
140
141             // #ifdef LOCK
142 LockService lockRegistry = ServicesRegistry.getInstance ().
143                     getLockService ();
144             if (jParams.settings ().areLocksActivated ()) {
145                 LockKey lockKey = LockKey.composeLockKey (LockKey.
146                         UPDATE_FIELD_TYPE,
147                         theField.getID (), theField.getPageID ());
148                 if (lockRegistry.acquire (lockKey, jParams.getUser (),
149                         jParams.getSessionID (),
150                         jParams.getSession ().
151                         getMaxInactiveInterval ())) {
152                     // #endif
153 flushPageCacheThatDisplayField (jParams, theField);
154
155                     processLastScreen (jParams, engineMap);
156                     processCurrentScreen (jParams, engineMap);
157
158                     // #ifdef LOCK
159 } else {
160
161                     // Prerequisites are NOT completed ! Damned ! Redirect the JSP
162 // output to lock informations.
163 LockEngine.getInstance ().redirect (jParams, engineMap,
164                             lockKey);
165                 }
166             }
167             // #endif
168
169         } else {
170             throw new JahiaForbiddenAccessException ();
171         }
172
173         // displays the screen
174 toolBox.displayScreen (jParams, engineMap);
175
176     } // end handleActions
177
178     /**
179      * Retrieve the engine name.
180      *
181      * @return the engine name.
182      */
183     public final String JavaDoc getName () {
184         return ENGINE_NAME;
185     }
186
187     /**
188      * processes the last screen sent by the user
189      *
190      * @param jParams a ParamBean object
191      */
192     public void processLastScreen (ParamBean jParams, HashMap JavaDoc engineMap)
193             throws JahiaException,
194             JahiaForbiddenAccessException {
195         logger.debug ("started");
196
197         JahiaContentFieldFacade jahiaContentFieldFacade
198                 = (JahiaContentFieldFacade) engineMap.get ("jahiaContentFieldFacade");
199
200         EntryLoadRequest prevEntryLoadRequest
201                 = (EntryLoadRequest) engineMap.get ("prevEntryLoadRequest");
202
203         JahiaField theField = jahiaContentFieldFacade.getField (
204                 prevEntryLoadRequest, true);
205
206         // handle undefined field
207 int initialFieldType = theField.getType ();
208
209         engineMap.put (JahiaEngine.PROCESSING_LANGUAGECODE,
210                 engineMap.get ("prevLanguageCode"));
211         engineMap.put ("theField", theField);
212
213         // gets the last screen
214 // lastscreen = edit, rights, logs
215 String JavaDoc lastScreen = jParams.getRequest ().getParameter ("lastscreen");
216         if (lastScreen == null) {
217             //lastScreen = "edit";
218 lastScreen = EMPTY_STRING;
219         }
220
221         logger.debug ("lastscreen=" + lastScreen);
222
223         // indicates to sub engines that we are processing last screen
224 int mode = JahiaEngine.UPDATE_MODE;
225
226         // dispatches to the appropriate sub engine
227 if (lastScreen.equals ("edit")) {
228             if (!toolBox.processFieldTypes (jParams, mode, engineMap)) {
229                 // if there was an error, come back to last screen
230 engineMap.put ("screen", lastScreen);
231                 engineMap.put ("jspSource", TEMPLATE_JSP);
232             } else {
233                 if (jParams.getRequest ().getParameter (
234                         "apply_change_to_all_lang_" + theField.getID ()) != null) {
235                     applyChangeToAllLang (theField, jahiaContentFieldFacade,
236                             engineMap, jParams);
237                 }
238             }
239         } else if (lastScreen.equals ("rightsMgmt")) {
240             if (engineMap.get ("adminAccess") != null) {
241                 ManageRights.getInstance ().handleActions (jParams, mode,
242                         engineMap, theField.getAclID ());
243             } else {
244                 throw new JahiaForbiddenAccessException ();
245             }
246         } else if (lastScreen.equals ("logs")) {
247             if (engineMap.get ("adminAccess") != null) {
248                 // ManageLogs_Engine.getInstance().handleActions( jParams, null );
249 } else {
250                 throw new JahiaForbiddenAccessException ();
251             }
252         } else if (lastScreen.equals ("versioning")) {
253             if (engineMap.get ("adminAccess") != null) {
254
255                 /**
256                  * @todo forward to versioning URL
257                  *
258                  */
259
260                 /**
261                  VersioningEngine.getInstance()
262                  .handleAction( jParams, mode, engineMap, JahiaObjectTool.FIELD_TYPE, theField );
263                  */
264             } else {
265                 throw new JahiaForbiddenAccessException ();
266             }
267         }
268         theField = (JahiaField) engineMap.get ("theField");
269         if (initialFieldType != theField.getType ()) {
270             // init the JahiaContentFieldFacade
271 ArrayList JavaDoc localeList = new ArrayList JavaDoc ();
272             Vector JavaDoc siteLanguageSettings = jParams.getSite ().getLanguageSettings ();
273             if (siteLanguageSettings != null) {
274                 for (int i = 0; i < siteLanguageSettings.size (); i++) {
275                     SiteLanguageSettings curSetting = (SiteLanguageSettings)
276                             siteLanguageSettings.elementAt (i);
277                     if (curSetting.isActivated ()) {
278                         Locale JavaDoc tempLocale = LanguageCodeConverters.
279                                 languageCodeToLocale (curSetting.
280                                 getCode ());
281                         localeList.add (tempLocale);
282                     }
283                 }
284             }
285
286             jahiaContentFieldFacade =
287                     new JahiaContentFieldFacade (theField.getID (),
288                             theField.getJahiaID (),
289                             theField.getPageID (),
290                             theField.getctnid (),
291                             theField.getFieldDefID (),
292                             theField.getType (),
293                             theField.getConnectType (),
294                             theField.getValue (),
295                             theField.getAclID (),
296                             jParams,
297                             localeList);
298
299             engineMap.put ("jahiaContentFieldFacade", jahiaContentFieldFacade);
300
301         }
302     } // end processLastScreen
303
304     /**
305      * prepares the screen requested by the user
306      *
307      * @param jParams a ParamBean object
308      */
309     public void processCurrentScreen (ParamBean jParams, HashMap JavaDoc engineMap)
310             throws JahiaException,
311             JahiaForbiddenAccessException {
312         logger.debug ("started");
313
314         JahiaContentFieldFacade jahiaContentFieldFacade
315                 = (JahiaContentFieldFacade) engineMap.get ("jahiaContentFieldFacade");
316
317         EntryLoadRequest entryLoadRequest
318                 = (EntryLoadRequest) engineMap.get ("entryLoadRequest");
319
320         engineMap.put (JahiaEngine.PROCESSING_LANGUAGECODE,
321                 engineMap.get ("languageCode"));
322
323         JahiaField theField = jahiaContentFieldFacade.getField (entryLoadRequest, true);
324         engineMap.put ("theField", theField);
325
326         // gets the current screen
327 // screen = edit, rights, logs
328 String JavaDoc theScreen = (String JavaDoc) engineMap.get ("screen");
329         //JahiaField theField = (JahiaField) engineMap.get( "theField" );
330
331         logger.debug ("screen=" + theScreen);
332
333         HashSet JavaDoc updatedLanguageEntries = (HashSet JavaDoc) engineMap.get (
334                 "updatedLanguageEntries");
335         HashSet JavaDoc updatedFields = (HashSet JavaDoc) engineMap.get ("updated.fields");
336
337         // indicates to sub engines that we are processing last screen
338 int mode = JahiaEngine.LOAD_MODE;
339
340         // #ifdef LOCK
341 LockKey lockKey = LockKey.composeLockKey (LockKey.UPDATE_FIELD_TYPE,
342                 theField.getID (),
343                 theField.getPageID ());
344         LockService lockRegistry = ServicesRegistry.getInstance ().
345                 getLockService ();
346         // #endif
347
348         // dispatches to the appropriate sub engine
349 if (theScreen.equals ("edit")) {
350             if (toolBox.processFieldTypes (jParams, mode, engineMap)) {
351                 if (jParams.getRequest ().getParameter (
352                         "apply_change_to_all_lang_" + theField.getID ()) != null) {
353                     applyChangeToAllLang (theField, jahiaContentFieldFacade,
354                             engineMap, jParams);
355                 }
356             }
357         } else if (theScreen.equals ("logs")) {
358             toolBox.loadLogData (jParams, JahiaObjectTool.FIELD_TYPE, engineMap);
359         } else if (theScreen.equals ("rightsMgmt")) {
360             if (engineMap.get ("adminAccess") != null) {
361                 ManageRights.getInstance ().handleActions (jParams, mode,
362                         engineMap, theField.getAclID ());
363             } else {
364                 throw new JahiaForbiddenAccessException ();
365             }
366         } else if (theScreen.equals ("versioning")) {
367             if (engineMap.get ("adminAccess") != null) {
368                 /**
369                  VersioningEngine.getInstance()
370                  .handleAction( jParams, mode,engineMap, JahiaObjectTool.FIELD_TYPE, theField );
371                  */
372                 /**
373                  * Todo forward to Versioning engine
374                  */
375             } else {
376                 throw new JahiaForbiddenAccessException ();
377             }
378         } else if (theScreen.equals ("save") || theScreen.equals ("apply")) {
379
380             // #ifdef LOCK
381 // Did somebody steal the lock ? Panpan cucul !
382 if (jParams.settings ().areLocksActivated () &&
383                     lockRegistry.isStealedInContext (lockKey, jParams.getUser (),
384                             jParams.getSessionID ())) {
385                 engineMap.put ("screen",
386                         jParams.getRequest ().getParameter ("lastscreen"));
387                 engineMap.put ("jspSource", "apply");
388                 return;
389             }
390             // #endif
391
392             mode = JahiaEngine.SAVE_MODE;
393
394             // handle field type change
395 if (theField.getID () > 0) {
396                 ContentField contentField = ContentField.getField (theField.
397                         getID ());
398                 if (theField.getType () != contentField.getType ()) {
399                     EntrySaveRequest entrySaveRequest = new EntrySaveRequest (
400                             jParams.getUser (), theField.getLanguageCode ());
401                     contentField = contentField.changeType (theField.getType (),
402                             theField.getValue (), jParams, entrySaveRequest);
403                 }
404             }
405
406             Enumeration JavaDoc fields = jahiaContentFieldFacade.getFields ();
407             while (fields.hasMoreElements ()) {
408                 JahiaField field = (JahiaField) fields.nextElement ();
409                 if (field.hasChanged () &&
410                         (field.getLanguageCode ().equals (ContentField.
411                         SHARED_LANGUAGE)
412                         || updatedLanguageEntries.contains (field.getLanguageCode ()))
413                         || updatedFields.contains (new Integer JavaDoc (field.getID ()))) {
414
415                     // save the active entry only if the staging doesn't exists.
416 boolean processField = true;
417                     if (field.getWorkflowState () ==
418                             ContentObjectEntryState.WORKFLOW_STATE_ACTIVE) {
419                         ArrayList JavaDoc entryLocales = new ArrayList JavaDoc ();
420                         entryLocales.add (LanguageCodeConverters
421                                 .languageCodeToLocale (field.
422                                 getLanguageCode ()));
423                         EntryLoadRequest stagingLoadRequest =
424                                 new EntryLoadRequest (ContentObjectEntryState.
425                                 WORKFLOW_STATE_START_STAGING,
426                                         0, entryLocales);
427
428                         processField = (jahiaContentFieldFacade.getField (
429                                 stagingLoadRequest, false) == null);
430                     }
431                     if (processField) {
432                         engineMap.put ("theField", field);
433                         toolBox.processFieldTypes (jParams, mode, engineMap);
434                     }
435                 }
436             }
437             if (engineMap.get ("adminAccess") != null) {
438                 engineMap.put ("logObjectType",
439                         Integer.toString (JahiaObjectTool.FIELD_TYPE));
440                 engineMap.put ("logObject", theField);
441                 //ViewRights.getInstance().handleActions( jParams, mode, engineMap, theField.getAclID() );
442 ManageRights.getInstance ().handleActions (jParams, mode,
443                         engineMap, theField.getAclID ());
444             }
445
446             flushPageCacheThatDisplayField (jParams, theField);
447
448             JahiaEvent theEvent = new JahiaEvent (this, jParams, theField);
449             ServicesRegistry.getInstance ().getJahiaEventService ().
450                     fireUpdateField (theEvent);
451
452             if (theScreen.equals ("apply")) {
453                 engineMap.put ("prevScreenIsApply", new Boolean JavaDoc (true));
454                 String JavaDoc lastScreen =
455                         jParams.getRequest ().getParameter ("lastscreen");
456                 engineMap.put ("screen", lastScreen);
457             }
458             // #ifdef LOCK
459 else {
460                 if (jParams.settings ().areLocksActivated ()) {
461                     lockRegistry.release (lockKey, jParams.getUser (),
462                             jParams.getSessionID ());
463                 }
464             }
465             // #endif
466
467             logger.debug ("Changes applied and saved !");
468         }
469         // #ifdef LOCK
470 else if (theScreen.equals ("cancel")) {
471             if (jParams.settings ().areLocksActivated ()) {
472                 lockRegistry.release (lockKey, jParams.getUser (),
473                         jParams.getSessionID ());
474                 flushPageCacheThatDisplayField (jParams, theField);
475             }
476         }
477         // #endif
478
479     }
480
481     private void flushPageCacheThatDisplayField (ParamBean jParams,
482                                                  JahiaField theField)
483             throws JahiaException {
484         // since we have made modifications concerning this page, let's flush
485 // the content cache for all the users and browsers as well as all
486 // pages that display this containerList...
487 Set JavaDoc fieldPageRefs = ContentFieldXRefManager.getInstance ().
488                 getAbsoluteFieldPageIDs (theField.getID ());
489
490         // Get the cache instance and invalidate the related page entries
491 HtmlCache htmlCache = CacheFactory.getHtmlCache ();
492         if (htmlCache == null)
493             logger.warn ("Could not get the HTML cache instance!!");
494
495         if (fieldPageRefs != null) {
496             Iterator JavaDoc pageRefIDs = fieldPageRefs.iterator ();
497             while (pageRefIDs.hasNext ()) {
498                 Integer JavaDoc curPageID = (Integer JavaDoc) pageRefIDs.next ();
499
500                 if (htmlCache != null)
501                     htmlCache.invalidatePageEntries (curPageID.toString (),jParams.getEntryLoadRequest().getWorkflowState());
502             }
503         } else {
504             logger.debug ("Why is cross ref list empty ?");
505         }
506
507         // since we have made modifications concerning this page, let's flush
508 // the content cache for all the users and browsers...
509 if (htmlCache != null)
510             htmlCache.invalidatePageEntries (Integer.toString (jParams.getPageID ()),jParams.getEntryLoadRequest().getWorkflowState());
511     }
512
513     /**
514      * inits the engine map
515      *
516      * @param jParams a ParamBean object (with request and response)
517      *
518      * @return a HashMap object containing all the basic values needed by an engine
519      */
520     private HashMap JavaDoc initEngineMap (ParamBean jParams)
521             throws JahiaException,
522             JahiaSessionExpirationException {
523         logger.debug ("started");
524
525         HashMap JavaDoc engineMap = new HashMap JavaDoc ();
526         JahiaField theField;
527
528         // gets session values
529 HttpSession JavaDoc theSession = jParams.getSession ();
530
531         // tries to find if this is the first screen generated by the engine
532 String JavaDoc theScreen = jParams.getRequest ().getParameter ("screen");
533         logger.debug ("theScreen=" + theScreen);
534
535         boolean prevScreenIsApply = false;
536
537         if (engineMap != null && theScreen != null) {
538             Boolean JavaDoc prevScreenIsApplyBool = (Boolean JavaDoc) engineMap.get (
539                     "prevScreenIsApply");
540             prevScreenIsApply = (prevScreenIsApplyBool != null &&
541                     prevScreenIsApplyBool.booleanValue ());
542         }
543
544         // Resolve language code
545 String JavaDoc languageCode = jParams.getRequest ().getParameter ("engine_lang");
546         if (prevScreenIsApply) {
547             languageCode = (String JavaDoc) engineMap.get ("languageCode");
548         }
549
550         if (languageCode == null) {
551             Locale JavaDoc navLocale = (Locale JavaDoc) theSession.getAttribute (ParamBean.
552                     SESSION_LOCALE);
553             languageCode = navLocale.toString ();
554         }
555         if (languageCode == null) {
556             languageCode = jParams.settings ().getDefaultLanguageCode ();
557         }
558         String JavaDoc prevLanguageCode = jParams.getRequest ().getParameter (
559                 "prev_engine_lang");
560         if (prevLanguageCode == null) {
561             prevLanguageCode = languageCode;
562         }
563
564         JahiaContentFieldFacade jahiaContentFieldFacade;
565
566         if (theScreen != null) {
567             // if no, load the field value from the session
568 engineMap = (HashMap JavaDoc) theSession.getAttribute (
569                     "jahia_session_engineMap");
570
571             ///////////////////////////////////////////////////////////////////////////////////////
572 // FIXME -Fulco-
573 //
574 // This is a quick hack, engineMap should not be null if the session didn't
575 // expired. Maybe there are other cases where the engineMap can be null, I didn't
576 // checked them at all.
577 ///////////////////////////////////////////////////////////////////////////////////////
578 if (engineMap == null) {
579                 throw new JahiaSessionExpirationException ();
580             }
581
582             if (prevScreenIsApply) {
583                 engineMap.remove ("prevScreenIsApply");
584                 int fieldID = jParams.getFieldID ();
585
586                 ArrayList JavaDoc localeList = jParams.getSite ().
587                         getLanguageSettingsAsLocales (false);
588                 jahiaContentFieldFacade
589                         = new JahiaContentFieldFacade (fieldID,
590                                 LoadFlags.ALL,
591                                 jParams,
592                                 localeList,
593                                 true);
594
595                 engineMap.put ("jahiaContentFieldFacade",
596                         jahiaContentFieldFacade);
597                 Page_Field.resetPageBeanSession (jParams);
598
599             } else {
600                 jahiaContentFieldFacade
601                         = (JahiaContentFieldFacade) engineMap.get (
602                                 "jahiaContentFieldFacade");
603             }
604         } else {
605
606             int fieldID = jParams.getFieldID ();
607             Page_Field.resetPageBeanSession (jParams);
608             ArrayList JavaDoc localeList = new ArrayList JavaDoc ();
609             Vector JavaDoc siteLanguageSettings = jParams.getSite ().getLanguageSettings ();
610             if (siteLanguageSettings != null) {
611                 for (int i = 0; i < siteLanguageSettings.size (); i++) {
612                     SiteLanguageSettings curSetting = (SiteLanguageSettings)
613                             siteLanguageSettings.elementAt (i);
614                     if (curSetting.isActivated ()) {
615                         Locale JavaDoc tempLocale = LanguageCodeConverters.
616                                 languageCodeToLocale (curSetting.
617                                 getCode ());
618                         localeList.add (tempLocale);
619                     }
620                 }
621             }
622
623             jahiaContentFieldFacade
624                     = new JahiaContentFieldFacade (fieldID,
625                             LoadFlags.ALL,
626                             jParams,
627                             localeList,
628                             true);
629
630             engineMap.put ("jahiaContentFieldFacade", jahiaContentFieldFacade);
631
632             theScreen = "edit";
633
634             // init session
635 engineMap.put ("isSelectedField", new Boolean JavaDoc (true));
636
637         }
638
639         // Multilanguage Issue -------------------------------------------------
640 ArrayList JavaDoc locales = new ArrayList JavaDoc ();
641         locales.add (LanguageCodeConverters.languageCodeToLocale (languageCode));
642         EntryLoadRequest entryLoadRequest =
643                 new EntryLoadRequest (EntryLoadRequest.STAGING_WORKFLOW_STATE,
644                         0,
645                         locales);
646         ArrayList JavaDoc prevLocales = new ArrayList JavaDoc ();
647         prevLocales.add (LanguageCodeConverters.languageCodeToLocale (
648                 prevLanguageCode));
649         EntryLoadRequest prevEntryLoadRequest =
650                 new EntryLoadRequest (EntryLoadRequest.STAGING_WORKFLOW_STATE,
651                         0,
652                         prevLocales);
653
654         engineMap.put ("entryLoadRequest", entryLoadRequest);
655         engineMap.put ("prevEntryLoadRequest", prevEntryLoadRequest);
656         engineMap.put ("languageCode", languageCode);
657         engineMap.put ("prevLanguageCode", prevLanguageCode);
658
659         // remember the requested language codes :
660 HashSet JavaDoc updatedLanguageEntries = (HashSet JavaDoc) engineMap.get (
661                 "updatedLanguageEntries");
662         if (updatedLanguageEntries == null) {
663             updatedLanguageEntries = new HashSet JavaDoc ();
664         }
665         if (!updatedLanguageEntries.contains (languageCode)) {
666             updatedLanguageEntries.add (languageCode);
667         }
668         engineMap.put ("updatedLanguageEntries", updatedLanguageEntries);
669
670         // remember the updated fields ( Apply Change to all lang options )
671 HashSet JavaDoc updatedFields = (HashSet JavaDoc) engineMap.get ("updated.fields");
672         if (updatedFields == null) {
673             updatedFields = new HashSet JavaDoc ();
674         }
675         engineMap.put ("updated.fields", updatedFields);
676
677         // MultiLanguage Issue -------------------------------------------------
678
679         theField = jahiaContentFieldFacade.getField (entryLoadRequest, true);
680         engineMap.put ("theField", theField);
681
682         engineMap.put (RENDER_TYPE_PARAM, new Integer JavaDoc (JahiaEngine.RENDERTYPE_FORWARD));
683         engineMap.put (ENGINE_NAME_PARAM, ENGINE_NAME);
684         engineMap.put (ENGINE_URL_PARAM,
685                 jParams.composeEngineUrl ("updatefield",
686                         "?fid=" + theField.getID ()));
687         engineMap.put ("updateField", "updateField");
688         theSession.setAttribute ("jahia_session_engineMap", engineMap);
689
690         // sets screen
691 engineMap.put ("screen", theScreen);
692         if (theScreen.equals ("save")) {
693             engineMap.put ("jspSource", "close");
694         } else if (theScreen.equals ("apply")) {
695             engineMap.put ("jspSource", "apply");
696         } else if (theScreen.equals ("cancel")) {
697             engineMap.put ("jspSource", "close");
698         } else {
699             engineMap.put ("jspSource", TEMPLATE_JSP);
700         }
701
702         // sets engineMap for JSPs
703 jParams.getRequest ().setAttribute ("engineTitle", "Update Field");
704         jParams.getRequest ().setAttribute ("org.jahia.engines.EngineHashMap",
705                 engineMap);
706         return engineMap;
707     }
708
709     /**
710      * @param theField
711      * @param jahiaContentFieldFacade
712      * @param engineMap
713      *
714      * @throws JahiaException
715      */
716     private void applyChangeToAllLang (JahiaField theField,
717                                        JahiaContentFieldFacade
718             jahiaContentFieldFacade,
719                                        HashMap JavaDoc engineMap, ParamBean jParams)
720             throws JahiaException {
721
722         HashSet JavaDoc updatedFields = (HashSet JavaDoc) engineMap.get ("updated.fields");
723         Enumeration JavaDoc enumeration = jahiaContentFieldFacade.getFields ();
724         JahiaField field;
725         while (enumeration.hasMoreElements ()) {
726             field = (JahiaField) enumeration.nextElement ();
727             theField.copyValueInAnotherLanguage (field, jParams);
728
729             // remember change
730 if (!updatedFields.contains (new Integer JavaDoc (field.getID ()))) {
731                 updatedFields.add (new Integer JavaDoc (field.getID ()));
732             }
733         }
734     }
735
736 }
737
Popular Tags