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