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.expando.kernel.exception.ValueDataException;
018    import com.liferay.expando.kernel.model.ExpandoColumn;
019    import com.liferay.expando.kernel.model.ExpandoColumnConstants;
020    import com.liferay.expando.kernel.service.ExpandoColumnLocalServiceUtil;
021    import com.liferay.portal.kernel.exception.PortalException;
022    import com.liferay.portal.kernel.util.CharPool;
023    import com.liferay.portal.kernel.util.GetterUtil;
024    import com.liferay.portal.kernel.util.LocaleUtil;
025    import com.liferay.portal.kernel.util.LocalizationUtil;
026    import com.liferay.portal.kernel.util.StringBundler;
027    import com.liferay.portal.kernel.util.StringPool;
028    import com.liferay.portal.kernel.util.StringUtil;
029    import com.liferay.portal.kernel.util.Validator;
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            @Override
048            public List<Locale> getAvailableLocales() throws PortalException {
049                    if (!isColumnLocalized()) {
050                            return null;
051                    }
052    
053                    List<Locale> locales = new ArrayList<>();
054    
055                    for (String languageId :
056                                    LocalizationUtil.getAvailableLanguageIds(getData())) {
057    
058                            locales.add(LocaleUtil.fromLanguageId(languageId));
059                    }
060    
061                    return locales;
062            }
063    
064            @Override
065            public boolean getBoolean() throws PortalException {
066                    validate(ExpandoColumnConstants.BOOLEAN);
067    
068                    return GetterUtil.getBoolean(getData());
069            }
070    
071            @Override
072            public boolean[] getBooleanArray() throws PortalException {
073                    validate(ExpandoColumnConstants.BOOLEAN_ARRAY);
074    
075                    return GetterUtil.getBooleanValues(StringUtil.split(getData()));
076            }
077    
078            @Override
079            public ExpandoColumn getColumn() throws PortalException {
080                    if (_column != null) {
081                            return _column;
082                    }
083    
084                    long columnId = getColumnId();
085    
086                    if (columnId <= 0) {
087                            return null;
088                    }
089    
090                    return ExpandoColumnLocalServiceUtil.getColumn(columnId);
091            }
092    
093            @Override
094            public Date getDate() throws PortalException {
095                    validate(ExpandoColumnConstants.DATE);
096    
097                    return new Date(GetterUtil.getLong(getData()));
098            }
099    
100            @Override
101            public Date[] getDateArray() throws PortalException {
102                    validate(ExpandoColumnConstants.DATE_ARRAY);
103    
104                    String[] data = StringUtil.split(getData());
105    
106                    Date[] dateArray = new Date[data.length];
107    
108                    for (int i = 0; i < data.length; i++) {
109                            dateArray[i] = new Date(GetterUtil.getLong(data[i]));
110                    }
111    
112                    return dateArray;
113            }
114    
115            @Override
116            public Locale getDefaultLocale() throws PortalException {
117                    if (!isColumnLocalized()) {
118                            return null;
119                    }
120    
121                    String defaultLanguageId = LocalizationUtil.getDefaultLanguageId(
122                            getData());
123    
124                    return LocaleUtil.fromLanguageId(defaultLanguageId);
125            }
126    
127            @Override
128            public double getDouble() throws PortalException {
129                    validate(ExpandoColumnConstants.DOUBLE);
130    
131                    return GetterUtil.getDouble(getData());
132            }
133    
134            @Override
135            public double[] getDoubleArray() throws PortalException {
136                    validate(ExpandoColumnConstants.DOUBLE_ARRAY);
137    
138                    return GetterUtil.getDoubleValues(StringUtil.split(getData()));
139            }
140    
141            @Override
142            public float getFloat() throws PortalException {
143                    validate(ExpandoColumnConstants.FLOAT);
144    
145                    return GetterUtil.getFloat(getData());
146            }
147    
148            @Override
149            public float[] getFloatArray() throws PortalException {
150                    validate(ExpandoColumnConstants.FLOAT_ARRAY);
151    
152                    return GetterUtil.getFloatValues(StringUtil.split(getData()));
153            }
154    
155            @Override
156            public int getInteger() throws PortalException {
157                    validate(ExpandoColumnConstants.INTEGER);
158    
159                    return GetterUtil.getInteger(getData());
160            }
161    
162            @Override
163            public int[] getIntegerArray() throws PortalException {
164                    validate(ExpandoColumnConstants.INTEGER_ARRAY);
165    
166                    return GetterUtil.getIntegerValues(StringUtil.split(getData()));
167            }
168    
169            @Override
170            public long getLong() throws PortalException {
171                    validate(ExpandoColumnConstants.LONG);
172    
173                    return GetterUtil.getLong(getData());
174            }
175    
176            @Override
177            public long[] getLongArray() throws PortalException {
178                    validate(ExpandoColumnConstants.LONG_ARRAY);
179    
180                    return GetterUtil.getLongValues(StringUtil.split(getData()));
181            }
182    
183            @Override
184            public Number getNumber() throws PortalException {
185                    validate(ExpandoColumnConstants.NUMBER);
186    
187                    return GetterUtil.getNumber(getData());
188            }
189    
190            @Override
191            public Number[] getNumberArray() throws PortalException {
192                    validate(ExpandoColumnConstants.NUMBER_ARRAY);
193    
194                    return GetterUtil.getNumberValues(StringUtil.split(getData()));
195            }
196    
197            @Override
198            public Serializable getSerializable() throws PortalException {
199                    ExpandoColumn column = getColumn();
200    
201                    int type = column.getType();
202    
203                    if (type == ExpandoColumnConstants.BOOLEAN) {
204                            return getBoolean();
205                    }
206                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
207                            return getBooleanArray();
208                    }
209                    else if (type == ExpandoColumnConstants.DATE) {
210                            return getDate();
211                    }
212                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
213                            return getDateArray();
214                    }
215                    else if (type == ExpandoColumnConstants.DOUBLE) {
216                            return getDouble();
217                    }
218                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
219                            return getDoubleArray();
220                    }
221                    else if (type == ExpandoColumnConstants.FLOAT) {
222                            return getFloat();
223                    }
224                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
225                            return getFloatArray();
226                    }
227                    else if (type == ExpandoColumnConstants.INTEGER) {
228                            return getInteger();
229                    }
230                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
231                            return getIntegerArray();
232                    }
233                    else if (type == ExpandoColumnConstants.LONG) {
234                            return getLong();
235                    }
236                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
237                            return getLongArray();
238                    }
239                    else if (type == ExpandoColumnConstants.NUMBER) {
240                            return getNumber();
241                    }
242                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
243                            return getNumberArray();
244                    }
245                    else if (type == ExpandoColumnConstants.SHORT) {
246                            return getShort();
247                    }
248                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
249                            return getShortArray();
250                    }
251                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
252                            return getStringArray();
253                    }
254                    else if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
255                            return (Serializable)getStringArrayMap();
256                    }
257                    else if (type == ExpandoColumnConstants.STRING_LOCALIZED) {
258                            return (Serializable)getStringMap();
259                    }
260                    else {
261                            return getData();
262                    }
263            }
264    
265            @Override
266            public short getShort() throws PortalException {
267                    validate(ExpandoColumnConstants.SHORT);
268    
269                    return GetterUtil.getShort(getData());
270            }
271    
272            @Override
273            public short[] getShortArray() throws PortalException {
274                    validate(ExpandoColumnConstants.SHORT_ARRAY);
275    
276                    return GetterUtil.getShortValues(StringUtil.split(getData()));
277            }
278    
279            @Override
280            public String getString() throws PortalException {
281                    validate(ExpandoColumnConstants.STRING);
282    
283                    return getData();
284            }
285    
286            @Override
287            public String getString(Locale locale) throws PortalException {
288                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
289    
290                    String languageId = LocaleUtil.toLanguageId(locale);
291    
292                    return getData(languageId);
293            }
294    
295            @Override
296            public String[] getStringArray() throws PortalException {
297                    validate(ExpandoColumnConstants.STRING_ARRAY);
298    
299                    return split(getData());
300            }
301    
302            @Override
303            public String[] getStringArray(Locale locale) throws PortalException {
304                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
305    
306                    String languageId = LocaleUtil.toLanguageId(locale);
307    
308                    return split(getData(languageId));
309            }
310    
311            @Override
312            public Map<Locale, String[]> getStringArrayMap() throws PortalException {
313                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
314    
315                    Map<Locale, String> stringMap = LocalizationUtil.getLocalizationMap(
316                            getData());
317    
318                    Map<Locale, String[]> stringArrayMap = new HashMap<>(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<>();
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], CharPool.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    }