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