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 {
1069                                    value.setString((String)attributeValue);
1070                            }
1071    
1072                            doAddValue(
1073                                    companyId, classNameId, table.getTableId(),
1074                                    column.getColumnId(), classPK, value.getData());
1075                    }
1076            }
1077    
1078            @Override
1079            public void addValues(
1080                            long companyId, String className, String tableName, long classPK,
1081                            Map<String, Serializable> attributes)
1082                    throws PortalException {
1083    
1084                    long classNameId = classNameLocalService.getClassNameId(className);
1085    
1086                    addValues(companyId, classNameId, tableName, classPK, attributes);
1087            }
1088    
1089            @Override
1090            public void deleteColumnValues(long columnId) {
1091                    List<ExpandoValue> values = expandoValuePersistence.findByColumnId(
1092                            columnId);
1093    
1094                    for (ExpandoValue value : values) {
1095                            deleteValue(value);
1096                    }
1097            }
1098    
1099            @Override
1100            public void deleteRowValues(long rowId) {
1101                    List<ExpandoValue> values = expandoValuePersistence.findByRowId(rowId);
1102    
1103                    for (ExpandoValue value : values) {
1104                            deleteValue(value);
1105                    }
1106            }
1107    
1108            @Override
1109            public void deleteTableValues(long tableId) {
1110                    List<ExpandoValue> values = expandoValuePersistence.findByTableId(
1111                            tableId);
1112    
1113                    for (ExpandoValue value : values) {
1114                            deleteValue(value);
1115                    }
1116            }
1117    
1118            @Override
1119            public void deleteValue(ExpandoValue value) {
1120                    expandoValuePersistence.remove(value);
1121            }
1122    
1123            @Override
1124            public void deleteValue(long valueId) throws PortalException {
1125                    ExpandoValue value = expandoValuePersistence.findByPrimaryKey(valueId);
1126    
1127                    deleteValue(value);
1128            }
1129    
1130            @Override
1131            public void deleteValue(long columnId, long rowId) throws PortalException {
1132                    ExpandoValue value = expandoValuePersistence.findByC_R(columnId, rowId);
1133    
1134                    deleteValue(value);
1135            }
1136    
1137            @Override
1138            public void deleteValue(
1139                            long companyId, long classNameId, String tableName,
1140                            String columnName, long classPK)
1141                    throws PortalException {
1142    
1143                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1144                            companyId, classNameId, tableName);
1145    
1146                    if (table == null) {
1147                            return;
1148                    }
1149    
1150                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1151                            table.getTableId(), columnName);
1152    
1153                    if (column == null) {
1154                            return;
1155                    }
1156    
1157                    ExpandoValue value = expandoValuePersistence.fetchByT_C_C(
1158                            table.getTableId(), column.getColumnId(), classPK);
1159    
1160                    if (value != null) {
1161                            deleteValue(value.getValueId());
1162                    }
1163            }
1164    
1165            @Override
1166            public void deleteValue(
1167                            long companyId, String className, String tableName,
1168                            String columnName, long classPK)
1169                    throws PortalException {
1170    
1171                    long classNameId = classNameLocalService.getClassNameId(className);
1172    
1173                    expandoValueLocalService.deleteValue(
1174                            companyId, classNameId, tableName, columnName, classPK);
1175            }
1176    
1177            @Override
1178            public void deleteValues(long classNameId, long classPK) {
1179                    List<ExpandoValue> values = expandoValuePersistence.findByC_C(
1180                            classNameId, classPK);
1181    
1182                    for (ExpandoValue value : values) {
1183                            deleteValue(value);
1184                    }
1185            }
1186    
1187            @Override
1188            public void deleteValues(String className, long classPK) {
1189                    long classNameId = classNameLocalService.getClassNameId(className);
1190    
1191                    expandoValueLocalService.deleteValues(classNameId, classPK);
1192            }
1193    
1194            @Override
1195            public List<ExpandoValue> getColumnValues(
1196                    long columnId, int start, int end) {
1197    
1198                    return expandoValuePersistence.findByColumnId(columnId, start, end);
1199            }
1200    
1201            @Override
1202            public List<ExpandoValue> getColumnValues(
1203                    long companyId, long classNameId, String tableName, String columnName,
1204                    int start, int end) {
1205    
1206                    return expandoValueLocalService.getColumnValues(
1207                            companyId, classNameId, tableName, columnName, null, start, end);
1208            }
1209    
1210            @Override
1211            public List<ExpandoValue> getColumnValues(
1212                    long companyId, long classNameId, String tableName, String columnName,
1213                    String data, int start, int end) {
1214    
1215                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1216                            companyId, classNameId, tableName);
1217    
1218                    if (table == null) {
1219                            return Collections.emptyList();
1220                    }
1221    
1222                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1223                            table.getTableId(), columnName);
1224    
1225                    if (column == null) {
1226                            return Collections.emptyList();
1227                    }
1228    
1229                    if (data == null) {
1230                            return expandoValuePersistence.findByT_C(
1231                                    table.getTableId(), column.getColumnId(), start, end);
1232                    }
1233                    else {
1234                            return expandoValuePersistence.findByT_C_D(
1235                                    table.getTableId(), column.getColumnId(), data, start, end);
1236                    }
1237            }
1238    
1239            @Override
1240            public List<ExpandoValue> getColumnValues(
1241                    long companyId, String className, String tableName, String columnName,
1242                    int start, int end) {
1243    
1244                    long classNameId = classNameLocalService.getClassNameId(className);
1245    
1246                    return expandoValueLocalService.getColumnValues(
1247                            companyId, classNameId, tableName, columnName, start, end);
1248            }
1249    
1250            @Override
1251            public List<ExpandoValue> getColumnValues(
1252                    long companyId, String className, String tableName, String columnName,
1253                    String data, int start, int end) {
1254    
1255                    long classNameId = classNameLocalService.getClassNameId(className);
1256    
1257                    return expandoValueLocalService.getColumnValues(
1258                            companyId, classNameId, tableName, columnName, data, start, end);
1259            }
1260    
1261            /**
1262             * @deprecated As of 6.1.0, replaced by {@link #getColumnValues(long,
1263             *             String, String, String, String, int, int)}
1264             */
1265            @Deprecated
1266            @Override
1267            public List<ExpandoValue> getColumnValues(
1268                    String className, String tableName, String columnName, String data,
1269                    int start, int end) {
1270    
1271                    long companyId = CompanyThreadLocal.getCompanyId();
1272    
1273                    return expandoValueLocalService.getColumnValues(
1274                            companyId, className, tableName, columnName, data, start, end);
1275            }
1276    
1277            @Override
1278            public int getColumnValuesCount(long columnId) {
1279                    return expandoValuePersistence.countByColumnId(columnId);
1280            }
1281    
1282            @Override
1283            public int getColumnValuesCount(
1284                    long companyId, long classNameId, String tableName, String columnName) {
1285    
1286                    return expandoValueLocalService.getColumnValuesCount(
1287                            companyId, classNameId, tableName, columnName, null);
1288            }
1289    
1290            @Override
1291            public int getColumnValuesCount(
1292                    long companyId, long classNameId, String tableName, String columnName,
1293                    String data) {
1294    
1295                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1296                            companyId, classNameId, tableName);
1297    
1298                    if (table == null) {
1299                            return 0;
1300                    }
1301    
1302                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1303                            table.getTableId(), columnName);
1304    
1305                    if (column == null) {
1306                            return 0;
1307                    }
1308    
1309                    if (data == null) {
1310                            return expandoValuePersistence.countByT_C(
1311                                    table.getTableId(), column.getColumnId());
1312                    }
1313                    else {
1314                            return expandoValuePersistence.countByT_C_D(
1315                                    table.getTableId(), column.getColumnId(), data);
1316                    }
1317            }
1318    
1319            @Override
1320            public int getColumnValuesCount(
1321                    long companyId, String className, String tableName, String columnName) {
1322    
1323                    long classNameId = classNameLocalService.getClassNameId(className);
1324    
1325                    return expandoValueLocalService.getColumnValuesCount(
1326                            companyId, classNameId, tableName, columnName);
1327            }
1328    
1329            @Override
1330            public int getColumnValuesCount(
1331                    long companyId, String className, String tableName, String columnName,
1332                    String data) {
1333    
1334                    long classNameId = classNameLocalService.getClassNameId(className);
1335    
1336                    return expandoValueLocalService.getColumnValuesCount(
1337                            companyId, classNameId, tableName, columnName, data);
1338            }
1339    
1340            /**
1341             * @deprecated As of 6.1.0, replaced by {@link #getColumnValuesCount(long,
1342             *             String, String, String, String)}
1343             */
1344            @Deprecated
1345            @Override
1346            public int getColumnValuesCount(
1347                    String className, String tableName, String columnName, String data) {
1348    
1349                    long companyId = CompanyThreadLocal.getCompanyId();
1350    
1351                    return expandoValueLocalService.getColumnValuesCount(
1352                            companyId, className, tableName, columnName, data);
1353            }
1354    
1355            @Override
1356            public Map<String, Serializable> getData(
1357                            long companyId, String className, String tableName,
1358                            Collection<String> columnNames, long classPK)
1359                    throws PortalException {
1360    
1361                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
1362                            companyId, className, tableName, columnNames);
1363    
1364                    Map<String, Serializable> attributeValues = new HashMap<>(
1365                            (int)(columnNames.size() * 1.4));
1366    
1367                    ExpandoValue value = new ExpandoValueImpl();
1368    
1369                    for (ExpandoColumn column : columns) {
1370                            value.setColumn(column);
1371                            value.setData(column.getDefaultData());
1372    
1373                            Serializable attributeValue = doGetData(
1374                                    companyId, className, tableName, column.getName(), classPK,
1375                                    value, column.getType());
1376    
1377                            attributeValues.put(column.getName(), attributeValue);
1378                    }
1379    
1380                    return attributeValues;
1381            }
1382    
1383            @Override
1384            public Serializable getData(
1385                            long companyId, String className, String tableName,
1386                            String columnName, long classPK)
1387                    throws PortalException {
1388    
1389                    ExpandoColumn column = expandoColumnLocalService.getColumn(
1390                            companyId, className, tableName, columnName);
1391    
1392                    if (column == null) {
1393                            return null;
1394                    }
1395    
1396                    ExpandoValue value = new ExpandoValueImpl();
1397    
1398                    value.setColumn(column);
1399                    value.setData(column.getDefaultData());
1400    
1401                    return doGetData(
1402                            companyId, className, tableName, columnName, classPK, value,
1403                            column.getType());
1404            }
1405    
1406            @Override
1407            public boolean getData(
1408                            long companyId, String className, String tableName,
1409                            String columnName, long classPK, boolean defaultData)
1410                    throws PortalException {
1411    
1412                    ExpandoValue value = expandoValueLocalService.getValue(
1413                            companyId, className, tableName, columnName, classPK);
1414    
1415                    if (value == null) {
1416                            return defaultData;
1417                    }
1418                    else {
1419                            return value.getBoolean();
1420                    }
1421            }
1422    
1423            @Override
1424            public boolean[] getData(
1425                            long companyId, String className, String tableName,
1426                            String columnName, long classPK, boolean[] defaultData)
1427                    throws PortalException {
1428    
1429                    ExpandoValue value = expandoValueLocalService.getValue(
1430                            companyId, className, tableName, columnName, classPK);
1431    
1432                    if (value == null) {
1433                            return defaultData;
1434                    }
1435                    else {
1436                            return value.getBooleanArray();
1437                    }
1438            }
1439    
1440            @Override
1441            public Date getData(
1442                            long companyId, String className, String tableName,
1443                            String columnName, long classPK, Date defaultData)
1444                    throws PortalException {
1445    
1446                    ExpandoValue value = expandoValueLocalService.getValue(
1447                            companyId, className, tableName, columnName, classPK);
1448    
1449                    if (value == null) {
1450                            return defaultData;
1451                    }
1452                    else {
1453                            return value.getDate();
1454                    }
1455            }
1456    
1457            @Override
1458            public Date[] getData(
1459                            long companyId, String className, String tableName,
1460                            String columnName, long classPK, Date[] defaultData)
1461                    throws PortalException {
1462    
1463                    ExpandoValue value = expandoValueLocalService.getValue(
1464                            companyId, className, tableName, columnName, classPK);
1465    
1466                    if (value == null) {
1467                            return defaultData;
1468                    }
1469                    else {
1470                            return value.getDateArray();
1471                    }
1472            }
1473    
1474            @Override
1475            public double getData(
1476                            long companyId, String className, String tableName,
1477                            String columnName, long classPK, double defaultData)
1478                    throws PortalException {
1479    
1480                    ExpandoValue value = expandoValueLocalService.getValue(
1481                            companyId, className, tableName, columnName, classPK);
1482    
1483                    if (value == null) {
1484                            return defaultData;
1485                    }
1486                    else {
1487                            return value.getDouble();
1488                    }
1489            }
1490    
1491            @Override
1492            public double[] getData(
1493                            long companyId, String className, String tableName,
1494                            String columnName, long classPK, double[] defaultData)
1495                    throws PortalException {
1496    
1497                    ExpandoValue value = expandoValueLocalService.getValue(
1498                            companyId, className, tableName, columnName, classPK);
1499    
1500                    if (value == null) {
1501                            return defaultData;
1502                    }
1503                    else {
1504                            return value.getDoubleArray();
1505                    }
1506            }
1507    
1508            @Override
1509            public float getData(
1510                            long companyId, String className, String tableName,
1511                            String columnName, long classPK, float defaultData)
1512                    throws PortalException {
1513    
1514                    ExpandoValue value = expandoValueLocalService.getValue(
1515                            companyId, className, tableName, columnName, classPK);
1516    
1517                    if (value == null) {
1518                            return defaultData;
1519                    }
1520                    else {
1521                            return value.getFloat();
1522                    }
1523            }
1524    
1525            @Override
1526            public float[] getData(
1527                            long companyId, String className, String tableName,
1528                            String columnName, long classPK, float[] defaultData)
1529                    throws PortalException {
1530    
1531                    ExpandoValue value = expandoValueLocalService.getValue(
1532                            companyId, className, tableName, columnName, classPK);
1533    
1534                    if (value == null) {
1535                            return defaultData;
1536                    }
1537                    else {
1538                            return value.getFloatArray();
1539                    }
1540            }
1541    
1542            @Override
1543            public int getData(
1544                            long companyId, String className, String tableName,
1545                            String columnName, long classPK, int defaultData)
1546                    throws PortalException {
1547    
1548                    ExpandoValue value = expandoValueLocalService.getValue(
1549                            companyId, className, tableName, columnName, classPK);
1550    
1551                    if (value == null) {
1552                            return defaultData;
1553                    }
1554                    else {
1555                            return value.getInteger();
1556                    }
1557            }
1558    
1559            @Override
1560            public int[] getData(
1561                            long companyId, String className, String tableName,
1562                            String columnName, long classPK, int[] defaultData)
1563                    throws PortalException {
1564    
1565                    ExpandoValue value = expandoValueLocalService.getValue(
1566                            companyId, className, tableName, columnName, classPK);
1567    
1568                    if (value == null) {
1569                            return defaultData;
1570                    }
1571                    else {
1572                            return value.getIntegerArray();
1573                    }
1574            }
1575    
1576            @Override
1577            public long getData(
1578                            long companyId, String className, String tableName,
1579                            String columnName, long classPK, long defaultData)
1580                    throws PortalException {
1581    
1582                    ExpandoValue value = expandoValueLocalService.getValue(
1583                            companyId, className, tableName, columnName, classPK);
1584    
1585                    if (value == null) {
1586                            return defaultData;
1587                    }
1588                    else {
1589                            return value.getLong();
1590                    }
1591            }
1592    
1593            @Override
1594            public long[] getData(
1595                            long companyId, String className, String tableName,
1596                            String columnName, long classPK, long[] defaultData)
1597                    throws PortalException {
1598    
1599                    ExpandoValue value = expandoValueLocalService.getValue(
1600                            companyId, className, tableName, columnName, classPK);
1601    
1602                    if (value == null) {
1603                            return defaultData;
1604                    }
1605                    else {
1606                            return value.getLongArray();
1607                    }
1608            }
1609    
1610            @Override
1611            public Map<?, ?> getData(
1612                            long companyId, String className, String tableName,
1613                            String columnName, long classPK, Map<?, ?> defaultData)
1614                    throws PortalException {
1615    
1616                    ExpandoValue value = expandoValueLocalService.getValue(
1617                            companyId, className, tableName, columnName, classPK);
1618    
1619                    if (value == null) {
1620                            return defaultData;
1621                    }
1622    
1623                    ExpandoColumn column = value.getColumn();
1624    
1625                    int type = column.getType();
1626    
1627                    if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
1628                            return value.getStringArrayMap();
1629                    }
1630                    else {
1631                            return value.getStringMap();
1632                    }
1633            }
1634    
1635            @Override
1636            public Number getData(
1637                            long companyId, String className, String tableName,
1638                            String columnName, long classPK, Number defaultData)
1639                    throws PortalException {
1640    
1641                    ExpandoValue value = expandoValueLocalService.getValue(
1642                            companyId, className, tableName, columnName, classPK);
1643    
1644                    if (value == null) {
1645                            return defaultData;
1646                    }
1647                    else {
1648                            return value.getNumber();
1649                    }
1650            }
1651    
1652            @Override
1653            public Number[] getData(
1654                            long companyId, String className, String tableName,
1655                            String columnName, long classPK, Number[] defaultData)
1656                    throws PortalException {
1657    
1658                    ExpandoValue value = expandoValueLocalService.getValue(
1659                            companyId, className, tableName, columnName, classPK);
1660    
1661                    if (value == null) {
1662                            return defaultData;
1663                    }
1664                    else {
1665                            return value.getNumberArray();
1666                    }
1667            }
1668    
1669            @Override
1670            public short getData(
1671                            long companyId, String className, String tableName,
1672                            String columnName, long classPK, short defaultData)
1673                    throws PortalException {
1674    
1675                    ExpandoValue value = expandoValueLocalService.getValue(
1676                            companyId, className, tableName, columnName, classPK);
1677    
1678                    if (value == null) {
1679                            return defaultData;
1680                    }
1681                    else {
1682                            return value.getShort();
1683                    }
1684            }
1685    
1686            @Override
1687            public short[] getData(
1688                            long companyId, String className, String tableName,
1689                            String columnName, long classPK, short[] defaultData)
1690                    throws PortalException {
1691    
1692                    ExpandoValue value = expandoValueLocalService.getValue(
1693                            companyId, className, tableName, columnName, classPK);
1694    
1695                    if (value == null) {
1696                            return defaultData;
1697                    }
1698                    else {
1699                            return value.getShortArray();
1700                    }
1701            }
1702    
1703            @Override
1704            public String getData(
1705                            long companyId, String className, String tableName,
1706                            String columnName, long classPK, String defaultData)
1707                    throws PortalException {
1708    
1709                    ExpandoValue value = expandoValueLocalService.getValue(
1710                            companyId, className, tableName, columnName, classPK);
1711    
1712                    if (value == null) {
1713                            return defaultData;
1714                    }
1715                    else {
1716                            return value.getString();
1717                    }
1718            }
1719    
1720            @Override
1721            public String[] getData(
1722                            long companyId, String className, String tableName,
1723                            String columnName, long classPK, String[] defaultData)
1724                    throws PortalException {
1725    
1726                    ExpandoValue value = expandoValueLocalService.getValue(
1727                            companyId, className, tableName, columnName, classPK);
1728    
1729                    if (value == null) {
1730                            return defaultData;
1731                    }
1732                    else {
1733                            return value.getStringArray();
1734                    }
1735            }
1736    
1737            /**
1738             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1739             *             String, String, long)}
1740             */
1741            @Deprecated
1742            @Override
1743            public Serializable getData(
1744                            String className, String tableName, String columnName, long classPK)
1745                    throws PortalException {
1746    
1747                    long companyId = CompanyThreadLocal.getCompanyId();
1748    
1749                    return expandoValueLocalService.getData(
1750                            companyId, className, tableName, columnName, classPK);
1751            }
1752    
1753            /**
1754             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1755             *             String, String, long, boolean[])}
1756             */
1757            @Deprecated
1758            @Override
1759            public boolean getData(
1760                            String className, String tableName, String columnName, long classPK,
1761                            boolean defaultData)
1762                    throws PortalException {
1763    
1764                    long companyId = CompanyThreadLocal.getCompanyId();
1765    
1766                    return expandoValueLocalService.getData(
1767                            companyId, className, tableName, columnName, classPK, defaultData);
1768            }
1769    
1770            /**
1771             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1772             *             String, String, long, boolean[])}
1773             */
1774            @Deprecated
1775            @Override
1776            public boolean[] getData(
1777                            String className, String tableName, String columnName, long classPK,
1778                            boolean[] defaultData)
1779                    throws PortalException {
1780    
1781                    long companyId = CompanyThreadLocal.getCompanyId();
1782    
1783                    return expandoValueLocalService.getData(
1784                            companyId, className, tableName, columnName, classPK, defaultData);
1785            }
1786    
1787            /**
1788             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1789             *             String, String, long, Date[])}
1790             */
1791            @Deprecated
1792            @Override
1793            public Date getData(
1794                            String className, String tableName, String columnName, long classPK,
1795                            Date defaultData)
1796                    throws PortalException {
1797    
1798                    long companyId = CompanyThreadLocal.getCompanyId();
1799    
1800                    return expandoValueLocalService.getData(
1801                            companyId, className, tableName, columnName, classPK, defaultData);
1802            }
1803    
1804            /**
1805             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1806             *             String, String, long, Date[])}
1807             */
1808            @Deprecated
1809            @Override
1810            public Date[] getData(
1811                            String className, String tableName, String columnName, long classPK,
1812                            Date[] defaultData)
1813                    throws PortalException {
1814    
1815                    long companyId = CompanyThreadLocal.getCompanyId();
1816    
1817                    return expandoValueLocalService.getData(
1818                            companyId, className, tableName, columnName, classPK, defaultData);
1819            }
1820    
1821            /**
1822             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1823             *             String, String, long, double[])}
1824             */
1825            @Deprecated
1826            @Override
1827            public double getData(
1828                            String className, String tableName, String columnName, long classPK,
1829                            double defaultData)
1830                    throws PortalException {
1831    
1832                    long companyId = CompanyThreadLocal.getCompanyId();
1833    
1834                    return expandoValueLocalService.getData(
1835                            companyId, className, tableName, columnName, classPK, defaultData);
1836            }
1837    
1838            /**
1839             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1840             *             String, String, long, double[])}
1841             */
1842            @Deprecated
1843            @Override
1844            public double[] getData(
1845                            String className, String tableName, String columnName, long classPK,
1846                            double[] defaultData)
1847                    throws PortalException {
1848    
1849                    long companyId = CompanyThreadLocal.getCompanyId();
1850    
1851                    return expandoValueLocalService.getData(
1852                            companyId, className, tableName, columnName, classPK, defaultData);
1853            }
1854    
1855            /**
1856             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1857             *             String, String, long, float[])}
1858             */
1859            @Deprecated
1860            @Override
1861            public float getData(
1862                            String className, String tableName, String columnName, long classPK,
1863                            float defaultData)
1864                    throws PortalException {
1865    
1866                    long companyId = CompanyThreadLocal.getCompanyId();
1867    
1868                    return expandoValueLocalService.getData(
1869                            companyId, className, tableName, columnName, classPK, defaultData);
1870            }
1871    
1872            /**
1873             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1874             *             String, String, long, float[])}
1875             */
1876            @Deprecated
1877            @Override
1878            public float[] getData(
1879                            String className, String tableName, String columnName, long classPK,
1880                            float[] defaultData)
1881                    throws PortalException {
1882    
1883                    long companyId = CompanyThreadLocal.getCompanyId();
1884    
1885                    return expandoValueLocalService.getData(
1886                            companyId, className, tableName, columnName, classPK, defaultData);
1887            }
1888    
1889            /**
1890             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1891             *             String, String, long, int[])}
1892             */
1893            @Deprecated
1894            @Override
1895            public int getData(
1896                            String className, String tableName, String columnName, long classPK,
1897                            int defaultData)
1898                    throws PortalException {
1899    
1900                    long companyId = CompanyThreadLocal.getCompanyId();
1901    
1902                    return expandoValueLocalService.getData(
1903                            companyId, className, tableName, columnName, classPK, defaultData);
1904            }
1905    
1906            /**
1907             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1908             *             String, String, long, int[])}
1909             */
1910            @Deprecated
1911            @Override
1912            public int[] getData(
1913                            String className, String tableName, String columnName, long classPK,
1914                            int[] defaultData)
1915                    throws PortalException {
1916    
1917                    long companyId = CompanyThreadLocal.getCompanyId();
1918    
1919                    return expandoValueLocalService.getData(
1920                            companyId, className, tableName, columnName, classPK, defaultData);
1921            }
1922    
1923            /**
1924             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1925             *             String, String, long, long[])}
1926             */
1927            @Deprecated
1928            @Override
1929            public long getData(
1930                            String className, String tableName, String columnName, long classPK,
1931                            long defaultData)
1932                    throws PortalException {
1933    
1934                    long companyId = CompanyThreadLocal.getCompanyId();
1935    
1936                    return expandoValueLocalService.getData(
1937                            companyId, className, tableName, columnName, classPK, defaultData);
1938            }
1939    
1940            /**
1941             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1942             *             String, String, long, long[])}
1943             */
1944            @Deprecated
1945            @Override
1946            public long[] getData(
1947                            String className, String tableName, String columnName, long classPK,
1948                            long[] defaultData)
1949                    throws PortalException {
1950    
1951                    long companyId = CompanyThreadLocal.getCompanyId();
1952    
1953                    return expandoValueLocalService.getData(
1954                            companyId, className, tableName, columnName, classPK, defaultData);
1955            }
1956    
1957            /**
1958             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1959             *             String, String, long, short[])}
1960             */
1961            @Deprecated
1962            @Override
1963            public short getData(
1964                            String className, String tableName, String columnName, long classPK,
1965                            short defaultData)
1966                    throws PortalException {
1967    
1968                    long companyId = CompanyThreadLocal.getCompanyId();
1969    
1970                    return expandoValueLocalService.getData(
1971                            companyId, className, tableName, columnName, classPK, defaultData);
1972            }
1973    
1974            /**
1975             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1976             *             String, String, long, short[])}
1977             */
1978            @Deprecated
1979            @Override
1980            public short[] getData(
1981                            String className, String tableName, String columnName, long classPK,
1982                            short[] defaultData)
1983                    throws PortalException {
1984    
1985                    long companyId = CompanyThreadLocal.getCompanyId();
1986    
1987                    return expandoValueLocalService.getData(
1988                            companyId, className, tableName, columnName, classPK, defaultData);
1989            }
1990    
1991            /**
1992             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
1993             *             String, String, long, String[])}
1994             */
1995            @Deprecated
1996            @Override
1997            public String getData(
1998                            String className, String tableName, String columnName, long classPK,
1999                            String defaultData)
2000                    throws PortalException {
2001    
2002                    long companyId = CompanyThreadLocal.getCompanyId();
2003    
2004                    return expandoValueLocalService.getData(
2005                            companyId, className, tableName, columnName, classPK, defaultData);
2006            }
2007    
2008            /**
2009             * @deprecated As of 6.1.0, replaced by {@link #getData(long, String,
2010             *             String, String, long, String[])}
2011             */
2012            @Deprecated
2013            @Override
2014            public String[] getData(
2015                            String className, String tableName, String columnName, long classPK,
2016                            String[] defaultData)
2017                    throws PortalException {
2018    
2019                    long companyId = CompanyThreadLocal.getCompanyId();
2020    
2021                    return expandoValueLocalService.getData(
2022                            companyId, className, tableName, columnName, classPK, defaultData);
2023            }
2024    
2025            @Override
2026            public List<ExpandoValue> getDefaultTableColumnValues(
2027                    long companyId, long classNameId, String columnName, int start,
2028                    int end) {
2029    
2030                    return expandoValueLocalService.getColumnValues(
2031                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
2032                            columnName, start, end);
2033            }
2034    
2035            @Override
2036            public List<ExpandoValue> getDefaultTableColumnValues(
2037                    long companyId, String className, String columnName, int start,
2038                    int end) {
2039    
2040                    long classNameId = classNameLocalService.getClassNameId(className);
2041    
2042                    return expandoValueLocalService.getDefaultTableColumnValues(
2043                            companyId, classNameId, columnName, start, end);
2044            }
2045    
2046            @Override
2047            public int getDefaultTableColumnValuesCount(
2048                    long companyId, long classNameId, String columnName) {
2049    
2050                    return expandoValueLocalService.getColumnValuesCount(
2051                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
2052                            columnName);
2053            }
2054    
2055            @Override
2056            public int getDefaultTableColumnValuesCount(
2057                    long companyId, String className, String columnName) {
2058    
2059                    long classNameId = classNameLocalService.getClassNameId(className);
2060    
2061                    return expandoValueLocalService.getDefaultTableColumnValuesCount(
2062                            companyId, classNameId, columnName);
2063            }
2064    
2065            @Override
2066            public List<ExpandoValue> getRowValues(long rowId) {
2067                    return expandoValuePersistence.findByRowId(rowId);
2068            }
2069    
2070            @Override
2071            public List<ExpandoValue> getRowValues(long rowId, int start, int end) {
2072                    return expandoValuePersistence.findByRowId(rowId, start, end);
2073            }
2074    
2075            @Override
2076            public List<ExpandoValue> getRowValues(
2077                    long companyId, long classNameId, String tableName, long classPK,
2078                    int start, int end) {
2079    
2080                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
2081                            companyId, classNameId, tableName);
2082    
2083                    if (table == null) {
2084                            return Collections.emptyList();
2085                    }
2086    
2087                    return expandoValuePersistence.findByT_CPK(
2088                            table.getTableId(), classPK, start, end);
2089            }
2090    
2091            @Override
2092            public List<ExpandoValue> getRowValues(
2093                    long companyId, String className, String tableName, long classPK,
2094                    int start, int end) {
2095    
2096                    long classNameId = classNameLocalService.getClassNameId(className);
2097    
2098                    return expandoValueLocalService.getRowValues(
2099                            companyId, classNameId, tableName, classPK, start, end);
2100            }
2101    
2102            @Override
2103            public int getRowValuesCount(long rowId) {
2104                    return expandoValuePersistence.countByRowId(rowId);
2105            }
2106    
2107            @Override
2108            public int getRowValuesCount(
2109                    long companyId, long classNameId, String tableName, long classPK) {
2110    
2111                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
2112                            companyId, classNameId, tableName);
2113    
2114                    if (table == null) {
2115                            return 0;
2116                    }
2117    
2118                    return expandoValuePersistence.countByT_CPK(
2119                            table.getTableId(), classPK);
2120            }
2121    
2122            @Override
2123            public int getRowValuesCount(
2124                    long companyId, String className, String tableName, long classPK) {
2125    
2126                    long classNameId = classNameLocalService.getClassNameId(className);
2127    
2128                    return expandoValueLocalService.getRowValuesCount(
2129                            companyId, classNameId, tableName, classPK);
2130            }
2131    
2132            @Override
2133            public ExpandoValue getValue(long valueId) throws PortalException {
2134                    return expandoValuePersistence.findByPrimaryKey(valueId);
2135            }
2136    
2137            @Override
2138            public ExpandoValue getValue(long columnId, long rowId)
2139                    throws PortalException {
2140    
2141                    return expandoValuePersistence.findByC_R(columnId, rowId);
2142            }
2143    
2144            @Override
2145            public ExpandoValue getValue(long tableId, long columnId, long classPK) {
2146                    return expandoValuePersistence.fetchByT_C_C(tableId, columnId, classPK);
2147            }
2148    
2149            @Override
2150            public ExpandoValue getValue(
2151                    long companyId, long classNameId, String tableName, String columnName,
2152                    long classPK) {
2153    
2154                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
2155                            companyId, classNameId, tableName);
2156    
2157                    if (table == null) {
2158                            return null;
2159                    }
2160    
2161                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
2162                            table.getTableId(), columnName);
2163    
2164                    if (column == null) {
2165                            return null;
2166                    }
2167    
2168                    return expandoValuePersistence.fetchByT_C_C(
2169                            table.getTableId(), column.getColumnId(), classPK);
2170            }
2171    
2172            /**
2173             * @deprecated As of 6.1.0, replaced by {@link #getValue(long, long, String,
2174             *             String, long)}
2175             */
2176            @Deprecated
2177            @Override
2178            public ExpandoValue getValue(
2179                    long classNameId, String tableName, String columnName, long classPK) {
2180    
2181                    long companyId = CompanyThreadLocal.getCompanyId();
2182    
2183                    return expandoValueLocalService.getValue(
2184                            companyId, classNameId, tableName, columnName, classPK);
2185            }
2186    
2187            @Override
2188            public ExpandoValue getValue(
2189                    long companyId, String className, String tableName, String columnName,
2190                    long classPK) {
2191    
2192                    long classNameId = classNameLocalService.getClassNameId(className);
2193    
2194                    return expandoValueLocalService.getValue(
2195                            companyId, classNameId, tableName, columnName, classPK);
2196            }
2197    
2198            /**
2199             * @deprecated As of 6.1.0, replaced by {@link #getValue(long, String,
2200             *             String, String, long)}
2201             */
2202            @Deprecated
2203            @Override
2204            public ExpandoValue getValue(
2205                    String className, String tableName, String columnName, long classPK) {
2206    
2207                    long companyId = CompanyThreadLocal.getCompanyId();
2208    
2209                    return expandoValueLocalService.getValue(
2210                            companyId, className, tableName, columnName, classPK);
2211            }
2212    
2213            protected <T> T convertType(int type, Object data) {
2214                    if (data == null) {
2215                            return (T)data;
2216                    }
2217    
2218                    data = handleCollections(type, data);
2219                    data = handleStrings(type, data);
2220    
2221                    if (type == ExpandoColumnConstants.BOOLEAN) {
2222                            data = TypeConverterManager.convertType(data, Boolean.TYPE);
2223                    }
2224                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2225                            data = TypeConverterManager.convertType(data, boolean[].class);
2226                    }
2227                    else if (type == ExpandoColumnConstants.DATE) {
2228                            data = TypeConverterManager.convertType(data, Date.class);
2229                    }
2230                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2231                            data = TypeConverterManager.convertType(data, Date[].class);
2232                    }
2233                    else if (type == ExpandoColumnConstants.DOUBLE) {
2234                            data = TypeConverterManager.convertType(data, Double.TYPE);
2235                    }
2236                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2237                            data = TypeConverterManager.convertType(data, double[].class);
2238                    }
2239                    else if (type == ExpandoColumnConstants.FLOAT) {
2240                            data = TypeConverterManager.convertType(data, Float.TYPE);
2241                    }
2242                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2243                            data = TypeConverterManager.convertType(data, float[].class);
2244                    }
2245                    else if (type == ExpandoColumnConstants.INTEGER) {
2246                            data = TypeConverterManager.convertType(data, Integer.TYPE);
2247                    }
2248                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2249                            data = TypeConverterManager.convertType(data, int[].class);
2250                    }
2251                    else if (type == ExpandoColumnConstants.LONG) {
2252                            data = TypeConverterManager.convertType(data, Long.TYPE);
2253                    }
2254                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2255                            data = TypeConverterManager.convertType(data, long[].class);
2256                    }
2257                    else if (type == ExpandoColumnConstants.NUMBER) {
2258                            data = TypeConverterManager.convertType(data, Number.class);
2259                    }
2260                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2261                            data = TypeConverterManager.convertType(data, Number[].class);
2262                    }
2263                    else if (type == ExpandoColumnConstants.SHORT) {
2264                            data = TypeConverterManager.convertType(data, Short.TYPE);
2265                    }
2266                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2267                            data = TypeConverterManager.convertType(data, short[].class);
2268                    }
2269                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2270                            data = TypeConverterManager.convertType(data, String[].class);
2271                    }
2272    
2273                    return (T)data;
2274            }
2275    
2276            protected ExpandoValue doAddValue(
2277                    long companyId, long classNameId, long tableId, long columnId,
2278                    long classPK, String data) {
2279    
2280                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
2281    
2282                    if (row == null) {
2283                            long rowId = counterLocalService.increment();
2284    
2285                            row = expandoRowPersistence.create(rowId);
2286    
2287                            row.setCompanyId(companyId);
2288                            row.setTableId(tableId);
2289                            row.setClassPK(classPK);
2290    
2291                            expandoRowPersistence.update(row);
2292                    }
2293    
2294                    ExpandoValue value = expandoValuePersistence.fetchByC_R(
2295                            columnId, row.getRowId());
2296    
2297                    if (value == null) {
2298                            long valueId = counterLocalService.increment();
2299    
2300                            value = expandoValuePersistence.create(valueId);
2301    
2302                            value.setCompanyId(companyId);
2303                            value.setTableId(tableId);
2304                            value.setColumnId(columnId);
2305                            value.setRowId(row.getRowId());
2306                            value.setClassNameId(classNameId);
2307                            value.setClassPK(classPK);
2308                    }
2309    
2310                    if (value.isNew() || !Validator.equals(value.getData(), data)) {
2311                            value.setData(data);
2312    
2313                            expandoValuePersistence.update(value);
2314    
2315                            row.setModifiedDate(new Date());
2316    
2317                            expandoRowPersistence.update(row);
2318                    }
2319    
2320                    return value;
2321            }
2322    
2323            protected Serializable doGetData(
2324                            long companyId, String className, String tableName,
2325                            String columnName, long classPK, ExpandoValue value, int type)
2326                    throws PortalException {
2327    
2328                    if (type == ExpandoColumnConstants.BOOLEAN) {
2329                            return expandoValueLocalService.getData(
2330                                    companyId, className, tableName, columnName, classPK,
2331                                    value.getBoolean());
2332                    }
2333                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2334                            return expandoValueLocalService.getData(
2335                                    companyId, className, tableName, columnName, classPK,
2336                                    new boolean[0]);
2337                    }
2338                    else if (type == ExpandoColumnConstants.DATE) {
2339                            return expandoValueLocalService.getData(
2340                                    companyId, className, tableName, columnName, classPK,
2341                                    value.getDate());
2342                    }
2343                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2344                            return expandoValueLocalService.getData(
2345                                    companyId, className, tableName, columnName, classPK,
2346                                    new Date[0]);
2347                    }
2348                    else if (type == ExpandoColumnConstants.DOUBLE) {
2349                            return expandoValueLocalService.getData(
2350                                    companyId, className, tableName, columnName, classPK,
2351                                    value.getDouble());
2352                    }
2353                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2354                            return expandoValueLocalService.getData(
2355                                    companyId, className, tableName, columnName, classPK,
2356                                    new double[0]);
2357                    }
2358                    else if (type == ExpandoColumnConstants.FLOAT) {
2359                            return expandoValueLocalService.getData(
2360                                    companyId, className, tableName, columnName, classPK,
2361                                    value.getFloat());
2362                    }
2363                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2364                            return expandoValueLocalService.getData(
2365                                    companyId, className, tableName, columnName, classPK,
2366                                    new float[0]);
2367                    }
2368                    else if (type == ExpandoColumnConstants.INTEGER) {
2369                            return expandoValueLocalService.getData(
2370                                    companyId, className, tableName, columnName, classPK,
2371                                    value.getInteger());
2372                    }
2373                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2374                            return expandoValueLocalService.getData(
2375                                    companyId, className, tableName, columnName, classPK,
2376                                    new int[0]);
2377                    }
2378                    else if (type == ExpandoColumnConstants.LONG) {
2379                            return expandoValueLocalService.getData(
2380                                    companyId, className, tableName, columnName, classPK,
2381                                    value.getLong());
2382                    }
2383                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2384                            return expandoValueLocalService.getData(
2385                                    companyId, className, tableName, columnName, classPK,
2386                                    new long[0]);
2387                    }
2388                    else if (type == ExpandoColumnConstants.NUMBER) {
2389                            return expandoValueLocalService.getData(
2390                                    companyId, className, tableName, columnName, classPK,
2391                                    value.getNumber());
2392                    }
2393                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2394                            return expandoValueLocalService.getData(
2395                                    companyId, className, tableName, columnName, classPK,
2396                                    new Number[0]);
2397                    }
2398                    else if (type == ExpandoColumnConstants.SHORT) {
2399                            return expandoValueLocalService.getData(
2400                                    companyId, className, tableName, columnName, classPK,
2401                                    value.getShort());
2402                    }
2403                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2404                            return expandoValueLocalService.getData(
2405                                    companyId, className, tableName, columnName, classPK,
2406                                    new short[0]);
2407                    }
2408                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2409                            return expandoValueLocalService.getData(
2410                                    companyId, className, tableName, columnName, classPK,
2411                                    new String[0]);
2412                    }
2413                    else if (type == ExpandoColumnConstants.STRING) {
2414                            return expandoValueLocalService.getData(
2415                                    companyId, className, tableName, columnName, classPK,
2416                                    value.getString());
2417                    }
2418                    else {
2419                            return (Serializable)expandoValueLocalService.getData(
2420                                    companyId, className, tableName, columnName, classPK,
2421                                    new HashMap<Object, Object>());
2422                    }
2423            }
2424    
2425            protected Object handleCollections(int type, Object object) {
2426                    if (!(object instanceof Collection) || !isTypeArray(type)) {
2427                            return object;
2428                    }
2429    
2430                    Collection<?> collection = (Collection<?>)object;
2431    
2432                    return collection.toArray();
2433            }
2434    
2435            protected Object handleStrings(int type, Object object) {
2436                    if (!(object instanceof String)) {
2437                            return object;
2438                    }
2439    
2440                    String string = (String)object;
2441    
2442                    if (string.startsWith(StringPool.OPEN_BRACKET) &&
2443                            string.endsWith(StringPool.CLOSE_BRACKET)) {
2444    
2445                            string = string.substring(1, (string.length() - 1));
2446                    }
2447    
2448                    return string;
2449            }
2450    
2451            protected boolean isTypeArray(int type) {
2452                    if ((type == ExpandoColumnConstants.BOOLEAN_ARRAY) ||
2453                            (type == ExpandoColumnConstants.DATE_ARRAY) ||
2454                            (type == ExpandoColumnConstants.DOUBLE_ARRAY) ||
2455                            (type == ExpandoColumnConstants.FLOAT_ARRAY) ||
2456                            (type == ExpandoColumnConstants.INTEGER_ARRAY) ||
2457                            (type == ExpandoColumnConstants.LONG_ARRAY) ||
2458                            (type == ExpandoColumnConstants.NUMBER_ARRAY) ||
2459                            (type == ExpandoColumnConstants.SHORT_ARRAY) ||
2460                            (type == ExpandoColumnConstants.STRING_ARRAY)) {
2461    
2462                            return true;
2463                    }
2464    
2465                    return false;
2466            }
2467    
2468    }