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