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