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.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.util.StringPool;
019    import com.liferay.portal.kernel.util.Validator;
020    import com.liferay.portal.security.auth.CompanyThreadLocal;
021    import com.liferay.portal.typeconverter.DateArrayConverter;
022    import com.liferay.portal.typeconverter.NumberArrayConverter;
023    import com.liferay.portal.typeconverter.NumberConverter;
024    import com.liferay.portlet.expando.model.ExpandoColumn;
025    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
026    import com.liferay.portlet.expando.model.ExpandoRow;
027    import com.liferay.portlet.expando.model.ExpandoTable;
028    import com.liferay.portlet.expando.model.ExpandoTableConstants;
029    import com.liferay.portlet.expando.model.ExpandoValue;
030    import com.liferay.portlet.expando.model.impl.ExpandoValueImpl;
031    import com.liferay.portlet.expando.service.base.ExpandoValueLocalServiceBaseImpl;
032    
033    import java.io.Serializable;
034    
035    import java.util.Collection;
036    import java.util.Collections;
037    import java.util.Date;
038    import java.util.HashMap;
039    import java.util.List;
040    import java.util.Locale;
041    import java.util.Map;
042    
043    import jodd.typeconverter.TypeConverterManager;
044    import jodd.typeconverter.TypeConverterManagerBean;
045    
046    /**
047     * @author Raymond Aug??
048     * @author Brian Wing Shun Chan
049     * @author Marcellus Tavares
050     */
051    public class ExpandoValueLocalServiceImpl
052            extends ExpandoValueLocalServiceBaseImpl {
053    
054            public ExpandoValueLocalServiceImpl() {
055                    TypeConverterManagerBean defaultTypeConverterManager =
056                            TypeConverterManager.getDefaultTypeConverterManager();
057    
058                    defaultTypeConverterManager.register(
059                            Date[].class,
060                            new DateArrayConverter(
061                                    defaultTypeConverterManager.getConvertBean()));
062                    defaultTypeConverterManager.register(
063                            Number.class, new NumberConverter());
064                    defaultTypeConverterManager.register(
065                            Number[].class,
066                            new NumberArrayConverter(
067                                    defaultTypeConverterManager.getConvertBean()));
068            }
069    
070            @Override
071            public ExpandoValue addValue(
072                            long classNameId, long tableId, long columnId, long classPK,
073                            String data)
074                    throws PortalException {
075    
076                    ExpandoTable table = expandoTablePersistence.findByPrimaryKey(tableId);
077    
078                    return doAddValue(
079                            table.getCompanyId(), classNameId, tableId, columnId, classPK,
080                            data);
081            }
082    
083            @Override
084            public ExpandoValue addValue(
085                            long companyId, String className, String tableName,
086                            String columnName, long classPK, boolean data)
087                    throws PortalException {
088    
089                    ExpandoTable table = expandoTableLocalService.getTable(
090                            companyId, className, tableName);
091    
092                    ExpandoColumn column = expandoColumnLocalService.getColumn(
093                            table.getTableId(), columnName);
094    
095                    ExpandoValue value = new ExpandoValueImpl();
096    
097                    value.setCompanyId(table.getCompanyId());
098                    value.setColumnId(column.getColumnId());
099                    value.setBoolean(data);
100    
101                    return expandoValueLocalService.addValue(
102                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
103                            classPK, value.getData());
104            }
105    
106            @Override
107            public ExpandoValue addValue(
108                            long companyId, String className, String tableName,
109                            String columnName, long classPK, boolean[] data)
110                    throws PortalException {
111    
112                    ExpandoTable table = expandoTableLocalService.getTable(
113                            companyId, className, tableName);
114    
115                    ExpandoColumn column = expandoColumnLocalService.getColumn(
116                            table.getTableId(), columnName);
117    
118                    ExpandoValue value = new ExpandoValueImpl();
119    
120                    value.setCompanyId(table.getCompanyId());
121                    value.setColumnId(column.getColumnId());
122                    value.setBooleanArray(data);
123    
124                    return expandoValueLocalService.addValue(
125                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
126                            classPK, value.getData());
127            }
128    
129            @Override
130            public ExpandoValue addValue(
131                            long companyId, String className, String tableName,
132                            String columnName, long classPK, Date data)
133                    throws PortalException {
134    
135                    ExpandoTable table = expandoTableLocalService.getTable(
136                            companyId, className, tableName);
137    
138                    ExpandoColumn column = expandoColumnLocalService.getColumn(
139                            table.getTableId(), columnName);
140    
141                    ExpandoValue value = new ExpandoValueImpl();
142    
143                    value.setCompanyId(table.getCompanyId());
144                    value.setColumnId(column.getColumnId());
145                    value.setDate(data);
146    
147                    return expandoValueLocalService.addValue(
148                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
149                            classPK, value.getData());
150            }
151    
152            @Override
153            public ExpandoValue addValue(
154                            long companyId, String className, String tableName,
155                            String columnName, long classPK, Date[] data)
156                    throws PortalException {
157    
158                    ExpandoTable table = expandoTableLocalService.getTable(
159                            companyId, className, tableName);
160    
161                    ExpandoColumn column = expandoColumnLocalService.getColumn(
162                            table.getTableId(), columnName);
163    
164                    ExpandoValue value = new ExpandoValueImpl();
165    
166                    value.setCompanyId(table.getCompanyId());
167                    value.setColumnId(column.getColumnId());
168                    value.setDateArray(data);
169    
170                    return expandoValueLocalService.addValue(
171                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
172                            classPK, value.getData());
173            }
174    
175            @Override
176            public ExpandoValue addValue(
177                            long companyId, String className, String tableName,
178                            String columnName, long classPK, double data)
179                    throws PortalException {
180    
181                    ExpandoTable table = expandoTableLocalService.getTable(
182                            companyId, className, tableName);
183    
184                    ExpandoColumn column = expandoColumnLocalService.getColumn(
185                            table.getTableId(), columnName);
186    
187                    ExpandoValue value = new ExpandoValueImpl();
188    
189                    value.setCompanyId(table.getCompanyId());
190                    value.setColumnId(column.getColumnId());
191                    value.setDouble(data);
192    
193                    return expandoValueLocalService.addValue(
194                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
195                            classPK, value.getData());
196            }
197    
198            @Override
199            public ExpandoValue addValue(
200                            long companyId, String className, String tableName,
201                            String columnName, long classPK, double[] data)
202                    throws PortalException {
203    
204                    ExpandoTable table = expandoTableLocalService.getTable(
205                            companyId, className, tableName);
206    
207                    ExpandoColumn column = expandoColumnLocalService.getColumn(
208                            table.getTableId(), columnName);
209    
210                    ExpandoValue value = new ExpandoValueImpl();
211    
212                    value.setCompanyId(table.getCompanyId());
213                    value.setColumnId(column.getColumnId());
214                    value.setDoubleArray(data);
215    
216                    return expandoValueLocalService.addValue(
217                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
218                            classPK, value.getData());
219            }
220    
221            @Override
222            public ExpandoValue addValue(
223                            long companyId, String className, String tableName,
224                            String columnName, long classPK, float data)
225                    throws PortalException {
226    
227                    ExpandoTable table = expandoTableLocalService.getTable(
228                            companyId, className, tableName);
229    
230                    ExpandoColumn column = expandoColumnLocalService.getColumn(
231                            table.getTableId(), columnName);
232    
233                    ExpandoValue value = new ExpandoValueImpl();
234    
235                    value.setCompanyId(table.getCompanyId());
236                    value.setColumnId(column.getColumnId());
237                    value.setFloat(data);
238    
239                    return expandoValueLocalService.addValue(
240                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
241                            classPK, value.getData());
242            }
243    
244            @Override
245            public ExpandoValue addValue(
246                            long companyId, String className, String tableName,
247                            String columnName, long classPK, float[] data)
248                    throws PortalException {
249    
250                    ExpandoTable table = expandoTableLocalService.getTable(
251                            companyId, className, tableName);
252    
253                    ExpandoColumn column = expandoColumnLocalService.getColumn(
254                            table.getTableId(), columnName);
255    
256                    ExpandoValue value = new ExpandoValueImpl();
257    
258                    value.setCompanyId(table.getCompanyId());
259                    value.setColumnId(column.getColumnId());
260                    value.setFloatArray(data);
261    
262                    return expandoValueLocalService.addValue(
263                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
264                            classPK, value.getData());
265            }
266    
267            @Override
268            public ExpandoValue addValue(
269                            long companyId, String className, String tableName,
270                            String columnName, long classPK, int data)
271                    throws PortalException {
272    
273                    ExpandoTable table = expandoTableLocalService.getTable(
274                            companyId, className, tableName);
275    
276                    ExpandoColumn column = expandoColumnLocalService.getColumn(
277                            table.getTableId(), columnName);
278    
279                    ExpandoValue value = new ExpandoValueImpl();
280    
281                    value.setCompanyId(table.getCompanyId());
282                    value.setColumnId(column.getColumnId());
283                    value.setInteger(data);
284    
285                    return expandoValueLocalService.addValue(
286                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
287                            classPK, value.getData());
288            }
289    
290            @Override
291            public ExpandoValue addValue(
292                            long companyId, String className, String tableName,
293                            String columnName, long classPK, int[] data)
294                    throws PortalException {
295    
296                    ExpandoTable table = expandoTableLocalService.getTable(
297                            companyId, className, tableName);
298    
299                    ExpandoColumn column = expandoColumnLocalService.getColumn(
300                            table.getTableId(), columnName);
301    
302                    ExpandoValue value = new ExpandoValueImpl();
303    
304                    value.setCompanyId(table.getCompanyId());
305                    value.setColumnId(column.getColumnId());
306                    value.setIntegerArray(data);
307    
308                    return expandoValueLocalService.addValue(
309                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
310                            classPK, value.getData());
311            }
312    
313            @Override
314            public ExpandoValue addValue(
315                            long companyId, String className, String tableName,
316                            String columnName, long classPK, long data)
317                    throws PortalException {
318    
319                    ExpandoTable table = expandoTableLocalService.getTable(
320                            companyId, className, tableName);
321    
322                    ExpandoColumn column = expandoColumnLocalService.getColumn(
323                            table.getTableId(), columnName);
324    
325                    ExpandoValue value = new ExpandoValueImpl();
326    
327                    value.setCompanyId(table.getCompanyId());
328                    value.setColumnId(column.getColumnId());
329                    value.setLong(data);
330    
331                    return expandoValueLocalService.addValue(
332                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
333                            classPK, value.getData());
334            }
335    
336            @Override
337            public ExpandoValue addValue(
338                            long companyId, String className, String tableName,
339                            String columnName, long classPK, long[] data)
340                    throws PortalException {
341    
342                    ExpandoTable table = expandoTableLocalService.getTable(
343                            companyId, className, tableName);
344    
345                    ExpandoColumn column = expandoColumnLocalService.getColumn(
346                            table.getTableId(), columnName);
347    
348                    ExpandoValue value = new ExpandoValueImpl();
349    
350                    value.setCompanyId(table.getCompanyId());
351                    value.setColumnId(column.getColumnId());
352                    value.setLongArray(data);
353    
354                    return expandoValueLocalService.addValue(
355                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
356                            classPK, value.getData());
357            }
358    
359            @Override
360            public ExpandoValue addValue(
361                            long companyId, String className, String tableName,
362                            String columnName, long classPK, Map<Locale, ?> dataMap,
363                            Locale defautlLocale)
364                    throws PortalException {
365    
366                    ExpandoTable table = expandoTableLocalService.getTable(
367                            companyId, className, tableName);
368    
369                    ExpandoColumn column = expandoColumnLocalService.getColumn(
370                            table.getTableId(), columnName);
371    
372                    ExpandoValue value = new ExpandoValueImpl();
373    
374                    value.setCompanyId(table.getCompanyId());
375                    value.setColumnId(column.getColumnId());
376    
377                    int type = column.getType();
378    
379                    if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
380                            value.setStringArrayMap(
381                                    (Map<Locale, String[]>)dataMap, defautlLocale);
382                    }
383                    else {
384                            value.setStringMap((Map<Locale, String>)dataMap, defautlLocale);
385                    }
386    
387                    return expandoValueLocalService.addValue(
388                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
389                            classPK, value.getData());
390            }
391    
392            @Override
393            public ExpandoValue addValue(
394                            long companyId, String className, String tableName,
395                            String columnName, long classPK, Number data)
396                    throws PortalException {
397    
398                    ExpandoTable table = expandoTableLocalService.getTable(
399                            companyId, className, tableName);
400    
401                    ExpandoColumn column = expandoColumnLocalService.getColumn(
402                            table.getTableId(), columnName);
403    
404                    ExpandoValue value = new ExpandoValueImpl();
405    
406                    value.setCompanyId(table.getCompanyId());
407                    value.setColumnId(column.getColumnId());
408                    value.setNumber(data);
409    
410                    return expandoValueLocalService.addValue(
411                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
412                            classPK, value.getData());
413            }
414    
415            @Override
416            public ExpandoValue addValue(
417                            long companyId, String className, String tableName,
418                            String columnName, long classPK, Number[] data)
419                    throws PortalException {
420    
421                    ExpandoTable table = expandoTableLocalService.getTable(
422                            companyId, className, tableName);
423    
424                    ExpandoColumn column = expandoColumnLocalService.getColumn(
425                            table.getTableId(), columnName);
426    
427                    ExpandoValue value = new ExpandoValueImpl();
428    
429                    value.setCompanyId(table.getCompanyId());
430                    value.setColumnId(column.getColumnId());
431                    value.setNumberArray(data);
432    
433                    return expandoValueLocalService.addValue(
434                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
435                            classPK, value.getData());
436            }
437    
438            @Override
439            public ExpandoValue addValue(
440                            long companyId, String className, String tableName,
441                            String columnName, long classPK, Object data)
442                    throws PortalException {
443    
444                    ExpandoColumn column = expandoColumnLocalService.getColumn(
445                            companyId, className, tableName, columnName);
446    
447                    int type = column.getType();
448    
449                    data = convertType(type, data);
450    
451                    if (type == ExpandoColumnConstants.BOOLEAN) {
452                            return expandoValueLocalService.addValue(
453                                    companyId, className, tableName, columnName, classPK,
454                                    ((Boolean)data).booleanValue());
455                    }
456                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
457                            return expandoValueLocalService.addValue(
458                                    companyId, className, tableName, columnName, classPK,
459                                    (boolean[])data);
460                    }
461                    else if (type == ExpandoColumnConstants.DATE) {
462                            return expandoValueLocalService.addValue(
463                                    companyId, className, tableName, columnName, classPK,
464                                    (Date)data);
465                    }
466                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
467                            return expandoValueLocalService.addValue(
468                                    companyId, className, tableName, columnName, classPK,
469                                    (Date[])data);
470                    }
471                    else if (type == ExpandoColumnConstants.DOUBLE) {
472                            return expandoValueLocalService.addValue(
473                                    companyId, className, tableName, columnName, classPK,
474                                    ((Double)data).doubleValue());
475                    }
476                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
477                            return expandoValueLocalService.addValue(
478                                    companyId, className, tableName, columnName, classPK,
479                                    (double[])data);
480                    }
481                    else if (type == ExpandoColumnConstants.FLOAT) {
482                            return expandoValueLocalService.addValue(
483                                    companyId, className, tableName, columnName, classPK,
484                                    ((Float)data).floatValue());
485                    }
486                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
487                            return expandoValueLocalService.addValue(
488                                    companyId, className, tableName, columnName, classPK,
489                                    (float[])data);
490                    }
491                    else if (type == ExpandoColumnConstants.INTEGER) {
492                            return expandoValueLocalService.addValue(
493                                    companyId, className, tableName, columnName, classPK,
494                                    ((Integer)data).intValue());
495                    }
496                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
497                            return expandoValueLocalService.addValue(
498                                    companyId, className, tableName, columnName, classPK,
499                                    (int[])data);
500                    }
501                    else if (type == ExpandoColumnConstants.LONG) {
502                            return expandoValueLocalService.addValue(
503                                    companyId, className, tableName, columnName, classPK,
504                                    ((Long)data).longValue());
505                    }
506                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
507                            return expandoValueLocalService.addValue(
508                                    companyId, className, tableName, columnName, classPK,
509                                    (long[])data);
510                    }
511                    else if (type == ExpandoColumnConstants.NUMBER) {
512                            return expandoValueLocalService.addValue(
513                                    companyId, className, tableName, columnName, classPK,
514                                    (Number)data);
515                    }
516                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
517                            return expandoValueLocalService.addValue(
518                                    companyId, className, tableName, columnName, classPK,
519                                    (Number[])data);
520                    }
521                    else if (type == ExpandoColumnConstants.SHORT) {
522                            return expandoValueLocalService.addValue(
523                                    companyId, className, tableName, columnName, classPK,
524                                    ((Short)data).shortValue());
525                    }
526                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
527                            return expandoValueLocalService.addValue(
528                                    companyId, className, tableName, columnName, classPK,
529                                    (short[])data);
530                    }
531                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
532                            return expandoValueLocalService.addValue(
533                                    companyId, className, tableName, columnName, classPK,
534                                    (String[])data);
535                    }
536                    else if (type == ExpandoColumnConstants.STRING) {
537                            return expandoValueLocalService.addValue(
538                                    companyId, className, tableName, columnName, classPK,
539                                    (String)data);
540                    }
541                    else {
542                            return expandoValueLocalService.addValue(
543                                    companyId, className, tableName, columnName, classPK,
544                                    (Map<Locale, ?>)data, Locale.getDefault());
545                    }
546            }
547    
548            @Override
549            public ExpandoValue addValue(
550                            long companyId, String className, String tableName,
551                            String columnName, long classPK, short data)
552                    throws PortalException {
553    
554                    ExpandoTable table = expandoTableLocalService.getTable(
555                            companyId, className, tableName);
556    
557                    ExpandoColumn column = expandoColumnLocalService.getColumn(
558                            table.getTableId(), columnName);
559    
560                    ExpandoValue value = new ExpandoValueImpl();
561    
562                    value.setCompanyId(table.getCompanyId());
563                    value.setColumnId(column.getColumnId());
564                    value.setShort(data);
565    
566                    return expandoValueLocalService.addValue(
567                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
568                            classPK, value.getData());
569            }
570    
571            @Override
572            public ExpandoValue addValue(
573                            long companyId, String className, String tableName,
574                            String columnName, long classPK, short[] data)
575                    throws PortalException {
576    
577                    ExpandoTable table = expandoTableLocalService.getTable(
578                            companyId, className, tableName);
579    
580                    ExpandoColumn column = expandoColumnLocalService.getColumn(
581                            table.getTableId(), columnName);
582    
583                    ExpandoValue value = new ExpandoValueImpl();
584    
585                    value.setCompanyId(table.getCompanyId());
586                    value.setColumnId(column.getColumnId());
587                    value.setShortArray(data);
588    
589                    return expandoValueLocalService.addValue(
590                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
591                            classPK, value.getData());
592            }
593    
594            @Override
595            public ExpandoValue addValue(
596                            long companyId, String className, String tableName,
597                            String columnName, long classPK, String data)
598                    throws PortalException {
599    
600                    ExpandoTable table = expandoTableLocalService.getTable(
601                            companyId, className, tableName);
602    
603                    ExpandoColumn column = expandoColumnLocalService.getColumn(
604                            table.getTableId(), columnName);
605    
606                    ExpandoValue value = new ExpandoValueImpl();
607    
608                    value.setCompanyId(table.getCompanyId());
609                    value.setColumnId(column.getColumnId());
610                    value.setString(data);
611    
612                    return expandoValueLocalService.addValue(
613                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
614                            classPK, value.getData());
615            }
616    
617            @Override
618            public ExpandoValue addValue(
619                            long companyId, String className, String tableName,
620                            String columnName, long classPK, String[] data)
621                    throws PortalException {
622    
623                    ExpandoTable table = expandoTableLocalService.getTable(
624                            companyId, className, tableName);
625    
626                    ExpandoColumn column = expandoColumnLocalService.getColumn(
627                            table.getTableId(), columnName);
628    
629                    ExpandoValue value = new ExpandoValueImpl();
630    
631                    value.setCompanyId(table.getCompanyId());
632                    value.setColumnId(column.getColumnId());
633                    value.setStringArray(data);
634    
635                    return expandoValueLocalService.addValue(
636                            table.getClassNameId(), table.getTableId(), column.getColumnId(),
637                            classPK, value.getData());
638            }
639    
640            /**
641             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
642             *             String, String, long, boolean[])}
643             */
644            @Deprecated
645            @Override
646            public ExpandoValue addValue(
647                            String className, String tableName, String columnName, long classPK,
648                            boolean data)
649                    throws PortalException {
650    
651                    long companyId = CompanyThreadLocal.getCompanyId();
652    
653                    return expandoValueLocalService.addValue(
654                            companyId, className, tableName, columnName, classPK, data);
655            }
656    
657            /**
658             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
659             *             String, String, long, boolean[])}
660             */
661            @Deprecated
662            @Override
663            public ExpandoValue addValue(
664                            String className, String tableName, String columnName, long classPK,
665                            boolean[] data)
666                    throws PortalException {
667    
668                    long companyId = CompanyThreadLocal.getCompanyId();
669    
670                    return expandoValueLocalService.addValue(
671                            companyId, className, tableName, columnName, classPK, data);
672            }
673    
674            /**
675             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
676             *             String, String, long, Date[])}
677             */
678            @Deprecated
679            @Override
680            public ExpandoValue addValue(
681                            String className, String tableName, String columnName, long classPK,
682                            Date data)
683                    throws PortalException {
684    
685                    long companyId = CompanyThreadLocal.getCompanyId();
686    
687                    return expandoValueLocalService.addValue(
688                            companyId, className, tableName, columnName, classPK, data);
689            }
690    
691            /**
692             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
693             *             String, String, long, Date[])}
694             */
695            @Deprecated
696            @Override
697            public ExpandoValue addValue(
698                            String className, String tableName, String columnName, long classPK,
699                            Date[] data)
700                    throws PortalException {
701    
702                    long companyId = CompanyThreadLocal.getCompanyId();
703    
704                    return expandoValueLocalService.addValue(
705                            companyId, className, tableName, columnName, classPK, data);
706            }
707    
708            /**
709             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
710             *             String, String, long, double[])}
711             */
712            @Deprecated
713            @Override
714            public ExpandoValue addValue(
715                            String className, String tableName, String columnName, long classPK,
716                            double data)
717                    throws PortalException {
718    
719                    long companyId = CompanyThreadLocal.getCompanyId();
720    
721                    return expandoValueLocalService.addValue(
722                            companyId, className, tableName, columnName, classPK, data);
723            }
724    
725            /**
726             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
727             *             String, String, long, double[])}
728             */
729            @Deprecated
730            @Override
731            public ExpandoValue addValue(
732                            String className, String tableName, String columnName, long classPK,
733                            double[] data)
734                    throws PortalException {
735    
736                    long companyId = CompanyThreadLocal.getCompanyId();
737    
738                    return expandoValueLocalService.addValue(
739                            companyId, className, tableName, columnName, classPK, data);
740            }
741    
742            /**
743             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
744             *             String, String, long, float[])}
745             */
746            @Deprecated
747            @Override
748            public ExpandoValue addValue(
749                            String className, String tableName, String columnName, long classPK,
750                            float data)
751                    throws PortalException {
752    
753                    long companyId = CompanyThreadLocal.getCompanyId();
754    
755                    return expandoValueLocalService.addValue(
756                            companyId, className, tableName, columnName, classPK, data);
757            }
758    
759            /**
760             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
761             *             String, String, long, float[])}
762             */
763            @Deprecated
764            @Override
765            public ExpandoValue addValue(
766                            String className, String tableName, String columnName, long classPK,
767                            float[] data)
768                    throws PortalException {
769    
770                    long companyId = CompanyThreadLocal.getCompanyId();
771    
772                    return expandoValueLocalService.addValue(
773                            companyId, className, tableName, columnName, classPK, data);
774            }
775    
776            /**
777             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
778             *             String, String, long, int[])}
779             */
780            @Deprecated
781            @Override
782            public ExpandoValue addValue(
783                            String className, String tableName, String columnName, long classPK,
784                            int data)
785                    throws PortalException {
786    
787                    long companyId = CompanyThreadLocal.getCompanyId();
788    
789                    return expandoValueLocalService.addValue(
790                            companyId, className, tableName, columnName, classPK, data);
791            }
792    
793            /**
794             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
795             *             String, String, long, int[])}
796             */
797            @Deprecated
798            @Override
799            public ExpandoValue addValue(
800                            String className, String tableName, String columnName, long classPK,
801                            int[] data)
802                    throws PortalException {
803    
804                    long companyId = CompanyThreadLocal.getCompanyId();
805    
806                    return expandoValueLocalService.addValue(
807                            companyId, className, tableName, columnName, classPK, data);
808            }
809    
810            /**
811             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
812             *             String, String, long, long[])}
813             */
814            @Deprecated
815            @Override
816            public ExpandoValue addValue(
817                            String className, String tableName, String columnName, long classPK,
818                            long data)
819                    throws PortalException {
820    
821                    long companyId = CompanyThreadLocal.getCompanyId();
822    
823                    return expandoValueLocalService.addValue(
824                            companyId, className, tableName, columnName, classPK, data);
825            }
826    
827            /**
828             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
829             *             String, String, long, long[])}
830             */
831            @Deprecated
832            @Override
833            public ExpandoValue addValue(
834                            String className, String tableName, String columnName, long classPK,
835                            long[] data)
836                    throws PortalException {
837    
838                    long companyId = CompanyThreadLocal.getCompanyId();
839    
840                    return expandoValueLocalService.addValue(
841                            companyId, className, tableName, columnName, classPK, data);
842            }
843    
844            /**
845             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
846             *             String, String, long, Object)}
847             */
848            @Deprecated
849            @Override
850            public ExpandoValue addValue(
851                            String className, String tableName, String columnName, long classPK,
852                            Object data)
853                    throws PortalException {
854    
855                    long companyId = CompanyThreadLocal.getCompanyId();
856    
857                    return expandoValueLocalService.addValue(
858                            companyId, className, tableName, columnName, classPK, data);
859            }
860    
861            /**
862             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
863             *             String, String, long, short[])}
864             */
865            @Deprecated
866            @Override
867            public ExpandoValue addValue(
868                            String className, String tableName, String columnName, long classPK,
869                            short data)
870                    throws PortalException {
871    
872                    long companyId = CompanyThreadLocal.getCompanyId();
873    
874                    return expandoValueLocalService.addValue(
875                            companyId, className, tableName, columnName, classPK, data);
876            }
877    
878            /**
879             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
880             *             String, String, long, short[])}
881             */
882            @Deprecated
883            @Override
884            public ExpandoValue addValue(
885                            String className, String tableName, String columnName, long classPK,
886                            short[] data)
887                    throws PortalException {
888    
889                    long companyId = CompanyThreadLocal.getCompanyId();
890    
891                    return expandoValueLocalService.addValue(
892                            companyId, className, tableName, columnName, classPK, data);
893            }
894    
895            /**
896             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
897             *             String, String, long, String[])}
898             */
899            @Deprecated
900            @Override
901            public ExpandoValue addValue(
902                            String className, String tableName, String columnName, long classPK,
903                            String data)
904                    throws PortalException {
905    
906                    long companyId = CompanyThreadLocal.getCompanyId();
907    
908                    return expandoValueLocalService.addValue(
909                            companyId, className, tableName, columnName, classPK, data);
910            }
911    
912            /**
913             * @deprecated As of 6.1.0, replaced by {@link #addValue(long, String,
914             *             String, String, long, String[])}
915             */
916            @Deprecated
917            @Override
918            public ExpandoValue addValue(
919                            String className, String tableName, String columnName, long classPK,
920                            String[] data)
921                    throws PortalException {
922    
923                    long companyId = CompanyThreadLocal.getCompanyId();
924    
925                    return expandoValueLocalService.addValue(
926                            companyId, className, tableName, columnName, classPK, data);
927            }
928    
929            @Override
930            public void addValues(
931                            long classNameId, long tableId, List<ExpandoColumn> columns,
932                            long classPK, Map<String, String> data)
933                    throws PortalException {
934    
935                    ExpandoTable table = expandoTablePersistence.findByPrimaryKey(tableId);
936    
937                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
938    
939                    if (row == null) {
940                            long rowId = counterLocalService.increment();
941    
942                            row = expandoRowPersistence.create(rowId);
943    
944                            row.setCompanyId(table.getCompanyId());
945                            row.setTableId(tableId);
946                            row.setClassPK(classPK);
947    
948                            expandoRowPersistence.update(row);
949                    }
950    
951                    boolean rowModified = false;
952    
953                    for (ExpandoColumn column : columns) {
954                            String dataString = data.get(column.getName());
955    
956                            if (dataString == null) {
957                                    continue;
958                            }
959    
960                            ExpandoValue value = expandoValuePersistence.fetchByC_R(
961                                    column.getColumnId(), row.getRowId());
962    
963                            if (value == null) {
964                                    long valueId = counterLocalService.increment();
965    
966                                    value = expandoValuePersistence.create(valueId);
967    
968                                    value.setCompanyId(table.getCompanyId());
969                                    value.setTableId(tableId);
970                                    value.setColumnId(column.getColumnId());
971                                    value.setRowId(row.getRowId());
972                                    value.setClassNameId(classNameId);
973                                    value.setClassPK(classPK);
974                            }
975    
976                            if (value.isNew() ||
977                                    !Validator.equals(value.getData(), dataString)) {
978    
979                                    value.setData(dataString);
980    
981                                    expandoValuePersistence.update(value);
982    
983                                    rowModified = true;
984                            }
985                    }
986    
987                    if (rowModified) {
988                            row.setModifiedDate(new Date());
989    
990                            expandoRowPersistence.update(row);
991                    }
992            }
993    
994            @Override
995            public void addValues(
996                            long companyId, long classNameId, String tableName, long classPK,
997                            Map<String, Serializable> attributes)
998                    throws PortalException {
999    
1000                    ExpandoTable table = expandoTableLocalService.getTable(
1001                            companyId, classNameId, tableName);
1002    
1003                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
1004                            table.getTableId(), attributes.keySet());
1005    
1006                    ExpandoValue value = new ExpandoValueImpl();
1007    
1008                    value.setCompanyId(companyId);
1009    
1010                    for (ExpandoColumn column : columns) {
1011                            Serializable attributeValue = attributes.get(column.getName());
1012    
1013                            value.setColumn(column);
1014    
1015                            int type = column.getType();
1016    
1017                            if (type == ExpandoColumnConstants.BOOLEAN) {
1018                                    value.setBoolean((Boolean)attributeValue);
1019                            }
1020                            else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
1021                                    value.setBooleanArray((boolean[])attributeValue);
1022                            }
1023                            else if (type == ExpandoColumnConstants.DATE) {
1024                                    value.setDate((Date)attributeValue);
1025                            }
1026                            else if (type == ExpandoColumnConstants.DATE_ARRAY) {
1027                                    value.setDateArray((Date[])attributeValue);
1028                            }
1029                            else if (type == ExpandoColumnConstants.DOUBLE) {
1030                                    value.setDouble((Double)attributeValue);
1031                            }
1032                            else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
1033                                    value.setDoubleArray((double[])attributeValue);
1034                            }
1035                            else if (type == ExpandoColumnConstants.FLOAT) {
1036                                    value.setFloat((Float)attributeValue);
1037                            }
1038                            else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
1039                                    value.setFloatArray((float[])attributeValue);
1040                            }
1041                            else if (type == ExpandoColumnConstants.INTEGER) {
1042                                    value.setInteger((Integer)attributeValue);
1043                            }
1044                            else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
1045                                    value.setIntegerArray((int[])attributeValue);
1046                            }
1047                            else if (type == ExpandoColumnConstants.LONG) {
1048                                    value.setLong((Long)attributeValue);
1049                            }
1050                            else if (type == ExpandoColumnConstants.LONG_ARRAY) {
1051                                    value.setLongArray((long[])attributeValue);
1052                            }
1053                            else if (type == ExpandoColumnConstants.NUMBER) {
1054                                    value.setNumber((Number)attributeValue);
1055                            }
1056                            else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
1057                                    value.setNumberArray((Number[])attributeValue);
1058                            }
1059                            else if (type == ExpandoColumnConstants.SHORT) {
1060                                    value.setShort((Short)attributeValue);
1061                            }
1062                            else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
1063                                    value.setShortArray((short[])attributeValue);
1064                            }
1065                            else if (type == ExpandoColumnConstants.STRING_ARRAY) {
1066                                    value.setStringArray((String[])attributeValue);
1067                            }
1068                            else if (type == ExpandoColumnConstants.STRING_LOCALIZED) {
1069                                    value.setStringMap(
1070                                            (Map<Locale, String>)attributeValue, Locale.getDefault());
1071                            }
1072                            else {
1073                                    value.setString((String)attributeValue);
1074                            }
1075    
1076                            doAddValue(
1077                                    companyId, classNameId, table.getTableId(),
1078                                    column.getColumnId(), classPK, value.getData());
1079                    }
1080            }
1081    
1082            @Override
1083            public void addValues(
1084                            long companyId, String className, String tableName, long classPK,
1085                            Map<String, Serializable> attributes)
1086                    throws PortalException {
1087    
1088                    long classNameId = classNameLocalService.getClassNameId(className);
1089    
1090                    addValues(companyId, classNameId, tableName, classPK, attributes);
1091            }
1092    
1093            @Override
1094            public void deleteColumnValues(long columnId) {
1095                    List<ExpandoValue> values = expandoValuePersistence.findByColumnId(
1096                            columnId);
1097    
1098                    for (ExpandoValue value : values) {
1099                            deleteValue(value);
1100                    }
1101            }
1102    
1103            @Override
1104            public void deleteRowValues(long rowId) {
1105                    List<ExpandoValue> values = expandoValuePersistence.findByRowId(rowId);
1106    
1107                    for (ExpandoValue value : values) {
1108                            deleteValue(value);
1109                    }
1110            }
1111    
1112            @Override
1113            public void deleteTableValues(long tableId) {
1114                    List<ExpandoValue> values = expandoValuePersistence.findByTableId(
1115                            tableId);
1116    
1117                    for (ExpandoValue value : values) {
1118                            deleteValue(value);
1119                    }
1120            }
1121    
1122            @Override
1123            public void deleteValue(ExpandoValue value) {
1124                    expandoValuePersistence.remove(value);
1125            }
1126    
1127            @Override
1128            public void deleteValue(long valueId) throws PortalException {
1129                    ExpandoValue value = expandoValuePersistence.findByPrimaryKey(valueId);
1130    
1131                    deleteValue(value);
1132            }
1133    
1134            @Override
1135            public void deleteValue(long columnId, long rowId) throws PortalException {
1136                    ExpandoValue value = expandoValuePersistence.findByC_R(columnId, rowId);
1137    
1138                    deleteValue(value);
1139            }
1140    
1141            @Override
1142            public void deleteValue(
1143                            long companyId, long classNameId, String tableName,
1144                            String columnName, long classPK)
1145                    throws PortalException {
1146    
1147                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1148                            companyId, classNameId, tableName);
1149    
1150                    if (table == null) {
1151                            return;
1152                    }
1153    
1154                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1155                            table.getTableId(), columnName);
1156    
1157                    if (column == null) {
1158                            return;
1159                    }
1160    
1161                    ExpandoValue value = expandoValuePersistence.fetchByT_C_C(
1162                            table.getTableId(), column.getColumnId(), classPK);
1163    
1164                    if (value != null) {
1165                            deleteValue(value.getValueId());
1166                    }
1167            }
1168    
1169            @Override
1170            public void deleteValue(
1171                            long companyId, String className, String tableName,
1172                            String columnName, long classPK)
1173                    throws PortalException {
1174    
1175                    long classNameId = classNameLocalService.getClassNameId(className);
1176    
1177                    expandoValueLocalService.deleteValue(
1178                            companyId, classNameId, tableName, columnName, classPK);
1179            }
1180    
1181            @Override
1182            public void deleteValues(long classNameId, long classPK) {
1183                    List<ExpandoValue> values = expandoValuePersistence.findByC_C(
1184                            classNameId, classPK);
1185    
1186                    for (ExpandoValue value : values) {
1187                            deleteValue(value);
1188                    }
1189            }
1190    
1191            @Override
1192            public void deleteValues(String className, long classPK) {
1193                    long classNameId = classNameLocalService.getClassNameId(className);
1194    
1195                    expandoValueLocalService.deleteValues(classNameId, classPK);
1196            }
1197    
1198            @Override
1199            public List<ExpandoValue> getColumnValues(
1200                    long columnId, int start, int end) {
1201    
1202                    return expandoValuePersistence.findByColumnId(columnId, start, end);
1203            }
1204    
1205            @Override
1206            public List<ExpandoValue> getColumnValues(
1207                    long companyId, long classNameId, String tableName, String columnName,
1208                    int start, int end) {
1209    
1210                    return expandoValueLocalService.getColumnValues(
1211                            companyId, classNameId, tableName, columnName, null, start, end);
1212            }
1213    
1214            @Override
1215            public List<ExpandoValue> getColumnValues(
1216                    long companyId, long classNameId, String tableName, String columnName,
1217                    String data, int start, int end) {
1218    
1219                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1220                            companyId, classNameId, tableName);
1221    
1222                    if (table == null) {
1223                            return Collections.emptyList();
1224                    }
1225    
1226                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1227                            table.getTableId(), columnName);
1228    
1229                    if (column == null) {
1230                            return Collections.emptyList();
1231                    }
1232    
1233                    if (data == null) {
1234                            return expandoValuePersistence.findByT_C(
1235                                    table.getTableId(), column.getColumnId(), start, end);
1236                    }
1237                    else {
1238                            return expandoValuePersistence.findByT_C_D(
1239                                    table.getTableId(), column.getColumnId(), data, start, end);
1240                    }
1241            }
1242    
1243            @Override
1244            public List<ExpandoValue> getColumnValues(
1245                    long companyId, String className, String tableName, String columnName,
1246                    int start, int end) {
1247    
1248                    long classNameId = classNameLocalService.getClassNameId(className);
1249    
1250                    return expandoValueLocalService.getColumnValues(
1251                            companyId, classNameId, tableName, columnName, start, end);
1252            }
1253    
1254            @Override
1255            public List<ExpandoValue> getColumnValues(
1256                    long companyId, String className, String tableName, String columnName,
1257                    String data, int start, int end) {
1258    
1259                    long classNameId = classNameLocalService.getClassNameId(className);
1260    
1261                    return expandoValueLocalService.getColumnValues(
1262                            companyId, classNameId, tableName, columnName, data, start, end);
1263            }
1264    
1265            /**
1266             * @deprecated As of 6.1.0, replaced by {@link #getColumnValues(long,
1267             *             String, String, String, String, int, int)}
1268             */
1269            @Deprecated
1270            @Override
1271            public List<ExpandoValue> getColumnValues(
1272                    String className, String tableName, String columnName, String data,
1273                    int start, int end) {
1274    
1275                    long companyId = CompanyThreadLocal.getCompanyId();
1276    
1277                    return expandoValueLocalService.getColumnValues(
1278                            companyId, className, tableName, columnName, data, start, end);
1279            }
1280    
1281            @Override
1282            public int getColumnValuesCount(long columnId) {
1283                    return expandoValuePersistence.countByColumnId(columnId);
1284            }
1285    
1286            @Override
1287            public int getColumnValuesCount(
1288                    long companyId, long classNameId, String tableName, String columnName) {
1289    
1290                    return expandoValueLocalService.getColumnValuesCount(
1291                            companyId, classNameId, tableName, columnName, null);
1292            }
1293    
1294            @Override
1295            public int getColumnValuesCount(
1296                    long companyId, long classNameId, String tableName, String columnName,
1297                    String data) {
1298    
1299                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1300                            companyId, classNameId, tableName);
1301    
1302                    if (table == null) {
1303                            return 0;
1304                    }
1305    
1306                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1307                            table.getTableId(), columnName);
1308    
1309                    if (column == null) {
1310                            return 0;
1311                    }
1312    
1313                    if (data == null) {
1314                            return expandoValuePersistence.countByT_C(
1315                                    table.getTableId(), column.getColumnId());
1316                    }
1317                    else {
1318                            return expandoValuePersistence.countByT_C_D(
1319                                    table.getTableId(), column.getColumnId(), data);
1320                    }
1321            }
1322    
1323            @Override
1324            public int getColumnValuesCount(
1325                    long companyId, String className, String tableName, String columnName) {
1326    
1327                    long classNameId = classNameLocalService.getClassNameId(className);
1328    
1329                    return expandoValueLocalService.getColumnValuesCount(
1330                            companyId, classNameId, tableName, columnName);
1331            }
1332    
1333            @Override
1334            public int getColumnValuesCount(
1335                    long companyId, String className, String tableName, String columnName,
1336                    String data) {
1337    
1338                    long classNameId = classNameLocalService.getClassNameId(className);
1339    
1340                    return expandoValueLocalService.getColumnValuesCount(
1341                            companyId, classNameId, tableName, columnName, data);
1342            }
1343    
1344            /**
1345             * @deprecated As of 6.1.0, replaced by {@link #getColumnValuesCount(long,
1346             *             String, String, String, String)}
1347             */
1348            @Deprecated
1349            @Override
1350            public int getColumnValuesCount(
1351                    String className, String tableName, String columnName, String data) {
1352    
1353                    long companyId = CompanyThreadLocal.getCompanyId();
1354    
1355                    return expandoValueLocalService.getColumnValuesCount(
1356                            companyId, className, tableName, columnName, data);
1357            }
1358    
1359            @Override
1360            public Map<String, Serializable> getData(
1361                            long companyId, String className, String tableName,
1362                            Collection<String> columnNames, long classPK)
1363                    throws PortalException {
1364    
1365                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
1366                            companyId, className, tableName, columnNames);
1367    
1368                    Map<String, Serializable> attributeValues = new HashMap<>(
1369                            (int)(columnNames.size() * 1.4));
1370    
1371                    ExpandoValue value = new ExpandoValueImpl();
1372    
1373                    for (ExpandoColumn column : columns) {
1374                            value.setColumn(column);
1375                            value.setData(column.getDefaultData());
1376    
1377                            Serializable attributeValue = doGetData(
1378                                    companyId, className, tableName, column.getName(), classPK,
1379                                    value, column.getType());
1380    
1381                            attributeValues.put(column.getName(), attributeValue);
1382                    }
1383    
1384                    return attributeValues;
1385            }
1386    
1387            @Override
1388            public Serializable getData(
1389                            long companyId, String className, String tableName,
1390                            String columnName, long classPK)
1391                    throws PortalException {
1392    
1393                    ExpandoColumn column = expandoColumnLocalService.getColumn(
1394                            companyId, className, tableName, columnName);
1395    
1396                    if (column == null) {
1397                            return null;
1398                    }
1399    
1400                    ExpandoValue value = new ExpandoValueImpl();
1401    
1402                    value.setColumn(column);
1403                    value.setData(column.getDefaultData());
1404    
1405                    return doGetData(
1406                            companyId, className, tableName, columnName, classPK, value,
1407                            column.getType());
1408            }
1409    
1410            @Override
1411            public boolean getData(
1412                            long companyId, String className, String tableName,
1413                            String columnName, long classPK, boolean defaultData)
1414                    throws PortalException {
1415    
1416                    ExpandoValue value = expandoValueLocalService.getValue(
1417                            companyId, className, tableName, columnName, classPK);
1418    
1419                    if (value == null) {
1420                            return defaultData;
1421                    }
1422                    else {
1423                            return value.getBoolean();
1424                    }
1425            }
1426    
1427            @Override
1428            public boolean[] getData(
1429                            long companyId, String className, String tableName,
1430                            String columnName, long classPK, boolean[] defaultData)
1431                    throws PortalException {
1432    
1433                    ExpandoValue value = expandoValueLocalService.getValue(
1434                            companyId, className, tableName, columnName, classPK);
1435    
1436                    if (value == null) {
1437                            return defaultData;
1438                    }
1439                    else {
1440                            return value.getBooleanArray();
1441                    }
1442            }
1443    
1444            @Override
1445            public Date getData(
1446                            long companyId, String className, String tableName,
1447                            String columnName, long classPK, Date defaultData)
1448                    throws PortalException {
1449    
1450                    ExpandoValue value = expandoValueLocalService.getValue(
1451                            companyId, className, tableName, columnName, classPK);
1452    
1453                    if (value == null) {
1454                            return defaultData;
1455                    }
1456                    else {
1457                            return value.getDate();
1458                    }
1459            }
1460    
1461            @Override
1462            public Date[] getData(
1463                            long companyId, String className, String tableName,
1464                            String columnName, long classPK, Date[] defaultData)
1465                    throws PortalException {
1466    
1467                    ExpandoValue value = expandoValueLocalService.getValue(
1468                            companyId, className, tableName, columnName, classPK);
1469    
1470                    if (value == null) {
1471                            return defaultData;
1472                    }
1473                    else {
1474                            return value.getDateArray();
1475                    }
1476            }
1477    
1478            @Override
1479            public double getData(
1480                            long companyId, String className, String tableName,
1481                            String columnName, long classPK, double defaultData)
1482                    throws PortalException {
1483    
1484                    ExpandoValue value = expandoValueLocalService.getValue(
1485                            companyId, className, tableName, columnName, classPK);
1486    
1487                    if (value == null) {
1488                            return defaultData;
1489                    }
1490                    else {
1491                            return value.getDouble();
1492                    }
1493            }
1494    
1495            @Override
1496            public double[] getData(
1497                            long companyId, String className, String tableName,
1498                            String columnName, long classPK, double[] defaultData)
1499                    throws PortalException {
1500    
1501                    ExpandoValue value = expandoValueLocalService.getValue(
1502                            companyId, className, tableName, columnName, classPK);
1503    
1504                    if (value == null) {
1505                            return defaultData;
1506                    }
1507                    else {
1508                            return value.getDoubleArray();
1509                    }
1510            }
1511    
1512            @Override
1513            public float getData(
1514                            long companyId, String className, String tableName,
1515                            String columnName, long classPK, float defaultData)
1516                    throws PortalException {
1517    
1518                    ExpandoValue value = expandoValueLocalService.getValue(
1519                            companyId, className, tableName, columnName, classPK);
1520    
1521                    if (value == null) {
1522                            return defaultData;
1523                    }
1524                    else {
1525                            return value.getFloat();
1526                    }
1527            }
1528    
1529            @Override
1530            public float[] getData(
1531                            long companyId, String className, String tableName,
1532                            String columnName, long classPK, float[] defaultData)
1533                    throws PortalException {
1534    
1535                    ExpandoValue value = expandoValueLocalService.getValue(
1536                            companyId, className, tableName, columnName, classPK);
1537    
1538                    if (value == null) {
1539                            return defaultData;
1540                    }
1541                    else {
1542                            return value.getFloatArray();
1543                    }
1544            }
1545    
1546            @Override
1547            public int getData(
1548                            long companyId, String className, String tableName,
1549                            String columnName, long classPK, int defaultData)
1550                    throws PortalException {
1551    
1552                    ExpandoValue value = expandoValueLocalService.getValue(
1553                            companyId, className, tableName, columnName, classPK);
1554    
1555                    if (value == null) {
1556                            return defaultData;
1557                    }
1558                    else {
1559                            return value.getInteger();
1560                    }
1561            }
1562    
1563            @Override
1564            public int[] getData(
1565                            long companyId, String className, String tableName,
1566                            String columnName, long classPK, int[] defaultData)
1567                    throws PortalException {
1568    
1569                    ExpandoValue value = expandoValueLocalService.getValue(
1570                            companyId, className, tableName, columnName, classPK);
1571    
1572                    if (value == null) {
1573                            return defaultData;
1574                    }
1575                    else {
1576                            return value.getIntegerArray();
1577                    }
1578            }
1579    
1580            @Override
1581            public long getData(
1582                            long companyId, String className, String tableName,
1583                            String columnName, long classPK, long defaultData)
1584                    throws PortalException {
1585    
1586                    ExpandoValue value = expandoValueLocalService.getValue(
1587                            companyId, className, tableName, columnName, classPK);
1588    
1589                    if (value == null) {
1590                            return defaultData;
1591                    }
1592                    else {
1593                            return value.getLong();
1594                    }
1595            }
1596    
1597            @Override
1598            public long[] getData(
1599                            long companyId, String className, String tableName,
1600                            String columnName, long classPK, long[] defaultData)
1601                    throws PortalException {
1602    
1603                    ExpandoValue value = expandoValueLocalService.getValue(
1604                            companyId, className, tableName, columnName, classPK);
1605    
1606                    if (value == null) {
1607                            return defaultData;
1608                    }
1609                    else {
1610                            return value.getLongArray();
1611                    }
1612            }
1613    
1614            @Override
1615            public Map<?, ?> getData(
1616                            long companyId, String className, String tableName,
1617                            String columnName, long classPK, Map<?, ?> defaultData)
1618                    throws PortalException {
1619    
1620                    ExpandoValue value = expandoValueLocalService.getValue(
1621                            companyId, className, tableName, columnName, classPK);
1622    
1623                    if (value == null) {
1624                            return defaultData;
1625                    }
1626    
1627                    ExpandoColumn column = value.getColumn();
1628    
1629                    int type = column.getType();
1630    
1631                    if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
1632                            return value.getStringArrayMap();
1633                    }
1634                    else {
1635                            return value.getStringMap();
1636                    }
1637            }
1638    
1639            @Override
1640            public Number getData(
1641                            long companyId, String className, String tableName,
1642                            String columnName, long classPK, Number defaultData)
1643                    throws PortalException {
1644    
1645                    ExpandoValue value = expandoValueLocalService.getValue(
1646                            companyId, className, tableName, columnName, classPK);
1647    
1648                    if (value == null) {
1649                            return defaultData;
1650                    }
1651                    else {
1652                            return value.getNumber();
1653                    }
1654            }
1655    
1656            @Override
1657            public Number[] getData(
1658                            long companyId, String className, String tableName,
1659                            String columnName, long classPK, Number[] defaultData)
1660                    throws PortalException {
1661    
1662                    ExpandoValue value = expandoValueLocalService.getValue(
1663                            companyId, className, tableName, columnName, classPK);
1664    
1665                    if (value == null) {
1666                            return defaultData;
1667                    }
1668                    else {
1669                            return value.getNumberArray();
1670                    }
1671            }
1672    
1673            @Override
1674            public short getData(
1675                            long companyId, String className, String tableName,
1676                            String columnName, long classPK, short defaultData)
1677                    throws PortalException {
1678    
1679                    ExpandoValue value = expandoValueLocalService.getValue(
1680                            companyId, className, tableName, columnName, classPK);
1681    
1682                    if (value == null) {
1683                            return defaultData;
1684                    }
1685                    else {
1686                            return value.getShort();
1687                    }
1688            }
1689    
1690            @Override
1691            public short[] getData(
1692                            long companyId, String className, String tableName,
1693                            String columnName, long classPK, short[] defaultData)
1694                    throws PortalException {
1695    
1696                    ExpandoValue value = expandoValueLocalService.getValue(
1697                            companyId, className, tableName, columnName, classPK);
1698    
1699                    if (value == null) {
1700                            return defaultData;
1701                    }
1702                    else {
1703                            return value.getShortArray();
1704                    }
1705            }
1706    
1707            @Override
1708            public String getData(
1709                            long companyId, String className, String tableName,
1710                            String columnName, long classPK, String defaultData)
1711                    throws PortalException {
1712    
1713                    ExpandoValue value = expandoValueLocalService.getValue(
1714                            companyId, className, tableName, columnName, classPK);
1715    
1716                    if (value == null) {
1717                            return defaultData;
1718                    }
1719                    else {
1720                            return value.getString();
1721                    }
1722            }
1723    
1724            @Override
1725            public String[] getData(
1726                            long companyId, String className, String tableName,
1727                            String columnName, long classPK, String[] defaultData)
1728                    throws PortalException {
1729    
1730                    ExpandoValue value = expandoValueLocalService.getValue(
1731                            companyId, className, tableName, columnName, classPK);
1732    
1733                    if (value == null) {
1734                            return defaultData;
1735                    }
1736                    else {
1737                            return value.getStringArray();
1738                    }
1739            }
1740    
1741            /**
1742             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1743             *             String, String, long)}
1744             */
1745            @Deprecated
1746            @Override
1747            public Serializable getData(
1748                            String className, String tableName, String columnName, long classPK)
1749                    throws PortalException {
1750    
1751                    long companyId = CompanyThreadLocal.getCompanyId();
1752    
1753                    return expandoValueLocalService.getData(
1754                            companyId, className, tableName, columnName, classPK);
1755            }
1756    
1757            /**
1758             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1759             *             String, String, long, boolean[])}
1760             */
1761            @Deprecated
1762            @Override
1763            public boolean getData(
1764                            String className, String tableName, String columnName, long classPK,
1765                            boolean defaultData)
1766                    throws PortalException {
1767    
1768                    long companyId = CompanyThreadLocal.getCompanyId();
1769    
1770                    return expandoValueLocalService.getData(
1771                            companyId, className, tableName, columnName, classPK, defaultData);
1772            }
1773    
1774            /**
1775             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1776             *             String, String, long, boolean[])}
1777             */
1778            @Deprecated
1779            @Override
1780            public boolean[] getData(
1781                            String className, String tableName, String columnName, long classPK,
1782                            boolean[] defaultData)
1783                    throws PortalException {
1784    
1785                    long companyId = CompanyThreadLocal.getCompanyId();
1786    
1787                    return expandoValueLocalService.getData(
1788                            companyId, className, tableName, columnName, classPK, defaultData);
1789            }
1790    
1791            /**
1792             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1793             *             String, String, long, Date[])}
1794             */
1795            @Deprecated
1796            @Override
1797            public Date getData(
1798                            String className, String tableName, String columnName, long classPK,
1799                            Date defaultData)
1800                    throws PortalException {
1801    
1802                    long companyId = CompanyThreadLocal.getCompanyId();
1803    
1804                    return expandoValueLocalService.getData(
1805                            companyId, className, tableName, columnName, classPK, defaultData);
1806            }
1807    
1808            /**
1809             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1810             *             String, String, long, Date[])}
1811             */
1812            @Deprecated
1813            @Override
1814            public Date[] getData(
1815                            String className, String tableName, String columnName, long classPK,
1816                            Date[] defaultData)
1817                    throws PortalException {
1818    
1819                    long companyId = CompanyThreadLocal.getCompanyId();
1820    
1821                    return expandoValueLocalService.getData(
1822                            companyId, className, tableName, columnName, classPK, defaultData);
1823            }
1824    
1825            /**
1826             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1827             *             String, String, long, double[])}
1828             */
1829            @Deprecated
1830            @Override
1831            public double getData(
1832                            String className, String tableName, String columnName, long classPK,
1833                            double defaultData)
1834                    throws PortalException {
1835    
1836                    long companyId = CompanyThreadLocal.getCompanyId();
1837    
1838                    return expandoValueLocalService.getData(
1839                            companyId, className, tableName, columnName, classPK, defaultData);
1840            }
1841    
1842            /**
1843             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1844             *             String, String, long, double[])}
1845             */
1846            @Deprecated
1847            @Override
1848            public double[] getData(
1849                            String className, String tableName, String columnName, long classPK,
1850                            double[] defaultData)
1851                    throws PortalException {
1852    
1853                    long companyId = CompanyThreadLocal.getCompanyId();
1854    
1855                    return expandoValueLocalService.getData(
1856                            companyId, className, tableName, columnName, classPK, defaultData);
1857            }
1858    
1859            /**
1860             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1861             *             String, String, long, float[])}
1862             */
1863            @Deprecated
1864            @Override
1865            public float getData(
1866                            String className, String tableName, String columnName, long classPK,
1867                            float defaultData)
1868                    throws PortalException {
1869    
1870                    long companyId = CompanyThreadLocal.getCompanyId();
1871    
1872                    return expandoValueLocalService.getData(
1873                            companyId, className, tableName, columnName, classPK, defaultData);
1874            }
1875    
1876            /**
1877             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1878             *             String, String, long, float[])}
1879             */
1880            @Deprecated
1881            @Override
1882            public float[] getData(
1883                            String className, String tableName, String columnName, long classPK,
1884                            float[] defaultData)
1885                    throws PortalException {
1886    
1887                    long companyId = CompanyThreadLocal.getCompanyId();
1888    
1889                    return expandoValueLocalService.getData(
1890                            companyId, className, tableName, columnName, classPK, defaultData);
1891            }
1892    
1893            /**
1894             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1895             *             String, String, long, int[])}
1896             */
1897            @Deprecated
1898            @Override
1899            public int getData(
1900                            String className, String tableName, String columnName, long classPK,
1901                            int defaultData)
1902                    throws PortalException {
1903    
1904                    long companyId = CompanyThreadLocal.getCompanyId();
1905    
1906                    return expandoValueLocalService.getData(
1907                            companyId, className, tableName, columnName, classPK, defaultData);
1908            }
1909    
1910            /**
1911             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1912             *             String, String, long, int[])}
1913             */
1914            @Deprecated
1915            @Override
1916            public int[] getData(
1917                            String className, String tableName, String columnName, long classPK,
1918                            int[] defaultData)
1919                    throws PortalException {
1920    
1921                    long companyId = CompanyThreadLocal.getCompanyId();
1922    
1923                    return expandoValueLocalService.getData(
1924                            companyId, className, tableName, columnName, classPK, defaultData);
1925            }
1926    
1927            /**
1928             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1929             *             String, String, long, long[])}
1930             */
1931            @Deprecated
1932            @Override
1933            public long getData(
1934                            String className, String tableName, String columnName, long classPK,
1935                            long defaultData)
1936                    throws PortalException {
1937    
1938                    long companyId = CompanyThreadLocal.getCompanyId();
1939    
1940                    return expandoValueLocalService.getData(
1941                            companyId, className, tableName, columnName, classPK, defaultData);
1942            }
1943    
1944            /**
1945             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1946             *             String, String, long, long[])}
1947             */
1948            @Deprecated
1949            @Override
1950            public long[] getData(
1951                            String className, String tableName, String columnName, long classPK,
1952                            long[] defaultData)
1953                    throws PortalException {
1954    
1955                    long companyId = CompanyThreadLocal.getCompanyId();
1956    
1957                    return expandoValueLocalService.getData(
1958                            companyId, className, tableName, columnName, classPK, defaultData);
1959            }
1960    
1961            /**
1962             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1963             *             String, String, long, short[])}
1964             */
1965            @Deprecated
1966            @Override
1967            public short getData(
1968                            String className, String tableName, String columnName, long classPK,
1969                            short defaultData)
1970                    throws PortalException {
1971    
1972                    long companyId = CompanyThreadLocal.getCompanyId();
1973    
1974                    return expandoValueLocalService.getData(
1975                            companyId, className, tableName, columnName, classPK, defaultData);
1976            }
1977    
1978            /**
1979             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1980             *             String, String, long, short[])}
1981             */
1982            @Deprecated
1983            @Override
1984            public short[] getData(
1985                            String className, String tableName, String columnName, long classPK,
1986                            short[] defaultData)
1987                    throws PortalException {
1988    
1989                    long companyId = CompanyThreadLocal.getCompanyId();
1990    
1991                    return expandoValueLocalService.getData(
1992                            companyId, className, tableName, columnName, classPK, defaultData);
1993            }
1994    
1995            /**
1996             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1997             *             String, String, long, String[])}
1998             */
1999            @Deprecated
2000            @Override
2001            public String getData(
2002                            String className, String tableName, String columnName, long classPK,
2003                            String defaultData)
2004                    throws PortalException {
2005    
2006                    long companyId = CompanyThreadLocal.getCompanyId();
2007    
2008                    return expandoValueLocalService.getData(
2009                            companyId, className, tableName, columnName, classPK, defaultData);
2010            }
2011    
2012            /**
2013             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
2014             *             String, String, long, String[])}
2015             */
2016            @Deprecated
2017            @Override
2018            public String[] getData(
2019                            String className, String tableName, String columnName, long classPK,
2020                            String[] defaultData)
2021                    throws PortalException {
2022    
2023                    long companyId = CompanyThreadLocal.getCompanyId();
2024    
2025                    return expandoValueLocalService.getData(
2026                            companyId, className, tableName, columnName, classPK, defaultData);
2027            }
2028    
2029            @Override
2030            public List<ExpandoValue> getDefaultTableColumnValues(
2031                    long companyId, long classNameId, String columnName, int start,
2032                    int end) {
2033    
2034                    return expandoValueLocalService.getColumnValues(
2035                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
2036                            columnName, start, end);
2037            }
2038    
2039            @Override
2040            public List<ExpandoValue> getDefaultTableColumnValues(
2041                    long companyId, String className, String columnName, int start,
2042                    int end) {
2043    
2044                    long classNameId = classNameLocalService.getClassNameId(className);
2045    
2046                    return expandoValueLocalService.getDefaultTableColumnValues(
2047                            companyId, classNameId, columnName, start, end);
2048            }
2049    
2050            @Override
2051            public int getDefaultTableColumnValuesCount(
2052                    long companyId, long classNameId, String columnName) {
2053    
2054                    return expandoValueLocalService.getColumnValuesCount(
2055                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
2056                            columnName);
2057            }
2058    
2059            @Override
2060            public int getDefaultTableColumnValuesCount(
2061                    long companyId, String className, String columnName) {
2062    
2063                    long classNameId = classNameLocalService.getClassNameId(className);
2064    
2065                    return expandoValueLocalService.getDefaultTableColumnValuesCount(
2066                            companyId, classNameId, columnName);
2067            }
2068    
2069            @Override
2070            public List<ExpandoValue> getRowValues(long rowId) {
2071                    return expandoValuePersistence.findByRowId(rowId);
2072            }
2073    
2074            @Override
2075            public List<ExpandoValue> getRowValues(long rowId, int start, int end) {
2076                    return expandoValuePersistence.findByRowId(rowId, start, end);
2077            }
2078    
2079            @Override
2080            public List<ExpandoValue> getRowValues(
2081                    long companyId, long classNameId, String tableName, long classPK,
2082                    int start, int end) {
2083    
2084                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
2085                            companyId, classNameId, tableName);
2086    
2087                    if (table == null) {
2088                            return Collections.emptyList();
2089                    }
2090    
2091                    return expandoValuePersistence.findByT_CPK(
2092                            table.getTableId(), classPK, start, end);
2093            }
2094    
2095            @Override
2096            public List<ExpandoValue> getRowValues(
2097                    long companyId, String className, String tableName, long classPK,
2098                    int start, int end) {
2099    
2100                    long classNameId = classNameLocalService.getClassNameId(className);
2101    
2102                    return expandoValueLocalService.getRowValues(
2103                            companyId, classNameId, tableName, classPK, start, end);
2104            }
2105    
2106            @Override
2107            public int getRowValuesCount(long rowId) {
2108                    return expandoValuePersistence.countByRowId(rowId);
2109            }
2110    
2111            @Override
2112            public int getRowValuesCount(
2113                    long companyId, long classNameId, String tableName, long classPK) {
2114    
2115                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
2116                            companyId, classNameId, tableName);
2117    
2118                    if (table == null) {
2119                            return 0;
2120                    }
2121    
2122                    return expandoValuePersistence.countByT_CPK(
2123                            table.getTableId(), classPK);
2124            }
2125    
2126            @Override
2127            public int getRowValuesCount(
2128                    long companyId, String className, String tableName, long classPK) {
2129    
2130                    long classNameId = classNameLocalService.getClassNameId(className);
2131    
2132                    return expandoValueLocalService.getRowValuesCount(
2133                            companyId, classNameId, tableName, classPK);
2134            }
2135    
2136            @Override
2137            public ExpandoValue getValue(long valueId) throws PortalException {
2138                    return expandoValuePersistence.findByPrimaryKey(valueId);
2139            }
2140    
2141            @Override
2142            public ExpandoValue getValue(long columnId, long rowId)
2143                    throws PortalException {
2144    
2145                    return expandoValuePersistence.findByC_R(columnId, rowId);
2146            }
2147    
2148            @Override
2149            public ExpandoValue getValue(long tableId, long columnId, long classPK) {
2150                    return expandoValuePersistence.fetchByT_C_C(tableId, columnId, classPK);
2151            }
2152    
2153            @Override
2154            public ExpandoValue getValue(
2155                    long companyId, long classNameId, String tableName, String columnName,
2156                    long classPK) {
2157    
2158                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
2159                            companyId, classNameId, tableName);
2160    
2161                    if (table == null) {
2162                            return null;
2163                    }
2164    
2165                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
2166                            table.getTableId(), columnName);
2167    
2168                    if (column == null) {
2169                            return null;
2170                    }
2171    
2172                    return expandoValuePersistence.fetchByT_C_C(
2173                            table.getTableId(), column.getColumnId(), classPK);
2174            }
2175    
2176            /**
2177             * @deprecated As of 6.1.0, replaced by {@link #getValue(long, long, String,
2178             *             String, long)}
2179             */
2180            @Deprecated
2181            @Override
2182            public ExpandoValue getValue(
2183                    long classNameId, String tableName, String columnName, long classPK) {
2184    
2185                    long companyId = CompanyThreadLocal.getCompanyId();
2186    
2187                    return expandoValueLocalService.getValue(
2188                            companyId, classNameId, tableName, columnName, classPK);
2189            }
2190    
2191            @Override
2192            public ExpandoValue getValue(
2193                    long companyId, String className, String tableName, String columnName,
2194                    long classPK) {
2195    
2196                    long classNameId = classNameLocalService.getClassNameId(className);
2197    
2198                    return expandoValueLocalService.getValue(
2199                            companyId, classNameId, tableName, columnName, classPK);
2200            }
2201    
2202            /**
2203             * @deprecated As of 6.1.0, replaced by {@link #getValue(long, String,
2204             *             String, String, long)}
2205             */
2206            @Deprecated
2207            @Override
2208            public ExpandoValue getValue(
2209                    String className, String tableName, String columnName, long classPK) {
2210    
2211                    long companyId = CompanyThreadLocal.getCompanyId();
2212    
2213                    return expandoValueLocalService.getValue(
2214                            companyId, className, tableName, columnName, classPK);
2215            }
2216    
2217            protected <T> T convertType(int type, Object data) {
2218                    if (data == null) {
2219                            return (T)data;
2220                    }
2221    
2222                    data = handleCollections(type, data);
2223                    data = handleStrings(type, data);
2224    
2225                    if (type == ExpandoColumnConstants.BOOLEAN) {
2226                            data = TypeConverterManager.convertType(data, Boolean.TYPE);
2227                    }
2228                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2229                            data = TypeConverterManager.convertType(data, boolean[].class);
2230                    }
2231                    else if (type == ExpandoColumnConstants.DATE) {
2232                            data = TypeConverterManager.convertType(data, Date.class);
2233                    }
2234                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2235                            data = TypeConverterManager.convertType(data, Date[].class);
2236                    }
2237                    else if (type == ExpandoColumnConstants.DOUBLE) {
2238                            data = TypeConverterManager.convertType(data, Double.TYPE);
2239                    }
2240                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2241                            data = TypeConverterManager.convertType(data, double[].class);
2242                    }
2243                    else if (type == ExpandoColumnConstants.FLOAT) {
2244                            data = TypeConverterManager.convertType(data, Float.TYPE);
2245                    }
2246                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2247                            data = TypeConverterManager.convertType(data, float[].class);
2248                    }
2249                    else if (type == ExpandoColumnConstants.INTEGER) {
2250                            data = TypeConverterManager.convertType(data, Integer.TYPE);
2251                    }
2252                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2253                            data = TypeConverterManager.convertType(data, int[].class);
2254                    }
2255                    else if (type == ExpandoColumnConstants.LONG) {
2256                            data = TypeConverterManager.convertType(data, Long.TYPE);
2257                    }
2258                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2259                            data = TypeConverterManager.convertType(data, long[].class);
2260                    }
2261                    else if (type == ExpandoColumnConstants.NUMBER) {
2262                            data = TypeConverterManager.convertType(data, Number.class);
2263                    }
2264                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2265                            data = TypeConverterManager.convertType(data, Number[].class);
2266                    }
2267                    else if (type == ExpandoColumnConstants.SHORT) {
2268                            data = TypeConverterManager.convertType(data, Short.TYPE);
2269                    }
2270                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2271                            data = TypeConverterManager.convertType(data, short[].class);
2272                    }
2273                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2274                            data = TypeConverterManager.convertType(data, String[].class);
2275                    }
2276    
2277                    return (T)data;
2278            }
2279    
2280            protected ExpandoValue doAddValue(
2281                    long companyId, long classNameId, long tableId, long columnId,
2282                    long classPK, String data) {
2283    
2284                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
2285    
2286                    if (row == null) {
2287                            long rowId = counterLocalService.increment();
2288    
2289                            row = expandoRowPersistence.create(rowId);
2290    
2291                            row.setCompanyId(companyId);
2292                            row.setTableId(tableId);
2293                            row.setClassPK(classPK);
2294    
2295                            expandoRowPersistence.update(row);
2296                    }
2297    
2298                    ExpandoValue value = expandoValuePersistence.fetchByC_R(
2299                            columnId, row.getRowId());
2300    
2301                    if (value == null) {
2302                            long valueId = counterLocalService.increment();
2303    
2304                            value = expandoValuePersistence.create(valueId);
2305    
2306                            value.setCompanyId(companyId);
2307                            value.setTableId(tableId);
2308                            value.setColumnId(columnId);
2309                            value.setRowId(row.getRowId());
2310                            value.setClassNameId(classNameId);
2311                            value.setClassPK(classPK);
2312                    }
2313    
2314                    if (value.isNew() || !Validator.equals(value.getData(), data)) {
2315                            value.setData(data);
2316    
2317                            expandoValuePersistence.update(value);
2318    
2319                            row.setModifiedDate(new Date());
2320    
2321                            expandoRowPersistence.update(row);
2322                    }
2323    
2324                    return value;
2325            }
2326    
2327            protected Serializable doGetData(
2328                            long companyId, String className, String tableName,
2329                            String columnName, long classPK, ExpandoValue value, int type)
2330                    throws PortalException {
2331    
2332                    if (type == ExpandoColumnConstants.BOOLEAN) {
2333                            return expandoValueLocalService.getData(
2334                                    companyId, className, tableName, columnName, classPK,
2335                                    value.getBoolean());
2336                    }
2337                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2338                            return expandoValueLocalService.getData(
2339                                    companyId, className, tableName, columnName, classPK,
2340                                    new boolean[0]);
2341                    }
2342                    else if (type == ExpandoColumnConstants.DATE) {
2343                            return expandoValueLocalService.getData(
2344                                    companyId, className, tableName, columnName, classPK,
2345                                    value.getDate());
2346                    }
2347                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2348                            return expandoValueLocalService.getData(
2349                                    companyId, className, tableName, columnName, classPK,
2350                                    new Date[0]);
2351                    }
2352                    else if (type == ExpandoColumnConstants.DOUBLE) {
2353                            return expandoValueLocalService.getData(
2354                                    companyId, className, tableName, columnName, classPK,
2355                                    value.getDouble());
2356                    }
2357                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2358                            return expandoValueLocalService.getData(
2359                                    companyId, className, tableName, columnName, classPK,
2360                                    new double[0]);
2361                    }
2362                    else if (type == ExpandoColumnConstants.FLOAT) {
2363                            return expandoValueLocalService.getData(
2364                                    companyId, className, tableName, columnName, classPK,
2365                                    value.getFloat());
2366                    }
2367                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2368                            return expandoValueLocalService.getData(
2369                                    companyId, className, tableName, columnName, classPK,
2370                                    new float[0]);
2371                    }
2372                    else if (type == ExpandoColumnConstants.INTEGER) {
2373                            return expandoValueLocalService.getData(
2374                                    companyId, className, tableName, columnName, classPK,
2375                                    value.getInteger());
2376                    }
2377                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2378                            return expandoValueLocalService.getData(
2379                                    companyId, className, tableName, columnName, classPK,
2380                                    new int[0]);
2381                    }
2382                    else if (type == ExpandoColumnConstants.LONG) {
2383                            return expandoValueLocalService.getData(
2384                                    companyId, className, tableName, columnName, classPK,
2385                                    value.getLong());
2386                    }
2387                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2388                            return expandoValueLocalService.getData(
2389                                    companyId, className, tableName, columnName, classPK,
2390                                    new long[0]);
2391                    }
2392                    else if (type == ExpandoColumnConstants.NUMBER) {
2393                            return expandoValueLocalService.getData(
2394                                    companyId, className, tableName, columnName, classPK,
2395                                    value.getNumber());
2396                    }
2397                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2398                            return expandoValueLocalService.getData(
2399                                    companyId, className, tableName, columnName, classPK,
2400                                    new Number[0]);
2401                    }
2402                    else if (type == ExpandoColumnConstants.SHORT) {
2403                            return expandoValueLocalService.getData(
2404                                    companyId, className, tableName, columnName, classPK,
2405                                    value.getShort());
2406                    }
2407                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2408                            return expandoValueLocalService.getData(
2409                                    companyId, className, tableName, columnName, classPK,
2410                                    new short[0]);
2411                    }
2412                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2413                            return expandoValueLocalService.getData(
2414                                    companyId, className, tableName, columnName, classPK,
2415                                    new String[0]);
2416                    }
2417                    else if (type == ExpandoColumnConstants.STRING) {
2418                            return expandoValueLocalService.getData(
2419                                    companyId, className, tableName, columnName, classPK,
2420                                    value.getString());
2421                    }
2422                    else {
2423                            return (Serializable)expandoValueLocalService.getData(
2424                                    companyId, className, tableName, columnName, classPK,
2425                                    new HashMap<Object, Object>());
2426                    }
2427            }
2428    
2429            protected Object handleCollections(int type, Object object) {
2430                    if (!(object instanceof Collection) || !isTypeArray(type)) {
2431                            return object;
2432                    }
2433    
2434                    Collection<?> collection = (Collection<?>)object;
2435    
2436                    return collection.toArray();
2437            }
2438    
2439            protected Object handleStrings(int type, Object object) {
2440                    if (!(object instanceof String)) {
2441                            return object;
2442                    }
2443    
2444                    String string = (String)object;
2445    
2446                    if (string.startsWith(StringPool.OPEN_BRACKET) &&
2447                            string.endsWith(StringPool.CLOSE_BRACKET)) {
2448    
2449                            string = string.substring(1, (string.length() - 1));
2450                    }
2451    
2452                    return string;
2453            }
2454    
2455            protected boolean isTypeArray(int type) {
2456                    if ((type == ExpandoColumnConstants.BOOLEAN_ARRAY) ||
2457                            (type == ExpandoColumnConstants.DATE_ARRAY) ||
2458                            (type == ExpandoColumnConstants.DOUBLE_ARRAY) ||
2459                            (type == ExpandoColumnConstants.FLOAT_ARRAY) ||
2460                            (type == ExpandoColumnConstants.INTEGER_ARRAY) ||
2461                            (type == ExpandoColumnConstants.LONG_ARRAY) ||
2462                            (type == ExpandoColumnConstants.NUMBER_ARRAY) ||
2463                            (type == ExpandoColumnConstants.SHORT_ARRAY) ||
2464                            (type == ExpandoColumnConstants.STRING_ARRAY)) {
2465    
2466                            return true;
2467                    }
2468    
2469                    return false;
2470            }
2471    
2472    }