001    /**
002     * Copyright (c) 2000-2013 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.portlet.expando.model.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.util.GetterUtil;
020    import com.liferay.portal.kernel.util.LocaleUtil;
021    import com.liferay.portal.kernel.util.LocalizationUtil;
022    import com.liferay.portal.kernel.util.StringBundler;
023    import com.liferay.portal.kernel.util.StringPool;
024    import com.liferay.portal.kernel.util.StringUtil;
025    import com.liferay.portal.kernel.util.Validator;
026    import com.liferay.portlet.expando.ValueDataException;
027    import com.liferay.portlet.expando.model.ExpandoColumn;
028    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
029    import com.liferay.portlet.expando.service.ExpandoColumnLocalServiceUtil;
030    
031    import java.io.Serializable;
032    
033    import java.util.ArrayList;
034    import java.util.Date;
035    import java.util.HashMap;
036    import java.util.List;
037    import java.util.Locale;
038    import java.util.Map;
039    
040    /**
041     * @author Raymond Aug??
042     * @author Brian Wing Shun Chan
043     * @author Marcellus Tavares
044     */
045    public class ExpandoValueImpl extends ExpandoValueBaseImpl {
046    
047            public ExpandoValueImpl() {
048            }
049    
050            @Override
051            public List<Locale> getAvailableLocales()
052                    throws PortalException, SystemException {
053    
054                    if (!isColumnLocalized()) {
055                            return null;
056                    }
057    
058                    List<Locale> locales = new ArrayList<Locale>();
059    
060                    for (String languageId :
061                                    LocalizationUtil.getAvailableLanguageIds(getData())) {
062    
063                            locales.add(LocaleUtil.fromLanguageId(languageId));
064                    }
065    
066                    return locales;
067            }
068    
069            @Override
070            public boolean getBoolean() throws PortalException, SystemException {
071                    validate(ExpandoColumnConstants.BOOLEAN);
072    
073                    return GetterUtil.getBoolean(getData());
074            }
075    
076            @Override
077            public boolean[] getBooleanArray() throws PortalException, SystemException {
078                    validate(ExpandoColumnConstants.BOOLEAN_ARRAY);
079    
080                    return GetterUtil.getBooleanValues(StringUtil.split(getData()));
081            }
082    
083            @Override
084            public ExpandoColumn getColumn() throws PortalException, SystemException {
085                    if (_column != null) {
086                            return _column;
087                    }
088    
089                    long columnId = getColumnId();
090    
091                    if (columnId <= 0) {
092                            return null;
093                    }
094    
095                    return ExpandoColumnLocalServiceUtil.getColumn(columnId);
096            }
097    
098            @Override
099            public Date getDate() throws PortalException, SystemException {
100                    validate(ExpandoColumnConstants.DATE);
101    
102                    return new Date(GetterUtil.getLong(getData()));
103            }
104    
105            @Override
106            public Date[] getDateArray() throws PortalException, SystemException {
107                    validate(ExpandoColumnConstants.DATE_ARRAY);
108    
109                    String[] data = StringUtil.split(getData());
110    
111                    Date[] dateArray = new Date[data.length];
112    
113                    for (int i = 0; i < data.length; i++) {
114                            dateArray[i] = new Date(GetterUtil.getLong(data[i]));
115                    }
116    
117                    return dateArray;
118            }
119    
120            @Override
121            public Locale getDefaultLocale() throws PortalException, SystemException {
122                    if (!isColumnLocalized()) {
123                            return null;
124                    }
125    
126                    String defaultLanguageId = LocalizationUtil.getDefaultLanguageId(
127                            getData());
128    
129                    return LocaleUtil.fromLanguageId(defaultLanguageId);
130            }
131    
132            @Override
133            public double getDouble() throws PortalException, SystemException {
134                    validate(ExpandoColumnConstants.DOUBLE);
135    
136                    return GetterUtil.getDouble(getData());
137            }
138    
139            @Override
140            public double[] getDoubleArray() throws PortalException, SystemException {
141                    validate(ExpandoColumnConstants.DOUBLE_ARRAY);
142    
143                    return GetterUtil.getDoubleValues(StringUtil.split(getData()));
144            }
145    
146            @Override
147            public float getFloat() throws PortalException, SystemException {
148                    validate(ExpandoColumnConstants.FLOAT);
149    
150                    return GetterUtil.getFloat(getData());
151            }
152    
153            @Override
154            public float[] getFloatArray() throws PortalException, SystemException {
155                    validate(ExpandoColumnConstants.FLOAT_ARRAY);
156    
157                    return GetterUtil.getFloatValues(StringUtil.split(getData()));
158            }
159    
160            @Override
161            public int getInteger() throws PortalException, SystemException {
162                    validate(ExpandoColumnConstants.INTEGER);
163    
164                    return GetterUtil.getInteger(getData());
165            }
166    
167            @Override
168            public int[] getIntegerArray() throws PortalException, SystemException {
169                    validate(ExpandoColumnConstants.INTEGER_ARRAY);
170    
171                    return GetterUtil.getIntegerValues(StringUtil.split(getData()));
172            }
173    
174            @Override
175            public long getLong() throws PortalException, SystemException {
176                    validate(ExpandoColumnConstants.LONG);
177    
178                    return GetterUtil.getLong(getData());
179            }
180    
181            @Override
182            public long[] getLongArray() throws PortalException, SystemException {
183                    validate(ExpandoColumnConstants.LONG_ARRAY);
184    
185                    return GetterUtil.getLongValues(StringUtil.split(getData()));
186            }
187    
188            @Override
189            public Number getNumber() throws PortalException, SystemException {
190                    validate(ExpandoColumnConstants.NUMBER);
191    
192                    return GetterUtil.getNumber(getData());
193            }
194    
195            @Override
196            public Number[] getNumberArray() throws PortalException, SystemException {
197                    validate(ExpandoColumnConstants.NUMBER_ARRAY);
198    
199                    return GetterUtil.getNumberValues(StringUtil.split(getData()));
200            }
201    
202            @Override
203            public Serializable getSerializable()
204                    throws PortalException, SystemException {
205    
206                    ExpandoColumn column = getColumn();
207    
208                    int type = column.getType();
209    
210                    if (type == ExpandoColumnConstants.BOOLEAN) {
211                            return getBoolean();
212                    }
213                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
214                            return getBooleanArray();
215                    }
216                    else if (type == ExpandoColumnConstants.DATE) {
217                            return getDate();
218                    }
219                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
220                            return getDateArray();
221                    }
222                    else if (type == ExpandoColumnConstants.DOUBLE) {
223                            return getDouble();
224                    }
225                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
226                            return getDoubleArray();
227                    }
228                    else if (type == ExpandoColumnConstants.FLOAT) {
229                            return getFloat();
230                    }
231                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
232                            return getFloatArray();
233                    }
234                    else if (type == ExpandoColumnConstants.INTEGER) {
235                            return getInteger();
236                    }
237                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
238                            return getIntegerArray();
239                    }
240                    else if (type == ExpandoColumnConstants.LONG) {
241                            return getLong();
242                    }
243                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
244                            return getLongArray();
245                    }
246                    else if (type == ExpandoColumnConstants.NUMBER) {
247                            return getNumber();
248                    }
249                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
250                            return getNumberArray();
251                    }
252                    else if (type == ExpandoColumnConstants.SHORT) {
253                            return getShort();
254                    }
255                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
256                            return getShortArray();
257                    }
258                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
259                            return getStringArray();
260                    }
261                    else if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
262                            return (Serializable)getStringArrayMap();
263                    }
264                    else if (type == ExpandoColumnConstants.STRING_LOCALIZED) {
265                            return (Serializable)getStringMap();
266                    }
267                    else {
268                            return getData();
269                    }
270            }
271    
272            @Override
273            public short getShort() throws PortalException, SystemException {
274                    validate(ExpandoColumnConstants.SHORT);
275    
276                    return GetterUtil.getShort(getData());
277            }
278    
279            @Override
280            public short[] getShortArray() throws PortalException, SystemException {
281                    validate(ExpandoColumnConstants.SHORT_ARRAY);
282    
283                    return GetterUtil.getShortValues(StringUtil.split(getData()));
284            }
285    
286            @Override
287            public String getString() throws PortalException, SystemException {
288                    validate(ExpandoColumnConstants.STRING);
289    
290                    return getData();
291            }
292    
293            @Override
294            public String getString(Locale locale)
295                    throws PortalException, SystemException {
296    
297                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
298    
299                    String languageId = LocaleUtil.toLanguageId(locale);
300    
301                    return getData(languageId);
302            }
303    
304            @Override
305            public String[] getStringArray() throws PortalException, SystemException {
306                    validate(ExpandoColumnConstants.STRING_ARRAY);
307    
308                    return split(getData());
309            }
310    
311            @Override
312            public String[] getStringArray(Locale locale)
313                    throws PortalException, SystemException {
314    
315                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
316    
317                    String languageId = LocaleUtil.toLanguageId(locale);
318    
319                    return split(getData(languageId));
320            }
321    
322            @Override
323            public Map<Locale, String[]> getStringArrayMap()
324                    throws PortalException, SystemException {
325    
326                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
327    
328                    Map<Locale, String> stringMap = LocalizationUtil.getLocalizationMap(
329                            getData());
330    
331                    Map<Locale, String[]> stringArrayMap = new HashMap<Locale, String[]>(
332                            stringMap.size());
333    
334                    for (Map.Entry<Locale, String> entry : stringMap.entrySet()) {
335                            stringArrayMap.put(entry.getKey(), split(entry.getValue()));
336                    }
337    
338                    return stringArrayMap;
339            }
340    
341            @Override
342            public Map<Locale, String> getStringMap()
343                    throws PortalException, SystemException {
344    
345                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
346    
347                    return LocalizationUtil.getLocalizationMap(getData());
348            }
349    
350            @Override
351            public void setBoolean(boolean data)
352                    throws PortalException, SystemException {
353    
354                    validate(ExpandoColumnConstants.BOOLEAN);
355    
356                    setData(String.valueOf(data));
357            }
358    
359            @Override
360            public void setBooleanArray(boolean[] data)
361                    throws PortalException, SystemException {
362    
363                    validate(ExpandoColumnConstants.BOOLEAN_ARRAY);
364    
365                    setData(StringUtil.merge(data));
366            }
367    
368            @Override
369            public void setColumn(ExpandoColumn column) {
370                    _column = column;
371    
372                    setColumnId(_column.getColumnId());
373            }
374    
375            @Override
376            public void setDate(Date data) throws PortalException, SystemException {
377                    validate(ExpandoColumnConstants.DATE);
378    
379                    setData(String.valueOf(data.getTime()));
380            }
381    
382            @Override
383            public void setDateArray(Date[] data)
384                    throws PortalException, SystemException {
385    
386                    validate(ExpandoColumnConstants.DATE_ARRAY);
387    
388                    setData(StringUtil.merge(data));
389            }
390    
391            @Override
392            public void setDouble(double data) throws PortalException, SystemException {
393                    validate(ExpandoColumnConstants.DOUBLE);
394    
395                    setData(String.valueOf(data));
396            }
397    
398            @Override
399            public void setDoubleArray(double[] data)
400                    throws PortalException, SystemException {
401    
402                    validate(ExpandoColumnConstants.DOUBLE_ARRAY);
403    
404                    setData(StringUtil.merge(data));
405            }
406    
407            @Override
408            public void setFloat(float data) throws PortalException, SystemException {
409                    validate(ExpandoColumnConstants.FLOAT);
410    
411                    setData(String.valueOf(data));
412            }
413    
414            @Override
415            public void setFloatArray(float[] data)
416                    throws PortalException, SystemException {
417    
418                    validate(ExpandoColumnConstants.FLOAT_ARRAY);
419    
420                    setData(StringUtil.merge(data));
421            }
422    
423            @Override
424            public void setInteger(int data) throws PortalException, SystemException {
425                    validate(ExpandoColumnConstants.INTEGER);
426    
427                    setData(String.valueOf(data));
428            }
429    
430            @Override
431            public void setIntegerArray(int[] data)
432                    throws PortalException, SystemException {
433    
434                    validate(ExpandoColumnConstants.INTEGER_ARRAY);
435    
436                    setData(StringUtil.merge(data));
437            }
438    
439            @Override
440            public void setLong(long data) throws PortalException, SystemException {
441                    validate(ExpandoColumnConstants.LONG);
442    
443                    setData(String.valueOf(data));
444            }
445    
446            @Override
447            public void setLongArray(long[] data)
448                    throws PortalException, SystemException {
449    
450                    validate(ExpandoColumnConstants.LONG_ARRAY);
451    
452                    setData(StringUtil.merge(data));
453            }
454    
455            @Override
456            public void setNumber(Number data) throws PortalException, SystemException {
457                    validate(ExpandoColumnConstants.NUMBER);
458    
459                    setData(String.valueOf(data));
460            }
461    
462            @Override
463            public void setNumberArray(Number[] data)
464                    throws PortalException, SystemException {
465    
466                    validate(ExpandoColumnConstants.NUMBER_ARRAY);
467    
468                    setData(StringUtil.merge(data));
469            }
470    
471            @Override
472            public void setShort(short data) throws PortalException, SystemException {
473                    validate(ExpandoColumnConstants.SHORT);
474    
475                    setData(String.valueOf(data));
476            }
477    
478            @Override
479            public void setShortArray(short[] data)
480                    throws PortalException, SystemException {
481    
482                    validate(ExpandoColumnConstants.SHORT_ARRAY);
483    
484                    setData(StringUtil.merge(data));
485            }
486    
487            @Override
488            public void setString(String data) throws PortalException, SystemException {
489                    validate(ExpandoColumnConstants.STRING);
490    
491                    setData(data);
492            }
493    
494            @Override
495            public void setString(String data, Locale locale, Locale defaultLocale)
496                    throws PortalException, SystemException {
497    
498                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
499    
500                    doSetString(data, locale, defaultLocale);
501            }
502    
503            @Override
504            public void setStringArray(String[] data)
505                    throws PortalException, SystemException {
506    
507                    validate(ExpandoColumnConstants.STRING_ARRAY);
508    
509                    setData(merge(data));
510            }
511    
512            @Override
513            public void setStringArray(
514                            String[] data, Locale locale, Locale defaultLocale)
515                    throws PortalException, SystemException {
516    
517                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
518    
519                    doSetString(merge(data), locale, defaultLocale);
520            }
521    
522            @Override
523            public void setStringArrayMap(
524                            Map<Locale, String[]> dataMap, Locale defaultLocale)
525                    throws PortalException, SystemException {
526    
527                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
528    
529                    Map<Locale, String> stringMap = new HashMap<Locale, String>();
530    
531                    for (Map.Entry<Locale, String[]> entry : dataMap.entrySet()) {
532                            stringMap.put(entry.getKey(), merge(entry.getValue()));
533                    }
534    
535                    doSetStringMap(stringMap, defaultLocale);
536            }
537    
538            @Override
539            public void setStringMap(Map<Locale, String> dataMap, Locale defaultLocale)
540                    throws PortalException, SystemException {
541    
542                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
543    
544                    doSetStringMap(dataMap, defaultLocale);
545            }
546    
547            protected void doSetString(
548                    String data, Locale locale, Locale defaultLocale) {
549    
550                    String languageId = LocaleUtil.toLanguageId(locale);
551                    String defaultLanguageId = LocaleUtil.toLanguageId(defaultLocale);
552    
553                    if (Validator.isNotNull(data)) {
554                            data = LocalizationUtil.updateLocalization(
555                                    getData(), "Data", data, languageId, defaultLanguageId);
556                    }
557                    else {
558                            data = LocalizationUtil.removeLocalization(
559                                    getData(), "Data", languageId);
560                    }
561    
562                    setData(data);
563            }
564    
565            protected void doSetStringMap(
566                    Map<Locale, String> dataMap, Locale defaultLocale) {
567    
568                    if (dataMap == null) {
569                            return;
570                    }
571    
572                    String data = LocalizationUtil.updateLocalization(
573                            dataMap, getData(), "Data", LocaleUtil.toLanguageId(defaultLocale));
574    
575                    setData(data);
576            }
577    
578            protected String getData(String languageId) {
579                    return LocalizationUtil.getLocalization(getData(), languageId);
580            }
581    
582            protected boolean isColumnLocalized()
583                    throws PortalException, SystemException {
584    
585                    ExpandoColumn column = getColumn();
586    
587                    if (column == null) {
588                            return false;
589                    }
590    
591                    if ((column.getType() ==
592                                    ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) ||
593                            (column.getType() == ExpandoColumnConstants.STRING_LOCALIZED)) {
594    
595                            return true;
596                    }
597    
598                    return false;
599            }
600    
601            protected String merge(String[] data) {
602                    if (data != null) {
603                            for (int i = 0; i < data.length; i++) {
604                                    data[i] = StringUtil.replace(
605                                            data[i], StringPool.COMMA, _EXPANDO_COMMA);
606                            }
607                    }
608    
609                    return StringUtil.merge(data);
610            }
611    
612            protected String[] split(String data) {
613                    String[] dataArray = StringUtil.split(data);
614    
615                    for (int i = 0; i < dataArray.length; i++) {
616                            dataArray[i] = StringUtil.replace(
617                                    dataArray[i], _EXPANDO_COMMA, StringPool.COMMA);
618                    }
619    
620                    return dataArray;
621            }
622    
623            protected void validate(int type) throws PortalException, SystemException {
624                    ExpandoColumn column = getColumn();
625    
626                    if (column == null) {
627                            return;
628                    }
629    
630                    if (column.getType() == type) {
631                            return;
632                    }
633    
634                    StringBundler sb = new StringBundler(6);
635    
636                    sb.append("Column ");
637                    sb.append(getColumnId());
638                    sb.append(" has type ");
639                    sb.append(ExpandoColumnConstants.getTypeLabel(column.getType()));
640                    sb.append(" and is not compatible with type ");
641                    sb.append(ExpandoColumnConstants.getTypeLabel(type));
642    
643                    throw new ValueDataException(sb.toString());
644            }
645    
646            private static final String _EXPANDO_COMMA = "[$LIFERAY_EXPANDO_COMMA$]";
647    
648            private transient ExpandoColumn _column;
649    
650    }