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