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