001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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.equals(Date.class)) {
479                                            continue;
480                                    }
481    
482                                    Date date = getDate(dateParam, request);
483    
484                                    if (date != null) {
485                                            BeanUtil.setPropertyForcedSilent(bean, dateParam, date);
486                                    }
487                            }
488                    }
489            }
490    
491            public void setProperty(Object bean, String param, Object value) {
492                    try {
493                            BeanUtil.setProperty(bean, param, value);
494                    }
495                    catch (Exception e) {
496                            _log.error(e, e);
497                    }
498            }
499    
500            protected Date getDate(String param, HttpServletRequest request) {
501                    int month = ParamUtil.getInteger(request, param + "Month");
502                    int day = ParamUtil.getInteger(request, param + "Day");
503                    int year = ParamUtil.getInteger(request, param + "Year");
504                    int hour = ParamUtil.getInteger(request, param + "Hour", -1);
505                    int minute = ParamUtil.getInteger(request, param + "Minute");
506    
507                    int amPm = ParamUtil.getInteger(request, param + "AmPm");
508    
509                    if (amPm == Calendar.PM) {
510                            hour += 12;
511                    }
512    
513                    if (hour == -1) {
514                            return PortalUtil.getDate(month, day, year);
515                    }
516    
517                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
518                            WebKeys.THEME_DISPLAY);
519    
520                    User user = themeDisplay.getUser();
521    
522                    try {
523                            return PortalUtil.getDate(
524                                    month, day, year, hour, minute, user.getTimeZone(),
525                                    new PortalException());
526                    }
527                    catch (PortalException pe) {
528                            return null;
529                    }
530            }
531    
532            private static Log _log = LogFactoryUtil.getLog(BeanPropertiesImpl.class);
533    
534    }