001    /**
002     * Copyright (c) 2000-present 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.security.pacl.DoPrivileged;
022    import com.liferay.portal.kernel.util.GetterUtil;
023    import com.liferay.portal.kernel.util.ParamUtil;
024    import com.liferay.portal.model.User;
025    import com.liferay.portal.theme.ThemeDisplay;
026    import com.liferay.portal.util.PortalUtil;
027    import com.liferay.portal.util.WebKeys;
028    
029    import java.util.Calendar;
030    import java.util.Date;
031    import java.util.Enumeration;
032    
033    import javax.servlet.http.HttpServletRequest;
034    
035    import jodd.bean.BeanCopy;
036    import jodd.bean.BeanUtil;
037    
038    import jodd.typeconverter.Convert;
039    
040    /**
041     * @author Brian Wing Shun Chan
042     */
043    @DoPrivileged
044    public class BeanPropertiesImpl implements BeanProperties {
045    
046            @Override
047            public void copyProperties(Object source, Object target) {
048                    try {
049                            BeanCopy beanCopy = BeanCopy.beans(source, target);
050    
051                            beanCopy.copy();
052                    }
053                    catch (Exception e) {
054                            _log.error(e, e);
055                    }
056            }
057    
058            @Override
059            public void copyProperties(
060                    Object source, Object target, Class<?> editable) {
061    
062                    try {
063                            BeanCopy beanCopy = BeanCopy.beans(source, target);
064    
065                            beanCopy.includeAs(editable);
066    
067                            beanCopy.copy();
068                    }
069                    catch (Exception e) {
070                            _log.error(e, e);
071                    }
072            }
073    
074            @Override
075            public void copyProperties(
076                    Object source, Object target, String[] ignoreProperties) {
077    
078                    try {
079                            BeanCopy beanCopy = BeanCopy.beans(source, target);
080    
081                            beanCopy.exclude(ignoreProperties);
082    
083                            beanCopy.copy();
084                    }
085                    catch (Exception e) {
086                            _log.error(e, e);
087                    }
088            }
089    
090            @Override
091            public boolean getBoolean(Object bean, String param) {
092                    return getBoolean(bean, param, GetterUtil.DEFAULT_BOOLEAN);
093            }
094    
095            @Override
096            public boolean getBoolean(Object bean, String param, boolean defaultValue) {
097                    boolean beanValue = defaultValue;
098    
099                    if (bean != null) {
100                            try {
101                                    Object value = BeanUtil.getProperty(bean, param);
102    
103                                    beanValue = Convert.toBooleanValue(value, defaultValue);
104                            }
105                            catch (Exception e) {
106                                    _log.error(e, e);
107                            }
108                    }
109    
110                    return beanValue;
111            }
112    
113            @Override
114            public boolean getBooleanSilent(Object bean, String param) {
115                    return getBooleanSilent(bean, param, GetterUtil.DEFAULT_BOOLEAN);
116            }
117    
118            @Override
119            public boolean getBooleanSilent(
120                    Object bean, String param, boolean defaultValue) {
121    
122                    boolean beanValue = defaultValue;
123    
124                    if (bean != null) {
125                            try {
126                                    Object value = BeanUtil.getProperty(bean, param);
127    
128                                    beanValue = Convert.toBooleanValue(value, defaultValue);
129                            }
130                            catch (Exception e) {
131                            }
132                    }
133    
134                    return beanValue;
135            }
136    
137            @Override
138            public byte getByte(Object bean, String param) {
139                    return getByte(bean, param, GetterUtil.DEFAULT_BYTE);
140            }
141    
142            @Override
143            public byte getByte(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.toByteValue(value, defaultValue);
151                            }
152                            catch (Exception e) {
153                                    _log.error(e, e);
154                            }
155                    }
156    
157                    return beanValue;
158            }
159    
160            @Override
161            public byte getByteSilent(Object bean, String param) {
162                    return getByteSilent(bean, param, GetterUtil.DEFAULT_BYTE);
163            }
164    
165            @Override
166            public byte getByteSilent(Object bean, String param, byte defaultValue) {
167                    byte beanValue = defaultValue;
168    
169                    if (bean != null) {
170                            try {
171                                    Object value = BeanUtil.getProperty(bean, param);
172    
173                                    beanValue = Convert.toByteValue(value, defaultValue);
174                            }
175                            catch (Exception e) {
176                            }
177                    }
178    
179                    return beanValue;
180            }
181    
182            @Override
183            public double getDouble(Object bean, String param) {
184                    return getDouble(bean, param, GetterUtil.DEFAULT_DOUBLE);
185            }
186    
187            @Override
188            public double getDouble(Object bean, String param, double defaultValue) {
189                    double beanValue = defaultValue;
190    
191                    if (bean != null) {
192                            try {
193                                    Object value = BeanUtil.getProperty(bean, param);
194    
195                                    beanValue = Convert.toDoubleValue(value, defaultValue);
196                            }
197                            catch (Exception e) {
198                                    _log.error(e, e);
199                            }
200                    }
201    
202                    return beanValue;
203            }
204    
205            @Override
206            public double getDoubleSilent(Object bean, String param) {
207                    return getDoubleSilent(bean, param, GetterUtil.DEFAULT_DOUBLE);
208            }
209    
210            @Override
211            public double getDoubleSilent(
212                    Object bean, String param, double defaultValue) {
213    
214                    double beanValue = defaultValue;
215    
216                    if (bean != null) {
217                            try {
218                                    Object value = BeanUtil.getProperty(bean, param);
219    
220                                    beanValue = Convert.toDoubleValue(value, defaultValue);
221                            }
222                            catch (Exception e) {
223                            }
224                    }
225    
226                    return beanValue;
227            }
228    
229            @Override
230            public float getFloat(Object bean, String param) {
231                    return getFloat(bean, param, GetterUtil.DEFAULT_FLOAT);
232            }
233    
234            @Override
235            public float getFloat(Object bean, String param, float defaultValue) {
236                    float beanValue = defaultValue;
237    
238                    if (bean != null) {
239                            try {
240                                    Object value = BeanUtil.getProperty(bean, param);
241    
242                                    beanValue = Convert.toFloatValue(value, defaultValue);
243                            }
244                            catch (Exception e) {
245                                    _log.error(e, e);
246                            }
247                    }
248    
249                    return beanValue;
250            }
251    
252            @Override
253            public float getFloatSilent(Object bean, String param) {
254                    return getFloatSilent(bean, param, GetterUtil.DEFAULT_FLOAT);
255            }
256    
257            @Override
258            public float getFloatSilent(Object bean, String param, float defaultValue) {
259                    float beanValue = defaultValue;
260    
261                    if (bean != null) {
262                            try {
263                                    Object value = BeanUtil.getProperty(bean, param);
264    
265                                    beanValue = Convert.toFloatValue(value, defaultValue);
266                            }
267                            catch (Exception e) {
268                            }
269                    }
270    
271                    return beanValue;
272            }
273    
274            @Override
275            public int getInteger(Object bean, String param) {
276                    return getInteger(bean, param, GetterUtil.DEFAULT_INTEGER);
277            }
278    
279            @Override
280            public int getInteger(Object bean, String param, int defaultValue) {
281                    int beanValue = defaultValue;
282    
283                    if (bean != null) {
284                            try {
285                                    Object value = BeanUtil.getProperty(bean, param);
286    
287                                    beanValue = Convert.toIntValue(value, defaultValue);
288                            }
289                            catch (Exception e) {
290                                    _log.error(e, e);
291                            }
292                    }
293    
294                    return beanValue;
295            }
296    
297            @Override
298            public int getIntegerSilent(Object bean, String param) {
299                    return getIntegerSilent(bean, param, GetterUtil.DEFAULT_INTEGER);
300            }
301    
302            @Override
303            public int getIntegerSilent(Object bean, String param, int defaultValue) {
304                    int beanValue = defaultValue;
305    
306                    if (bean != null) {
307                            try {
308                                    Object value = BeanUtil.getProperty(bean, param);
309    
310                                    beanValue = Convert.toIntValue(value, defaultValue);
311                            }
312                            catch (Exception e) {
313                            }
314                    }
315    
316                    return beanValue;
317            }
318    
319            @Override
320            public long getLong(Object bean, String param) {
321                    return getLong(bean, param, GetterUtil.DEFAULT_LONG);
322            }
323    
324            @Override
325            public long getLong(Object bean, String param, long defaultValue) {
326                    long beanValue = defaultValue;
327    
328                    if (bean != null) {
329                            try {
330                                    Object value = BeanUtil.getProperty(bean, param);
331    
332                                    beanValue = Convert.toLongValue(value, defaultValue);
333                            }
334                            catch (Exception e) {
335                                    _log.error(e, e);
336                            }
337                    }
338    
339                    return beanValue;
340            }
341    
342            @Override
343            public long getLongSilent(Object bean, String param) {
344                    return getLongSilent(bean, param, GetterUtil.DEFAULT_LONG);
345            }
346    
347            @Override
348            public long getLongSilent(Object bean, String param, long defaultValue) {
349                    long beanValue = defaultValue;
350    
351                    if (bean != null) {
352                            try {
353                                    Object value = BeanUtil.getProperty(bean, param);
354    
355                                    beanValue = Convert.toLongValue(value, defaultValue);
356                            }
357                            catch (Exception e) {
358                            }
359                    }
360    
361                    return beanValue;
362            }
363    
364            @Override
365            public Object getObject(Object bean, String param) {
366                    return getObject(bean, param, null);
367            }
368    
369            @Override
370            public Object getObject(Object bean, String param, Object defaultValue) {
371                    Object beanValue = null;
372    
373                    if (bean != null) {
374                            try {
375                                    beanValue = BeanUtil.getProperty(bean, param);
376                            }
377                            catch (Exception e) {
378                                    _log.error(e, e);
379                            }
380                    }
381    
382                    if (beanValue == null) {
383                            return defaultValue;
384                    }
385                    else {
386                            return beanValue;
387                    }
388            }
389    
390            @Override
391            public Object getObjectSilent(Object bean, String param) {
392                    return getObjectSilent(bean, param, null);
393            }
394    
395            @Override
396            public Object getObjectSilent(
397                    Object bean, String param, Object defaultValue) {
398    
399                    Object beanValue = null;
400    
401                    if (bean != null) {
402                            try {
403                                    beanValue = BeanUtil.getProperty(bean, param);
404                            }
405                            catch (Exception e) {
406                            }
407                    }
408    
409                    if (beanValue == null) {
410                            return defaultValue;
411                    }
412                    else {
413                            return beanValue;
414                    }
415            }
416    
417            @Override
418            public Class<?> getObjectType(Object bean, String param) {
419                    return getObjectType(bean, param, null);
420            }
421    
422            @Override
423            public Class<?> getObjectType(
424                    Object bean, String param, Class<?> defaultValue) {
425    
426                    Class<?> beanType = null;
427    
428                    if (bean != null) {
429                            try {
430                                    beanType = BeanUtil.getPropertyType(bean, param);
431                            }
432                            catch (Exception e) {
433                                    _log.error(e, e);
434                            }
435                    }
436    
437                    if (beanType == null) {
438                            return defaultValue;
439                    }
440                    else {
441                            return beanType;
442                    }
443            }
444    
445            @Override
446            public Class<?> getObjectTypeSilent(Object bean, String param) {
447                    return getObjectTypeSilent(bean, param, null);
448            }
449    
450            @Override
451            public Class<?> getObjectTypeSilent(
452                    Object bean, String param, Class<?> defaultValue) {
453    
454                    Class<?> beanType = null;
455    
456                    if (bean != null) {
457                            try {
458                                    beanType = BeanUtil.getPropertyType(bean, param);
459                            }
460                            catch (Exception e) {
461                            }
462                    }
463    
464                    if (beanType == null) {
465                            return defaultValue;
466                    }
467                    else {
468                            return beanType;
469                    }
470            }
471    
472            @Override
473            public short getShort(Object bean, String param) {
474                    return getShort(bean, param, GetterUtil.DEFAULT_SHORT);
475            }
476    
477            @Override
478            public short getShort(Object bean, String param, short defaultValue) {
479                    short beanValue = defaultValue;
480    
481                    if (bean != null) {
482                            try {
483                                    Object value = BeanUtil.getProperty(bean, param);
484    
485                                    beanValue = Convert.toShortValue(value, defaultValue);
486                            }
487                            catch (Exception e) {
488                                    _log.error(e, e);
489                            }
490                    }
491    
492                    return beanValue;
493            }
494    
495            @Override
496            public short getShortSilent(Object bean, String param) {
497                    return getShortSilent(bean, param, GetterUtil.DEFAULT_SHORT);
498            }
499    
500            @Override
501            public short getShortSilent(Object bean, String param, short defaultValue) {
502                    short beanValue = defaultValue;
503    
504                    if (bean != null) {
505                            try {
506                                    Object value = BeanUtil.getProperty(bean, param);
507    
508                                    beanValue = Convert.toShortValue(value, defaultValue);
509                            }
510                            catch (Exception e) {
511                            }
512                    }
513    
514                    return beanValue;
515            }
516    
517            @Override
518            public String getString(Object bean, String param) {
519                    return getString(bean, param, GetterUtil.DEFAULT_STRING);
520            }
521    
522            @Override
523            public String getString(Object bean, String param, String defaultValue) {
524                    String beanValue = defaultValue;
525    
526                    if (bean != null) {
527                            try {
528                                    Object value = BeanUtil.getProperty(bean, param);
529    
530                                    beanValue = Convert.toString(value, defaultValue);
531                            }
532                            catch (Exception e) {
533                                    _log.error(e, e);
534                            }
535                    }
536    
537                    return beanValue;
538            }
539    
540            @Override
541            public String getStringSilent(Object bean, String param) {
542                    return getStringSilent(bean, param, GetterUtil.DEFAULT_STRING);
543            }
544    
545            @Override
546            public String getStringSilent(
547                    Object bean, String param, String defaultValue) {
548    
549                    String beanValue = defaultValue;
550    
551                    if (bean != null) {
552                            try {
553                                    Object value = BeanUtil.getProperty(bean, param);
554    
555                                    beanValue = Convert.toString(value, defaultValue);
556                            }
557                            catch (Exception e) {
558                            }
559                    }
560    
561                    return beanValue;
562            }
563    
564            @Override
565            public void setProperties(Object bean, HttpServletRequest request) {
566                    Enumeration<String> enu = request.getParameterNames();
567    
568                    while (enu.hasMoreElements()) {
569                            String name = enu.nextElement();
570    
571                            String value = request.getParameter(name);
572    
573                            BeanUtil.setPropertyForcedSilent(bean, name, value);
574    
575                            if (name.endsWith("Month")) {
576                                    String dateParam = name.substring(0, name.lastIndexOf("Month"));
577    
578                                    if (request.getParameter(dateParam) != null) {
579                                            continue;
580                                    }
581    
582                                    Class<?> propertyTypeClass = BeanUtil.getPropertyType(
583                                            bean, dateParam);
584    
585                                    if ((propertyTypeClass == null) ||
586                                            !propertyTypeClass.equals(Date.class)) {
587    
588                                            continue;
589                                    }
590    
591                                    Date date = getDate(dateParam, request);
592    
593                                    if (date != null) {
594                                            BeanUtil.setPropertyForcedSilent(bean, dateParam, date);
595                                    }
596                            }
597                    }
598            }
599    
600            @Override
601            public void setProperty(Object bean, String param, Object value) {
602                    try {
603                            BeanUtil.setProperty(bean, param, value);
604                    }
605                    catch (Exception e) {
606                            _log.error(e, e);
607                    }
608            }
609    
610            @Override
611            public void setPropertySilent(Object bean, String param, Object value) {
612                    BeanUtil.setPropertyForcedSilent(bean, param, value);
613            }
614    
615            protected Date getDate(String param, HttpServletRequest request) {
616                    int month = ParamUtil.getInteger(request, param + "Month");
617                    int day = ParamUtil.getInteger(request, param + "Day");
618                    int year = ParamUtil.getInteger(request, param + "Year");
619                    int hour = ParamUtil.getInteger(request, param + "Hour", -1);
620                    int minute = ParamUtil.getInteger(request, param + "Minute");
621    
622                    int amPm = ParamUtil.getInteger(request, param + "AmPm");
623    
624                    if (amPm == Calendar.PM) {
625                            hour += 12;
626                    }
627    
628                    if (hour == -1) {
629                            return PortalUtil.getDate(month, day, year);
630                    }
631    
632                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
633                            WebKeys.THEME_DISPLAY);
634    
635                    User user = themeDisplay.getUser();
636    
637                    try {
638                            return PortalUtil.getDate(
639                                    month, day, year, hour, minute, user.getTimeZone(), null);
640                    }
641                    catch (PortalException pe) {
642                            return null;
643                    }
644            }
645    
646            private static final Log _log = LogFactoryUtil.getLog(
647                    BeanPropertiesImpl.class);
648    
649    }