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