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.exception.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<>();
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<>(stringMap.size());
318    
319                    for (Map.Entry<Locale, String> entry : stringMap.entrySet()) {
320                            stringArrayMap.put(entry.getKey(), split(entry.getValue()));
321                    }
322    
323                    return stringArrayMap;
324            }
325    
326            @Override
327            public Map<Locale, String> getStringMap() throws PortalException {
328                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
329    
330                    return LocalizationUtil.getLocalizationMap(getData());
331            }
332    
333            @Override
334            public void setBoolean(boolean data) throws PortalException {
335                    validate(ExpandoColumnConstants.BOOLEAN);
336    
337                    setData(String.valueOf(data));
338            }
339    
340            @Override
341            public void setBooleanArray(boolean[] data) throws PortalException {
342                    validate(ExpandoColumnConstants.BOOLEAN_ARRAY);
343    
344                    setData(StringUtil.merge(data));
345            }
346    
347            @Override
348            public void setColumn(ExpandoColumn column) {
349                    _column = column;
350    
351                    setColumnId(_column.getColumnId());
352            }
353    
354            @Override
355            public void setDate(Date data) throws PortalException {
356                    validate(ExpandoColumnConstants.DATE);
357    
358                    setData(String.valueOf(data.getTime()));
359            }
360    
361            @Override
362            public void setDateArray(Date[] data) throws PortalException {
363                    validate(ExpandoColumnConstants.DATE_ARRAY);
364    
365                    if (data.length > 0) {
366                            StringBundler sb = new StringBundler(data.length * 2);
367    
368                            for (Date date : data) {
369                                    sb.append(date.getTime());
370                                    sb.append(StringPool.COMMA);
371                            }
372    
373                            sb.setIndex(sb.index() - 1);
374    
375                            setData(sb.toString());
376                    }
377                    else {
378                            setData(StringPool.BLANK);
379                    }
380            }
381    
382            @Override
383            public void setDouble(double data) throws PortalException {
384                    validate(ExpandoColumnConstants.DOUBLE);
385    
386                    setData(String.valueOf(data));
387            }
388    
389            @Override
390            public void setDoubleArray(double[] data) throws PortalException {
391                    validate(ExpandoColumnConstants.DOUBLE_ARRAY);
392    
393                    setData(StringUtil.merge(data));
394            }
395    
396            @Override
397            public void setFloat(float data) throws PortalException {
398                    validate(ExpandoColumnConstants.FLOAT);
399    
400                    setData(String.valueOf(data));
401            }
402    
403            @Override
404            public void setFloatArray(float[] data) throws PortalException {
405                    validate(ExpandoColumnConstants.FLOAT_ARRAY);
406    
407                    setData(StringUtil.merge(data));
408            }
409    
410            @Override
411            public void setInteger(int data) throws PortalException {
412                    validate(ExpandoColumnConstants.INTEGER);
413    
414                    setData(String.valueOf(data));
415            }
416    
417            @Override
418            public void setIntegerArray(int[] data) throws PortalException {
419                    validate(ExpandoColumnConstants.INTEGER_ARRAY);
420    
421                    setData(StringUtil.merge(data));
422            }
423    
424            @Override
425            public void setLong(long data) throws PortalException {
426                    validate(ExpandoColumnConstants.LONG);
427    
428                    setData(String.valueOf(data));
429            }
430    
431            @Override
432            public void setLongArray(long[] data) throws PortalException {
433                    validate(ExpandoColumnConstants.LONG_ARRAY);
434    
435                    setData(StringUtil.merge(data));
436            }
437    
438            @Override
439            public void setNumber(Number data) throws PortalException {
440                    validate(ExpandoColumnConstants.NUMBER);
441    
442                    setData(String.valueOf(data));
443            }
444    
445            @Override
446            public void setNumberArray(Number[] data) throws PortalException {
447                    validate(ExpandoColumnConstants.NUMBER_ARRAY);
448    
449                    setData(StringUtil.merge(data));
450            }
451    
452            @Override
453            public void setShort(short data) throws PortalException {
454                    validate(ExpandoColumnConstants.SHORT);
455    
456                    setData(String.valueOf(data));
457            }
458    
459            @Override
460            public void setShortArray(short[] data) throws PortalException {
461                    validate(ExpandoColumnConstants.SHORT_ARRAY);
462    
463                    setData(StringUtil.merge(data));
464            }
465    
466            @Override
467            public void setString(String data) throws PortalException {
468                    validate(ExpandoColumnConstants.STRING);
469    
470                    setData(data);
471            }
472    
473            @Override
474            public void setString(String data, Locale locale, Locale defaultLocale)
475                    throws PortalException {
476    
477                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
478    
479                    doSetString(data, locale, defaultLocale);
480            }
481    
482            @Override
483            public void setStringArray(String[] data) throws PortalException {
484                    validate(ExpandoColumnConstants.STRING_ARRAY);
485    
486                    setData(merge(data));
487            }
488    
489            @Override
490            public void setStringArray(
491                            String[] data, Locale locale, Locale defaultLocale)
492                    throws PortalException {
493    
494                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
495    
496                    doSetString(merge(data), locale, defaultLocale);
497            }
498    
499            @Override
500            public void setStringArrayMap(
501                            Map<Locale, String[]> dataMap, Locale defaultLocale)
502                    throws PortalException {
503    
504                    validate(ExpandoColumnConstants.STRING_ARRAY_LOCALIZED);
505    
506                    Map<Locale, String> stringMap = new HashMap<>();
507    
508                    for (Map.Entry<Locale, String[]> entry : dataMap.entrySet()) {
509                            stringMap.put(entry.getKey(), merge(entry.getValue()));
510                    }
511    
512                    doSetStringMap(stringMap, defaultLocale);
513            }
514    
515            @Override
516            public void setStringMap(Map<Locale, String> dataMap, Locale defaultLocale)
517                    throws PortalException {
518    
519                    validate(ExpandoColumnConstants.STRING_LOCALIZED);
520    
521                    doSetStringMap(dataMap, defaultLocale);
522            }
523    
524            protected void doSetString(
525                    String data, Locale locale, Locale defaultLocale) {
526    
527                    String languageId = LocaleUtil.toLanguageId(locale);
528                    String defaultLanguageId = LocaleUtil.toLanguageId(defaultLocale);
529    
530                    if (Validator.isNotNull(data)) {
531                            data = LocalizationUtil.updateLocalization(
532                                    getData(), "Data", data, languageId, defaultLanguageId);
533                    }
534                    else {
535                            data = LocalizationUtil.removeLocalization(
536                                    getData(), "Data", languageId);
537                    }
538    
539                    setData(data);
540            }
541    
542            protected void doSetStringMap(
543                    Map<Locale, String> dataMap, Locale defaultLocale) {
544    
545                    if (dataMap == null) {
546                            return;
547                    }
548    
549                    String data = LocalizationUtil.updateLocalization(
550                            dataMap, getData(), "Data", LocaleUtil.toLanguageId(defaultLocale));
551    
552                    setData(data);
553            }
554    
555            protected String getData(String languageId) {
556                    return LocalizationUtil.getLocalization(getData(), languageId);
557            }
558    
559            protected boolean isColumnLocalized() throws PortalException {
560                    ExpandoColumn column = getColumn();
561    
562                    if (column == null) {
563                            return false;
564                    }
565    
566                    if ((column.getType() ==
567                                    ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) ||
568                            (column.getType() == ExpandoColumnConstants.STRING_LOCALIZED)) {
569    
570                            return true;
571                    }
572    
573                    return false;
574            }
575    
576            protected String merge(String[] data) {
577                    if (data != null) {
578                            for (int i = 0; i < data.length; i++) {
579                                    data[i] = StringUtil.replace(
580                                            data[i], StringPool.COMMA, _EXPANDO_COMMA);
581                            }
582                    }
583    
584                    return StringUtil.merge(data);
585            }
586    
587            protected String[] split(String data) {
588                    String[] dataArray = StringUtil.split(data);
589    
590                    for (int i = 0; i < dataArray.length; i++) {
591                            dataArray[i] = StringUtil.replace(
592                                    dataArray[i], _EXPANDO_COMMA, StringPool.COMMA);
593                    }
594    
595                    return dataArray;
596            }
597    
598            protected void validate(int type) throws PortalException {
599                    ExpandoColumn column = getColumn();
600    
601                    if (column == null) {
602                            return;
603                    }
604    
605                    if (column.getType() == type) {
606                            return;
607                    }
608    
609                    StringBundler sb = new StringBundler(6);
610    
611                    sb.append("Column ");
612                    sb.append(getColumnId());
613                    sb.append(" has type ");
614                    sb.append(ExpandoColumnConstants.getTypeLabel(column.getType()));
615                    sb.append(" and is not compatible with type ");
616                    sb.append(ExpandoColumnConstants.getTypeLabel(type));
617    
618                    throw new ValueDataException(sb.toString());
619            }
620    
621            private static final String _EXPANDO_COMMA = "[$LIFERAY_EXPANDO_COMMA$]";
622    
623            private transient ExpandoColumn _column;
624    
625    }