KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jahia > data > containers > ContainerValidatorBase


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  *
14  * ----- BEGIN LICENSE BLOCK -----
15  * Version: JCSL 1.0
16  *
17  * The contents of this file are subject to the Jahia Community Source License
18  * 1.0 or later (the "License"); you may not use this file except in
19  * compliance with the License. You may obtain a copy of the License at
20  * http://www.jahia.org/license
21  *
22  * Software distributed under the License is distributed on an "AS IS" basis,
23  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
24  * for the rights, obligations and limitations governing use of the contents
25  * of the file. The Original and Upgraded Code is the Jahia CMS and Portal
26  * Server. The developer of the Original and Upgraded Code is JAHIA Ltd. JAHIA
27  * Ltd. owns the copyrights in the portions it created. All Rights Reserved.
28  *
29  * The Shared Modifications are Jahia View Helper.
30  *
31  * The Developer of the Shared Modifications is Jahia Solution S�rl.
32  * Portions created by the Initial Developer are Copyright (C) 2002 by the
33  * Initial Developer. All Rights Reserved.
34  *
35  * Contributor(s):
36  * 28-Feb-2005, Commaro, Benjamin Papez
37  *
38  * ----- END LICENSE BLOCK -----
39  */

40 package org.jahia.data.containers;
41
42 import java.lang.reflect.InvocationHandler JavaDoc;
43 import java.lang.reflect.Method JavaDoc;
44 import java.util.*;
45
46 import org.jahia.data.FormDataManager;
47 import org.jahia.data.fields.*;
48 import org.jahia.engines.JahiaEngine;
49 import org.jahia.engines.shared.JahiaPageEngineTempBean;
50 import org.jahia.engines.shared.Page_Field;
51 import org.jahia.engines.validation.JahiaMltHelper;
52 import org.jahia.exceptions.JahiaException;
53 import org.jahia.params.ParamBean;
54 import org.jahia.services.pages.JahiaPage;
55 import org.jahia.services.version.EntryLoadRequest;
56 import org.jahia.utils.LanguageCodeConverters;
57
58 /**
59  * Used as the base class for all container validator beans.
60  *
61  * @author Benjamin Papez
62  */

63 public class ContainerValidatorBase implements InvocationHandler JavaDoc {
64
65     private static final org.apache.log4j.Logger logger = org.apache.log4j.Logger
66             .getLogger(ContainerValidatorBase.class);
67
68     private static String JavaDoc strToRemove[] = {"&LT;JAHIA", "<JAHIA", "</JAHIA", "&LT;/JAHIA", "_MULTILINE>", "_MULTILINE&GT;"};
69
70
71     protected ContainerFacadeInterface cf = null;
72
73     protected ParamBean jParams = null;
74
75     /**
76      * The constructor obtains the container facade and the ParamBean object
77      * used in the Jahia engines.
78      *
79      * @param newCf
80      * @param newParams
81      */

82     public ContainerValidatorBase(ContainerFacadeInterface newCf, ParamBean newParams) {
83         super();
84         cf = newCf;
85         jParams = newParams;
86     }
87
88     /**
89      * Gets the Jahia field out of the container field facade. The field is
90      * returned in the currently processed language. The version is either the
91      * staged or the active version. Keywords for uninitialized values are
92      * deleted. For a PAGE, the title is returned.
93      *
94      * @param fieldName
95      * @return value
96      */

97     protected String JavaDoc getJahiaField(String JavaDoc fieldName) {
98         String JavaDoc field = null;
99         if (fieldName == null) {
100             return null;
101         }
102
103         try {
104             Map engineMap = (HashMap) jParams.getSession().getAttribute("jahia_session_engineMap");
105
106             ArrayList locales = new ArrayList();
107             String JavaDoc languageCode = (String JavaDoc) engineMap.get(JahiaEngine.PROCESSING_LANGUAGECODE);
108             locales.add(LanguageCodeConverters.languageCodeToLocale(languageCode));
109
110             EntryLoadRequest entryLoadRequest = new EntryLoadRequest(EntryLoadRequest.STAGING_WORKFLOW_STATE
111                     | EntryLoadRequest.ACTIVE_WORKFLOW_STATE, 0, locales);
112
113             Enumeration fields = cf.getFields();
114
115             while (fields.hasMoreElements() && field == null) {
116                 JahiaContentFieldFacade cff = (JahiaContentFieldFacade) fields.nextElement();
117
118                 JahiaField newJf = cff.getField(entryLoadRequest, false);
119                 if (fieldName.equals(newJf.getDefinition().getName())) {
120                     switch (newJf.getType()) {
121                     case FieldTypes.PAGE:
122                         HashMap pageBeans = (HashMap) jParams.getSession().getAttribute("Page_Field.PageBeans");
123                         if (pageBeans == null) {
124                             pageBeans = new HashMap();
125                         }
126
127                         JahiaPageEngineTempBean pageBean = (JahiaPageEngineTempBean) pageBeans.get(newJf
128                                 .getDefinition().getName());
129                         field = "";
130                         if (pageBean == null || !Page_Field.RESET_LINK.equals(pageBean.getOperation())) {
131                             JahiaPage newPage = (JahiaPage) newJf.getObject();
132
133                             Map titles = (pageBean != null ? pageBean.getTitles() : (newPage == null ? null : newPage
134                                     .getContentPage().getTitles(true)));
135                             if (titles != null) {
136                                 field = (String JavaDoc) titles.get(languageCode);
137                             }
138                         }
139                         break;
140
141                     case FieldTypes.BIGTEXT:
142                         field = removeDefaultHtmlTags(newJf.getValue());
143                         break;
144
145                     case FieldTypes.DATE:
146                         if (newJf.getValue() != null && newJf.getValue().toUpperCase().indexOf("JAHIA_CALENDAR") != -1)
147                             field = "";
148                         else
149                             field = newJf.getValue();
150                         break;
151
152                     case FieldTypes.FILE:
153                         if (newJf.getValue() != null && newJf.getValue().toUpperCase().indexOf("<EMPTY>") != -1)
154                             field = "";
155                         else
156                             field = newJf.getValue();
157                         break;
158
159                     case FieldTypes.APPLICATION:
160                         field = (newJf.getObject() != null ? newJf.getObject().toString() : "");
161                         break;
162
163                     default:
164                         field = removeJahiaKeywords(newJf.getValue());
165                         break;
166                     }
167                 }
168             }
169         } catch (JahiaException e) {
170             logger.error("Error in retrieving Jahia field :", e);
171         }
172         if (field != null && "".equals(field.trim()))
173             field = null;
174         return field;
175     }
176
177     /**
178      * Gets the Jahia multivalue field out of the container field facade. The
179      * field is returned in the currently processed language. The version is
180      * either the staged or the active version. The field values are converted
181      * to a String array.
182      *
183      * @param fieldName
184      * @return fieldValues
185      */

186     protected JahiaMltHelper getJahiaMultiLanguageField(String JavaDoc fieldName) {
187         JahiaMltHelper field = null;
188
189         try {
190             Enumeration fields = cf.getFields();
191
192             while (fields.hasMoreElements() && field == null) {
193                 JahiaContentFieldFacade cff = (JahiaContentFieldFacade) fields.nextElement();
194
195                 Enumeration fieldsPerLanguage = cff.getFields();
196
197                 while (fieldsPerLanguage.hasMoreElements()) {
198                     JahiaField newJf = (JahiaField) fieldsPerLanguage.nextElement();
199
200                     if (fieldName.equals(newJf.getDefinition().getName())) {
201                         if (field == null)
202                             field = new JahiaMltHelper(jParams.getSite().getLanguageSettings());
203
204                         switch (newJf.getType()) {
205                         case FieldTypes.PAGE:
206                             HashMap pageBeans = (HashMap) jParams.getSession().getAttribute("Page_Field.PageBeans");
207                             if (pageBeans == null) {
208                                 pageBeans = new HashMap();
209                             }
210
211                             JahiaPageEngineTempBean pageBean = (JahiaPageEngineTempBean) pageBeans.get(newJf
212                                     .getDefinition().getName());
213                             if (pageBean == null || !Page_Field.RESET_LINK.equals(pageBean.getOperation())) {
214                                 JahiaPage newPage = (JahiaPage) newJf.getObject();
215
216                                 Map titles = (pageBean != null ? pageBean.getTitles() : (newPage == null ? null
217                                         : newPage.getContentPage().getTitles(true)));
218                                 if (titles != null) {
219                                     for (Iterator titlesIt = titles.entrySet().iterator(); titlesIt.hasNext();) {
220                                         Map.Entry entry = (Map.Entry) titlesIt.next();
221
222                                         field.addMltItem((String JavaDoc) entry.getKey(), (String JavaDoc) entry.getValue());
223                                     }
224                                 }
225                             }
226                             break;
227
228                         case FieldTypes.BIGTEXT:
229                             field.addMltItem(newJf.getLanguageCode(), removeDefaultHtmlTags(newJf.getValue()));
230                             break;
231
232                         case FieldTypes.DATE:
233                             if (newJf.getValue() != null
234                                     && newJf.getValue().toUpperCase().indexOf("JAHIA_CALENDAR") != -1)
235                                 field.addMltItem(newJf.getLanguageCode(), "");
236                             else
237                                 field.addMltItem(newJf.getLanguageCode(), newJf.getValue());
238                             break;
239
240                         case FieldTypes.FILE:
241                             if (newJf.getValue() != null && newJf.getValue().toUpperCase().indexOf("<EMPTY>") != -1)
242                                 field.addMltItem(newJf.getLanguageCode(), "");
243                             else
244                                 field.addMltItem(newJf.getLanguageCode(), FormDataManager.getInstance()
245                                         .removeSpecialTags(newJf.getValue()));
246                             break;
247
248                         case FieldTypes.APPLICATION:
249                             field.addMltItem(newJf.getLanguageCode(), (newJf.getObject() != null ? newJf.getObject()
250                                     .toString() : ""));
251                             break;
252
253                         default:
254                             field.addMltItem(newJf.getLanguageCode(), removeJahiaKeywords(newJf.getValue()));
255                             break;
256                         }
257                     }
258                 }
259             }
260         } catch (JahiaException e) {
261             logger.error("Error in retrieving Jahia field :", e);
262         }
263         return field.isEmpty() ? null : field;
264     }
265
266     /**
267      * Remove tags <html>, <br/>
268      *
269      * @param str
270      * @return the string with removed tags
271      */

272     public String JavaDoc removeDefaultHtmlTags(String JavaDoc str) {
273         if (str == null) {
274             return null;
275         }
276
277         str = removeTags(str, "html");
278         str = removeTag(str, "br");
279
280         return str;
281     }
282
283     /*
284      * Remove a start & end tag in a string For example removeTags(str,"title")
285      * will remove <title> and </title> @author POL
286      *
287      * @version 1.0 POL 23/01/2002 @param str Input String @param tag Tag to
288      * remove @return str
289      */

290     private String JavaDoc removeTags(String JavaDoc str, String JavaDoc tag) {
291         str = removeTag(str, tag);
292         str = removeTag(str, "/" + tag);
293         str = removeSpacesAndBreaks(str);
294         return str;
295     }
296
297     /*
298      * Remove a tag from a string Exemple: removeTag(str,"body") will remove
299      * <body bgcolor="#ffffff"> @author POL
300      *
301      * @version 1.0 POL 23/01/2002 @param str Input String @param tag Tag to
302      * remove @return str
303      */

304     private String JavaDoc removeTag(String JavaDoc str, String JavaDoc tag) {
305         if (str == null) {
306             return null;
307         }
308         StringBuffer JavaDoc result = new StringBuffer JavaDoc(str.length());
309         String JavaDoc strLower = str.toLowerCase();
310         tag = tag.toLowerCase();
311         int startOfIndex = 0;
312         int i = strLower.indexOf("<" + tag);
313         while (i != -1) {
314             result.append(str.substring(startOfIndex, i));
315             i = strLower.indexOf(">", i);
316             if (i != -1) {
317                 startOfIndex = i + 1;
318             }
319             i = strLower.indexOf("<" + tag, startOfIndex);
320         }
321         str = result.append(str.substring(startOfIndex, str.length())).toString();
322         return str;
323     }
324
325     /*
326      * Remove a tag from a string Exemple: removeTag(str,"body") will remove
327      * <body bgcolor="#ffffff"> @author POL
328      *
329      * @version 1.0 POL 23/01/2002 @param str Input String @param tag Tag to
330      * remove @return str
331      */

332     private String JavaDoc removeSpacesAndBreaks(String JavaDoc str) {
333         if (str == null) {
334             return null;
335         }
336         StringBuffer JavaDoc result = new StringBuffer JavaDoc(str.length());
337         int startOfIndex = 0;
338         int i = str.indexOf("/r");
339         while (i != -1) {
340             result.append(str.substring(startOfIndex, i));
341             startOfIndex = i + 2;
342             i = str.indexOf("/r", startOfIndex);
343         }
344
345         str = result.append(str.substring(startOfIndex, str.length())).toString();
346         result = new StringBuffer JavaDoc(str.length());
347         startOfIndex = 0;
348         i = str.indexOf("/r");
349         while (i != -1) {
350             result.append(str.substring(startOfIndex, i));
351             startOfIndex = i + 2;
352             i = str.indexOf("/r", startOfIndex);
353         }
354
355         str = result.append(str.substring(startOfIndex, str.length())).toString();
356
357         return str.trim();
358     }
359
360     private String JavaDoc removeJahiaKeywords(String JavaDoc theSelectedField) {
361
362         if (theSelectedField != null) {
363             String JavaDoc upperCaseField = theSelectedField.toUpperCase();
364             if (upperCaseField.indexOf("JAHIA_MULTILINE") != -1) {
365
366                 if (!upperCaseField.startsWith("&LT;JAHIA-RESOURCE")
367                         && !upperCaseField.startsWith("&LT;JAHIA-EXPRESSION")) {
368                     for (int i = 0; i < strToRemove.length; i++) {
369                         int index = upperCaseField.indexOf(strToRemove[i]);
370                         if (index != -1) {
371                             upperCaseField = upperCaseField.substring(0, index)
372                                     + upperCaseField
373                                             .substring(index + strToRemove[i].length(), upperCaseField.length());
374
375                             theSelectedField = theSelectedField.substring(0, index)
376                                     + theSelectedField.substring(index + strToRemove[i].length(), theSelectedField
377                                             .length());
378                         }
379                     }
380                 }
381
382                 if (theSelectedField.indexOf("[") != -1) {
383                     int startStr = theSelectedField.indexOf("[");
384                     int endStr = theSelectedField.indexOf("]>") + 2;
385                     theSelectedField = theSelectedField.substring(0, startStr)
386                             + theSelectedField.substring(endStr, theSelectedField.length());
387                 }
388             }
389         }
390         return theSelectedField;
391     }
392
393     public Object JavaDoc invoke(Object JavaDoc object, Method JavaDoc method, Object JavaDoc[] objects) throws Throwable JavaDoc {
394         logger.debug("Calling method " + method.getName());
395         if (method.getName().startsWith("get")) {
396             Enumeration fields = cf.getFields();
397             Object JavaDoc field;
398             String JavaDoc fieldName = method.getName().substring(3).toLowerCase();
399             if (fieldName.endsWith("mlt")) {
400                 fieldName = fieldName.substring(0, fieldName.length() - 3);
401 }
402             String JavaDoc matchingFieldName = null;
403             // try to find field by aliases
404
while (fields.hasMoreElements() && matchingFieldName == null) {
405                 JahiaContentFieldFacade cff = (JahiaContentFieldFacade) fields.nextElement();
406                 Enumeration fieldsPerLanguage = cff.getFields();
407
408                 while (fieldsPerLanguage.hasMoreElements() && matchingFieldName == null) {
409                     JahiaField newJf = (JahiaField) fieldsPerLanguage.nextElement();
410                     String JavaDoc[] aliasNames = new String JavaDoc[]{newJf.getDefinition().getName()};
411
412                     for (int i = 0; i < aliasNames.length; i++) {
413                         String JavaDoc defName = aliasNames[i].toLowerCase();
414                         if (defName.equals(fieldName)) {
415                             matchingFieldName = newJf.getDefinition().getName();
416                         }
417                     }
418                 }
419             }
420             if (matchingFieldName == null) {
421                 fields = cf.getFields();
422                 // try to find field by matching name
423
while (fields.hasMoreElements() && matchingFieldName == null) {
424                     JahiaContentFieldFacade cff = (JahiaContentFieldFacade) fields.nextElement();
425
426                     Enumeration fieldsPerLanguage = cff.getFields();
427
428                     while (fieldsPerLanguage.hasMoreElements() && matchingFieldName == null) {
429                         JahiaField newJf = (JahiaField) fieldsPerLanguage.nextElement();
430                         String JavaDoc defName = newJf.getDefinition().getName().toLowerCase();
431                         if (defName.equals(fieldName)) {
432                             matchingFieldName = newJf.getDefinition().getName();
433                         }
434                     }
435                 }
436             }
437             if (method.getReturnType().getName().equals(String JavaDoc.class.getName())) {
438                 field = getJahiaField(matchingFieldName);
439             } else {
440                 field = getJahiaMultiLanguageField(matchingFieldName);
441             }
442             logger.debug("return " + field + " for matching field " + matchingFieldName);
443             return field;
444         } else return null;
445     }
446 }
447
448
Popular Tags