001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.bean;
016    
017    import com.liferay.portal.kernel.bean.BeanProperties;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.log.Log;
020    import com.liferay.portal.kernel.log.LogFactoryUtil;
021    import com.liferay.portal.kernel.util.GetterUtil;
022    import com.liferay.portal.kernel.util.ParamUtil;
023    import com.liferay.portal.model.User;
024    import com.liferay.portal.theme.ThemeDisplay;
025    import com.liferay.portal.util.PortalUtil;
026    import com.liferay.portal.util.WebKeys;
027    
028    import java.util.Calendar;
029    import java.util.Date;
030    import java.util.Enumeration;
031    
032    import javax.servlet.http.HttpServletRequest;
033    
034    import jodd.bean.BeanTool;
035    import jodd.bean.BeanUtil;
036    
037    import jodd.typeconverter.Convert;
038    
039    /**
040     * @author Brian Wing Shun Chan
041     */
042    public class BeanPropertiesImpl implements BeanProperties {
043    
044            public void copyProperties(Object source, Object target) {
045                    try {
046                            BeanTool.copyProperties(source, target);
047                    }
048                    catch (Exception e) {
049                            _log.error(e, e);
050                    }
051            }
052    
053            public void copyProperties(
054                    Object source, Object target, Class<?> editable) {
055    
056                    try {
057                            BeanTool.copyProperties(source, target, editable);
058                    }
059                    catch (Exception e) {
060                            _log.error(e, e);
061                    }
062            }
063    
064            public void copyProperties(
065                    Object source, Object target, String[] ignoreProperties) {
066    
067                    try {
068                            BeanTool.copyProperties(source, target, ignoreProperties, false);
069                    }
070                    catch (Exception e) {
071                            _log.error(e, e);
072                    }
073            }
074    
075            public boolean getBoolean(Object bean, String param) {
076                    return getBoolean(bean, param, GetterUtil.DEFAULT_BOOLEAN);
077            }
078    
079            public boolean getBoolean(Object bean, String param, boolean defaultValue) {
080                    boolean beanValue = defaultValue;
081    
082                    if (bean != null) {
083                            try {
084                                    Object value = BeanUtil.getProperty(bean, param);
085    
086                                    beanValue = Convert.toBoolean(value, defaultValue);
087                            }
088                            catch (Exception e) {
089                                    _log.error(e, e);
090                            }
091                    }
092    
093                    return beanValue;
094            }
095    
096            public boolean getBooleanSilent(Object bean, String param) {
097                    return getBooleanSilent(bean, param, GetterUtil.DEFAULT_BOOLEAN);
098            }
099    
100            public boolean getBooleanSilent(
101                    Object bean, String param, boolean defaultValue) {
102    
103                    boolean beanValue = defaultValue;
104    
105                    if (bean != null) {
106                            try {
107                                    Object value = BeanUtil.getProperty(bean, param);
108    
109                                    beanValue = Convert.toBoolean(value, defaultValue);
110                            }
111                            catch (Exception e) {
112                            }
113                    }
114    
115                    return beanValue;
116            }
117    
118            public byte getByte(Object bean, String param) {
119                    return getByte(bean, param, GetterUtil.DEFAULT_BYTE);
120            }
121    
122            public byte getByte(Object bean, String param, byte defaultValue) {
123                    byte beanValue = defaultValue;
124    
125                    if (bean != null) {
126                            try {
127                                    Object value = BeanUtil.getProperty(bean, param);
128    
129                                    beanValue = Convert.toByte(value, defaultValue);
130                            }
131                            catch (Exception e) {
132                                    _log.error(e, e);
133                            }
134                    }
135    
136                    return beanValue;
137            }
138    
139            public byte getByteSilent(Object bean, String param) {
140                    return getByteSilent(bean, param, GetterUtil.DEFAULT_BYTE);
141            }
142    
143            public byte getByteSilent(Object bean, String param, byte defaultValue) {
144                    byte beanValue = defaultValue;
145    
146                    if (bean != null) {
147                            try {
148                                    Object value = BeanUtil.getProperty(bean, param);
149    
150                                    beanValue = Convert.toByte(value, defaultValue);
151                            }
152                            catch (Exception e) {
153                            }
154                    }
155    
156                    return beanValue;
157            }
158    
159            public double getDouble(Object bean, String param) {
160                    return getDouble(bean, param, GetterUtil.DEFAULT_DOUBLE);
161            }
162    
163            public double getDouble(Object bean, String param, double defaultValue) {
164                    double beanValue = defaultValue;
165    
166                    if (bean != null) {
167                            try {
168                                    Object value = BeanUtil.getProperty(bean, param);
169    
170                                    beanValue = Convert.toDouble(value, defaultValue);
171                            }
172                            catch (Exception e) {
173                                    _log.error(e, e);
174                            }
175                    }
176    
177                    return beanValue;
178            }
179    
180            public double getDoubleSilent(Object bean, String param) {
181                    return getDoubleSilent(bean, param, GetterUtil.DEFAULT_DOUBLE);
182            }
183    
184            public double getDoubleSilent(
185                    Object bean, String param, double defaultValue) {
186    
187                    double beanValue = defaultValue;
188    
189                    if (bean != null) {
190                            try {
191                                    Object value = BeanUtil.getProperty(bean, param);
192    
193                                    beanValue = Convert.toDouble(value, defaultValue);
194                            }
195                            catch (Exception e) {
196                            }
197                    }
198    
199                    return beanValue;
200            }
201    
202            public float getFloat(Object bean, String param) {
203                    return getFloat(bean, param, GetterUtil.DEFAULT_FLOAT);
204            }
205    
206            public float getFloat(Object bean, String param, float defaultValue) {
207                    float beanValue = defaultValue;
208    
209                    if (bean != null) {
210                            try {
211                                    Object value = BeanUtil.getProperty(bean, param);
212    
213                                    beanValue = Convert.toFloat(value, defaultValue);
214                            }
215                            catch (Exception e) {
216                                    _log.error(e, e);
217                            }
218                    }
219    
220                    return beanValue;
221            }
222    
223            public float getFloatSilent(Object bean, String param) {
224                    return getFloatSilent(bean, param, GetterUtil.DEFAULT_FLOAT);
225            }
226    
227            public float getFloatSilent(Object bean, String param, float defaultValue) {
228                    float beanValue = defaultValue;
229    
230                    if (bean != null) {
231                            try {
232                                    Object value = BeanUtil.getProperty(bean, param);
233    
234                                    beanValue = Convert.toFloat(value, defaultValue);
235                            }
236                            catch (Exception e) {
237                            }
238                    }
239    
240                    return beanValue;
241            }
242    
243            public int getInteger(Object bean, String param) {
244                    return getInteger(bean, param, GetterUtil.DEFAULT_INTEGER);
245            }
246    
247            public int getInteger(Object bean, String param, int defaultValue) {
248                    int beanValue = defaultValue;
249    
250                    if (bean != null) {
251                            try {
252                                    Object value = BeanUtil.getProperty(bean, param);
253    
254                                    beanValue = Convert.toInteger(value, defaultValue);
255                            }
256                            catch (Exception e) {
257                                    _log.error(e, e);
258                            }
259                    }
260    
261                    return beanValue;
262            }
263    
264            public int getIntegerSilent(Object bean, String param) {
265                    return getIntegerSilent(bean, param, GetterUtil.DEFAULT_INTEGER);
266            }
267    
268            public int getIntegerSilent(Object bean, String param, int defaultValue) {
269                    int beanValue = defaultValue;
270    
271                    if (bean != null) {
272                            try {
273                                    Object value = BeanUtil.getProperty(bean, param);
274    
275                                    beanValue = Convert.toInteger(value, defaultValue);
276                            }
277                            catch (Exception e) {
278                            }
279                    }
280    
281                    return beanValue;
282            }
283    
284            public long getLong(Object bean, String param) {
285                    return getLong(bean, param, GetterUtil.DEFAULT_LONG);
286            }
287    
288            public long getLong(Object bean, String param, long defaultValue) {
289                    long beanValue = defaultValue;
290    
291                    if (bean != null) {
292                            try {
293                                    Object value = BeanUtil.getProperty(bean, param);
294    
295                                    beanValue = Convert.toLong(value, defaultValue);
296                            }
297                            catch (Exception e) {
298                                    _log.error(e, e);
299                            }
300                    }
301    
302                    return beanValue;
303            }
304    
305            public long getLongSilent(Object bean, String param) {
306                    return getLongSilent(bean, param, GetterUtil.DEFAULT_LONG);
307            }
308    
309            public long getLongSilent(Object bean, String param, long defaultValue) {
310                    long beanValue = defaultValue;
311    
312                    if (bean != null) {
313                            try {
314                                    Object value = BeanUtil.getProperty(bean, param);
315    
316                                    beanValue = Convert.toLong(value, defaultValue);
317                            }
318                            catch (Exception e) {
319                            }
320                    }
321    
322                    return beanValue;
323            }
324    
325            public Object getObject(Object bean, String param) {
326                    return getObject(bean, param, null);
327            }
328    
329            public Object getObject(Object bean, String param, Object defaultValue) {
330                    Object beanValue = null;
331    
332                    if (bean != null) {
333                            try {
334                                    beanValue = BeanUtil.getProperty(bean, param);
335                            }
336                            catch (Exception e) {
337                                    _log.error(e, e);
338                            }
339                    }
340    
341                    if (beanValue == null) {
342                            return defaultValue;
343                    }
344                    else {
345                            return beanValue;
346                    }
347            }
348    
349            public Object getObjectSilent(Object bean, String param) {
350                    return getObjectSilent(bean, param, null);
351            }
352    
353            public Object getObjectSilent(
354                    Object bean, String param, Object defaultValue) {
355    
356                    Object beanValue = null;
357    
358                    if (bean != null) {
359                            try {
360                                    beanValue = BeanUtil.getProperty(bean, param);
361                            }
362                            catch (Exception e) {
363                            }
364                    }
365    
366                    if (beanValue == null) {
367                            return defaultValue;
368                    }
369                    else {
370                            return beanValue;
371                    }
372            }
373    
374            public short getShort(Object bean, String param) {
375                    return getShort(bean, param, GetterUtil.DEFAULT_SHORT);
376            }
377    
378            public short getShort(Object bean, String param, short defaultValue) {
379                    short beanValue = defaultValue;
380    
381                    if (bean != null) {
382                            try {
383                                    Object value = BeanUtil.getProperty(bean, param);
384    
385                                    beanValue = Convert.toShort(value, defaultValue);
386                            }
387                            catch (Exception e) {
388                                    _log.error(e, e);
389                            }
390                    }
391    
392                    return beanValue;
393            }
394    
395            public short getShortSilent(Object bean, String param) {
396                    return getShortSilent(bean, param, GetterUtil.DEFAULT_SHORT);
397            }
398    
399            public short getShortSilent(Object bean, String param, short defaultValue) {
400                    short beanValue = defaultValue;
401    
402                    if (bean != null) {
403                            try {
404                                    Object value = BeanUtil.getProperty(bean, param);
405    
406                                    beanValue = Convert.toShort(value, defaultValue);
407                            }
408                            catch (Exception e) {
409                            }
410                    }
411    
412                    return beanValue;
413            }
414    
415            public String getString(Object bean, String param) {
416                    return getString(bean, param, GetterUtil.DEFAULT_STRING);
417            }
418    
419            public String getString(Object bean, String param, String defaultValue) {
420                    String beanValue = defaultValue;
421    
422                    if (bean != null) {
423                            try {
424                                    Object value = BeanUtil.getProperty(bean, param);
425    
426                                    beanValue = Convert.toString(value, defaultValue);
427                            }
428                            catch (Exception e) {
429                                    _log.error(e, e);
430                            }
431                    }
432    
433                    return beanValue;
434            }
435    
436            public String getStringSilent(Object bean, String param) {
437                    return getStringSilent(bean, param, GetterUtil.DEFAULT_STRING);
438            }
439    
440            public String getStringSilent(
441                    Object bean, String param, String defaultValue) {
442    
443                    String beanValue = defaultValue;
444    
445                    if (bean != null) {
446                            try {
447                                    Object value = BeanUtil.getProperty(bean, param);
448    
449                                    beanValue = Convert.toString(value, defaultValue);
450                            }
451                            catch (Exception e) {
452                            }
453                    }
454    
455                    return beanValue;
456            }
457    
458            public void setProperties(Object bean, HttpServletRequest request) {
459                    Enumeration<String> enu = request.getParameterNames();
460    
461                    while (enu.hasMoreElements()) {
462                            String name = enu.nextElement();
463    
464                            String value = request.getParameter(name);
465    
466                            BeanUtil.setPropertyForcedSilent(bean, name, value);
467    
468                            if (name.endsWith("Month")) {
469                                    String dateParam = name.substring(0, name.lastIndexOf("Month"));
470    
471                                    if (request.getParameter(dateParam) != null) {
472                                            continue;
473                                    }
474    
475                                    Class<?> propertyTypeClass = BeanUtil.getPropertyType(
476                                            bean, dateParam);
477    
478                                    if ((propertyTypeClass == null) ||
479                                            !propertyTypeClass.equals(Date.class)) {
480    
481                                            continue;
482                                    }
483    
484                                    Date date = getDate(dateParam, request);
485    
486                                    if (date != null) {
487                                            BeanUtil.setPropertyForcedSilent(bean, dateParam, date);
488                                    }
489                            }
490                    }
491            }
492    
493            public void setProperty(Object bean, String param, Object value) {
494                    try {
495                            BeanUtil.setProperty(bean, param, value);
496                    }
497                    catch (Exception e) {
498                            _log.error(e, e);
499                    }
500            }
501    
502            protected Date getDate(String param, HttpServletRequest request) {
503                    int month = ParamUtil.getInteger(request, param + "Month");
504                    int day = ParamUtil.getInteger(request, param + "Day");
505                    int year = ParamUtil.getInteger(request, param + "Year");
506                    int hour = ParamUtil.getInteger(request, param + "Hour", -1);
507                    int minute = ParamUtil.getInteger(request, param + "Minute");
508    
509                    int amPm = ParamUtil.getInteger(request, param + "AmPm");
510    
511                    if (amPm == Calendar.PM) {
512                            hour += 12;
513                    }
514    
515                    if (hour == -1) {
516                            return PortalUtil.getDate(month, day, year);
517                    }
518    
519                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
520                            WebKeys.THEME_DISPLAY);
521    
522                    User user = themeDisplay.getUser();
523    
524                    try {
525                            return PortalUtil.getDate(
526                                    month, day, year, hour, minute, user.getTimeZone(),
527                                    new PortalException());
528                    }
529                    catch (PortalException pe) {
530                            return null;
531                    }
532            }
533    
534            private static Log _log = LogFactoryUtil.getLog(BeanPropertiesImpl.class);
535    
536    }