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