001    /**
002     * Copyright (c) 2000-2012 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 Class<?> getObjectType(Object bean, String param) {
375                    return getObjectType(bean, param, null);
376            }
377    
378            public Class<?> getObjectType(
379                    Object bean, String param, Class<?> defaultValue) {
380    
381                    Class<?> beanType = null;
382    
383                    if (bean != null) {
384                            try {
385                                    beanType = BeanUtil.getPropertyType(bean, param);
386                            }
387                            catch (Exception e) {
388                                    _log.error(e, e);
389                            }
390                    }
391    
392                    if (beanType == null) {
393                            return defaultValue;
394                    }
395                    else {
396                            return beanType;
397                    }
398            }
399    
400            public Class<?> getObjectTypeSilent(Object bean, String param) {
401                    return getObjectTypeSilent(bean, param, null);
402            }
403    
404            public Class<?> getObjectTypeSilent(
405                    Object bean, String param, Class<?> defaultValue) {
406    
407                    Class<?> beanType = null;
408    
409                    if (bean != null) {
410                            try {
411                                    beanType = BeanUtil.getPropertyType(bean, param);
412                            }
413                            catch (Exception e) {
414                            }
415                    }
416    
417                    if (beanType == null) {
418                            return defaultValue;
419                    }
420                    else {
421                            return beanType;
422                    }
423            }
424    
425            public short getShort(Object bean, String param) {
426                    return getShort(bean, param, GetterUtil.DEFAULT_SHORT);
427            }
428    
429            public short getShort(Object bean, String param, short defaultValue) {
430                    short beanValue = defaultValue;
431    
432                    if (bean != null) {
433                            try {
434                                    Object value = BeanUtil.getProperty(bean, param);
435    
436                                    beanValue = Convert.toShort(value, defaultValue);
437                            }
438                            catch (Exception e) {
439                                    _log.error(e, e);
440                            }
441                    }
442    
443                    return beanValue;
444            }
445    
446            public short getShortSilent(Object bean, String param) {
447                    return getShortSilent(bean, param, GetterUtil.DEFAULT_SHORT);
448            }
449    
450            public short getShortSilent(Object bean, String param, short defaultValue) {
451                    short beanValue = defaultValue;
452    
453                    if (bean != null) {
454                            try {
455                                    Object value = BeanUtil.getProperty(bean, param);
456    
457                                    beanValue = Convert.toShort(value, defaultValue);
458                            }
459                            catch (Exception e) {
460                            }
461                    }
462    
463                    return beanValue;
464            }
465    
466            public String getString(Object bean, String param) {
467                    return getString(bean, param, GetterUtil.DEFAULT_STRING);
468            }
469    
470            public String getString(Object bean, String param, String defaultValue) {
471                    String beanValue = defaultValue;
472    
473                    if (bean != null) {
474                            try {
475                                    Object value = BeanUtil.getProperty(bean, param);
476    
477                                    beanValue = Convert.toString(value, defaultValue);
478                            }
479                            catch (Exception e) {
480                                    _log.error(e, e);
481                            }
482                    }
483    
484                    return beanValue;
485            }
486    
487            public String getStringSilent(Object bean, String param) {
488                    return getStringSilent(bean, param, GetterUtil.DEFAULT_STRING);
489            }
490    
491            public String getStringSilent(
492                    Object bean, String param, String defaultValue) {
493    
494                    String beanValue = defaultValue;
495    
496                    if (bean != null) {
497                            try {
498                                    Object value = BeanUtil.getProperty(bean, param);
499    
500                                    beanValue = Convert.toString(value, defaultValue);
501                            }
502                            catch (Exception e) {
503                            }
504                    }
505    
506                    return beanValue;
507            }
508    
509            public void setProperties(Object bean, HttpServletRequest request) {
510                    Enumeration<String> enu = request.getParameterNames();
511    
512                    while (enu.hasMoreElements()) {
513                            String name = enu.nextElement();
514    
515                            String value = request.getParameter(name);
516    
517                            BeanUtil.setPropertyForcedSilent(bean, name, value);
518    
519                            if (name.endsWith("Month")) {
520                                    String dateParam = name.substring(0, name.lastIndexOf("Month"));
521    
522                                    if (request.getParameter(dateParam) != null) {
523                                            continue;
524                                    }
525    
526                                    Class<?> propertyTypeClass = BeanUtil.getPropertyType(
527                                            bean, dateParam);
528    
529                                    if ((propertyTypeClass == null) ||
530                                            !propertyTypeClass.equals(Date.class)) {
531    
532                                            continue;
533                                    }
534    
535                                    Date date = getDate(dateParam, request);
536    
537                                    if (date != null) {
538                                            BeanUtil.setPropertyForcedSilent(bean, dateParam, date);
539                                    }
540                            }
541                    }
542            }
543    
544            public void setProperty(Object bean, String param, Object value) {
545                    try {
546                            BeanUtil.setProperty(bean, param, value);
547                    }
548                    catch (Exception e) {
549                            _log.error(e, e);
550                    }
551            }
552    
553            protected Date getDate(String param, HttpServletRequest request) {
554                    int month = ParamUtil.getInteger(request, param + "Month");
555                    int day = ParamUtil.getInteger(request, param + "Day");
556                    int year = ParamUtil.getInteger(request, param + "Year");
557                    int hour = ParamUtil.getInteger(request, param + "Hour", -1);
558                    int minute = ParamUtil.getInteger(request, param + "Minute");
559    
560                    int amPm = ParamUtil.getInteger(request, param + "AmPm");
561    
562                    if (amPm == Calendar.PM) {
563                            hour += 12;
564                    }
565    
566                    if (hour == -1) {
567                            return PortalUtil.getDate(month, day, year);
568                    }
569    
570                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
571                            WebKeys.THEME_DISPLAY);
572    
573                    User user = themeDisplay.getUser();
574    
575                    try {
576                            return PortalUtil.getDate(
577                                    month, day, year, hour, minute, user.getTimeZone(),
578                                    new PortalException());
579                    }
580                    catch (PortalException pe) {
581                            return null;
582                    }
583            }
584    
585            private static Log _log = LogFactoryUtil.getLog(BeanPropertiesImpl.class);
586    
587    }