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