001    /**
002     * Copyright (c) 2000-2012 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 {@link #addValue(long, String, String, String, long,
598             *             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 {@link #addValue(long, String, String, String, long,
613             *             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 {@link #addValue(long, String, String, String, long, Date[])}
628             */
629            public ExpandoValue addValue(
630                            String className, String tableName, String columnName, long classPK,
631                            Date data)
632                    throws PortalException, SystemException {
633    
634                    long companyId = CompanyThreadLocal.getCompanyId();
635    
636                    return expandoValueLocalService.addValue(
637                            companyId, className, tableName, columnName, classPK, data);
638            }
639    
640            /**
641             * @deprecated {@link #addValue(long, String, String, String, long, Date[])}
642             */
643            public ExpandoValue addValue(
644                            String className, String tableName, String columnName, long classPK,
645                            Date[] data)
646                    throws PortalException, SystemException {
647    
648                    long companyId = CompanyThreadLocal.getCompanyId();
649    
650                    return expandoValueLocalService.addValue(
651                            companyId, className, tableName, columnName, classPK, data);
652            }
653    
654            /**
655             * @deprecated {@link #addValue(long, String, String, String, long,
656             *             double[])}
657             */
658            public ExpandoValue addValue(
659                            String className, String tableName, String columnName, long classPK,
660                            double data)
661                    throws PortalException, SystemException {
662    
663                    long companyId = CompanyThreadLocal.getCompanyId();
664    
665                    return expandoValueLocalService.addValue(
666                            companyId, className, tableName, columnName, classPK, data);
667            }
668    
669            /**
670             * @deprecated {@link #addValue(long, String, String, String, long,
671             *             double[])}
672             */
673            public ExpandoValue addValue(
674                            String className, String tableName, String columnName, long classPK,
675                            double[] data)
676                    throws PortalException, SystemException {
677    
678                    long companyId = CompanyThreadLocal.getCompanyId();
679    
680                    return expandoValueLocalService.addValue(
681                            companyId, className, tableName, columnName, classPK, data);
682            }
683    
684            /**
685             * @deprecated {@link #addValue(long, String, String, String, long,
686             *             float[])}
687             */
688            public ExpandoValue addValue(
689                            String className, String tableName, String columnName, long classPK,
690                            float data)
691                    throws PortalException, SystemException {
692    
693                    long companyId = CompanyThreadLocal.getCompanyId();
694    
695                    return expandoValueLocalService.addValue(
696                            companyId, className, tableName, columnName, classPK, data);
697            }
698    
699            /**
700             * @deprecated {@link #addValue(long, String, String, String, long,
701             *             float[])}
702             */
703            public ExpandoValue addValue(
704                            String className, String tableName, String columnName, long classPK,
705                            float[] data)
706                    throws PortalException, SystemException {
707    
708                    long companyId = CompanyThreadLocal.getCompanyId();
709    
710                    return expandoValueLocalService.addValue(
711                            companyId, className, tableName, columnName, classPK, data);
712            }
713    
714            /**
715             * @deprecated {@link #addValue(long, String, String, String, long, int[])}
716             */
717            public ExpandoValue addValue(
718                            String className, String tableName, String columnName, long classPK,
719                            int data)
720                    throws PortalException, SystemException {
721    
722                    long companyId = CompanyThreadLocal.getCompanyId();
723    
724                    return expandoValueLocalService.addValue(
725                            companyId, className, tableName, columnName, classPK, data);
726            }
727    
728            /**
729             * @deprecated {@link #addValue(long, String, String, String, long, int[])}
730             */
731            public ExpandoValue addValue(
732                            String className, String tableName, String columnName, long classPK,
733                            int[] data)
734                    throws PortalException, SystemException {
735    
736                    long companyId = CompanyThreadLocal.getCompanyId();
737    
738                    return expandoValueLocalService.addValue(
739                            companyId, className, tableName, columnName, classPK, data);
740            }
741    
742            /**
743             * @deprecated {@link #addValue(long, String, String, String, long, long[])}
744             */
745            public ExpandoValue addValue(
746                            String className, String tableName, String columnName, long classPK,
747                            long data)
748                    throws PortalException, SystemException {
749    
750                    long companyId = CompanyThreadLocal.getCompanyId();
751    
752                    return expandoValueLocalService.addValue(
753                            companyId, className, tableName, columnName, classPK, data);
754            }
755    
756            /**
757             * @deprecated {@link #addValue(long, String, String, String, long, long[])}
758             */
759            public ExpandoValue addValue(
760                            String className, String tableName, String columnName, long classPK,
761                            long[] data)
762                    throws PortalException, SystemException {
763    
764                    long companyId = CompanyThreadLocal.getCompanyId();
765    
766                    return expandoValueLocalService.addValue(
767                            companyId, className, tableName, columnName, classPK, data);
768            }
769    
770            /**
771             * @deprecated {@link #addValue(long, String, String, String, long, Object)}
772             */
773            public ExpandoValue addValue(
774                            String className, String tableName, String columnName, long classPK,
775                            Object data)
776                    throws PortalException, SystemException {
777    
778                    long companyId = CompanyThreadLocal.getCompanyId();
779    
780                    return expandoValueLocalService.addValue(
781                            companyId, className, tableName, columnName, classPK, data);
782            }
783    
784            /**
785             * @deprecated {@link #addValue(long, String, String, String, long,
786             *             short[])}
787             */
788            public ExpandoValue addValue(
789                            String className, String tableName, String columnName, long classPK,
790                            short data)
791                    throws PortalException, SystemException {
792    
793                    long companyId = CompanyThreadLocal.getCompanyId();
794    
795                    return expandoValueLocalService.addValue(
796                            companyId, className, tableName, columnName, classPK, data);
797            }
798    
799            /**
800             * @deprecated {@link #addValue(long, String, String, String, long,
801             *             short[])}
802             */
803            public ExpandoValue addValue(
804                            String className, String tableName, String columnName, long classPK,
805                            short[] data)
806                    throws PortalException, SystemException {
807    
808                    long companyId = CompanyThreadLocal.getCompanyId();
809    
810                    return expandoValueLocalService.addValue(
811                            companyId, className, tableName, columnName, classPK, data);
812            }
813    
814            /**
815             * @deprecated {@link #addValue(long, String, String, String, long,
816             *             String[])}
817             */
818            public ExpandoValue addValue(
819                            String className, String tableName, String columnName, long classPK,
820                            String data)
821                    throws PortalException, SystemException {
822    
823                    long companyId = CompanyThreadLocal.getCompanyId();
824    
825                    return expandoValueLocalService.addValue(
826                            companyId, className, tableName, columnName, classPK, data);
827            }
828    
829            /**
830             * @deprecated {@link #addValue(long, String, String, String, long,
831             *             String[])}
832             */
833            public ExpandoValue addValue(
834                            String className, String tableName, String columnName, long classPK,
835                            String[] data)
836                    throws PortalException, SystemException {
837    
838                    long companyId = CompanyThreadLocal.getCompanyId();
839    
840                    return expandoValueLocalService.addValue(
841                            companyId, className, tableName, columnName, classPK, data);
842            }
843    
844            public void addValues(
845                            long classNameId, long tableId, List<ExpandoColumn> columns,
846                            long classPK, Map<String, String> data)
847                    throws PortalException, SystemException {
848    
849                    ExpandoTable table = expandoTablePersistence.findByPrimaryKey(tableId);
850    
851                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
852    
853                    if (row == null) {
854                            long rowId = counterLocalService.increment();
855    
856                            row = expandoRowPersistence.create(rowId);
857    
858                            row.setCompanyId(table.getCompanyId());
859                            row.setTableId(tableId);
860                            row.setClassPK(classPK);
861    
862                            expandoRowPersistence.update(row);
863                    }
864    
865                    boolean rowModified = false;
866    
867                    for (ExpandoColumn column : columns) {
868                            String dataString = data.get(column.getName());
869    
870                            if (dataString == null) {
871                                    continue;
872                            }
873    
874                            ExpandoValue value = expandoValuePersistence.fetchByC_R(
875                                    column.getColumnId(), row.getRowId());
876    
877                            if (value == null) {
878                                    long valueId = counterLocalService.increment();
879    
880                                    value = expandoValuePersistence.create(valueId);
881    
882                                    value.setCompanyId(table.getCompanyId());
883                                    value.setTableId(tableId);
884                                    value.setColumnId(column.getColumnId());
885                                    value.setRowId(row.getRowId());
886                                    value.setClassNameId(classNameId);
887                                    value.setClassPK(classPK);
888                            }
889    
890                            if (value.isNew() ||
891                                    !Validator.equals(value.getData(), dataString)) {
892    
893                                    value.setData(dataString);
894    
895                                    expandoValuePersistence.update(value);
896    
897                                    rowModified = true;
898                            }
899                    }
900    
901                    if (rowModified) {
902                            row.setModifiedDate(new Date());
903    
904                            expandoRowPersistence.update(row);
905                    }
906            }
907    
908            public void addValues(
909                            long companyId, long classNameId, String tableName, long classPK,
910                            Map<String, Serializable> attributes)
911                    throws PortalException, SystemException {
912    
913                    ExpandoTable table = expandoTableLocalService.getTable(
914                            companyId, classNameId, tableName);
915    
916                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
917                            table.getTableId(), attributes.keySet());
918    
919                    ExpandoValue value = new ExpandoValueImpl();
920    
921                    value.setCompanyId(companyId);
922    
923                    for (ExpandoColumn column : columns) {
924                            Serializable attributeValue = attributes.get(column.getName());
925    
926                            value.setColumn(column);
927    
928                            int type = column.getType();
929    
930                            if (type == ExpandoColumnConstants.BOOLEAN) {
931                                    value.setBoolean((Boolean)attributeValue);
932                            }
933                            else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
934                                    value.setBooleanArray((boolean[])attributeValue);
935                            }
936                            else if (type == ExpandoColumnConstants.DATE) {
937                                    value.setDate((Date)attributeValue);
938                            }
939                            else if (type == ExpandoColumnConstants.DATE_ARRAY) {
940                                    value.setDateArray((Date[])attributeValue);
941                            }
942                            else if (type == ExpandoColumnConstants.DOUBLE) {
943                                    value.setDouble((Double)attributeValue);
944                            }
945                            else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
946                                    value.setDoubleArray((double[])attributeValue);
947                            }
948                            else if (type == ExpandoColumnConstants.FLOAT) {
949                                    value.setFloat((Float)attributeValue);
950                            }
951                            else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
952                                    value.setFloatArray((float[])attributeValue);
953                            }
954                            else if (type == ExpandoColumnConstants.INTEGER) {
955                                    value.setInteger((Integer)attributeValue);
956                            }
957                            else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
958                                    value.setIntegerArray((int[])attributeValue);
959                            }
960                            else if (type == ExpandoColumnConstants.LONG) {
961                                    value.setLong((Long)attributeValue);
962                            }
963                            else if (type == ExpandoColumnConstants.LONG_ARRAY) {
964                                    value.setLongArray((long[])attributeValue);
965                            }
966                            else if (type == ExpandoColumnConstants.NUMBER) {
967                                    value.setNumber((Number)attributeValue);
968                            }
969                            else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
970                                    value.setNumberArray((Number[])attributeValue);
971                            }
972                            else if (type == ExpandoColumnConstants.SHORT) {
973                                    value.setShort((Short)attributeValue);
974                            }
975                            else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
976                                    value.setShortArray((short[])attributeValue);
977                            }
978                            else if (type == ExpandoColumnConstants.STRING_ARRAY) {
979                                    value.setStringArray((String[])attributeValue);
980                            }
981                            else {
982                                    value.setString((String)attributeValue);
983                            }
984    
985                            doAddValue(
986                                    companyId, classNameId, table.getTableId(),
987                                    column.getColumnId(), classPK, value.getData());
988                    }
989            }
990    
991            public void addValues(
992                            long companyId, String className, String tableName, long classPK,
993                            Map<String, Serializable> attributes)
994                    throws PortalException, SystemException {
995    
996                    long classNameId = PortalUtil.getClassNameId(className);
997    
998                    addValues(companyId, classNameId, tableName, classPK, attributes);
999            }
1000    
1001            public void deleteColumnValues(long columnId) throws SystemException {
1002                    List<ExpandoValue> values = expandoValuePersistence.findByColumnId(
1003                            columnId);
1004    
1005                    for (ExpandoValue value : values) {
1006                            deleteValue(value);
1007                    }
1008            }
1009    
1010            public void deleteRowValues(long rowId) throws SystemException {
1011                    List<ExpandoValue> values = expandoValuePersistence.findByRowId(rowId);
1012    
1013                    for (ExpandoValue value : values) {
1014                            deleteValue(value);
1015                    }
1016            }
1017    
1018            public void deleteTableValues(long tableId) throws SystemException {
1019                    List<ExpandoValue> values = expandoValuePersistence.findByTableId(
1020                            tableId);
1021    
1022                    for (ExpandoValue value : values) {
1023                            deleteValue(value);
1024                    }
1025            }
1026    
1027            public void deleteValue(ExpandoValue value) throws SystemException {
1028                    expandoValuePersistence.remove(value);
1029            }
1030    
1031            public void deleteValue(long valueId)
1032                    throws PortalException, SystemException {
1033    
1034                    ExpandoValue value = expandoValuePersistence.findByPrimaryKey(valueId);
1035    
1036                    deleteValue(value);
1037            }
1038    
1039            public void deleteValue(long columnId, long rowId)
1040                    throws PortalException, SystemException {
1041    
1042                    ExpandoValue value = expandoValuePersistence.findByC_R(columnId, rowId);
1043    
1044                    deleteValue(value);
1045            }
1046    
1047            public void deleteValue(
1048                            long companyId, long classNameId, String tableName,
1049                            String columnName, long classPK)
1050                    throws PortalException, SystemException {
1051    
1052                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1053                            companyId, classNameId, tableName);
1054    
1055                    if (table == null) {
1056                            return;
1057                    }
1058    
1059                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1060                            table.getTableId(), columnName);
1061    
1062                    if (column == null) {
1063                            return;
1064                    }
1065    
1066                    ExpandoValue value = expandoValuePersistence.fetchByT_C_C(
1067                            table.getTableId(), column.getColumnId(), classPK);
1068    
1069                    if (value != null) {
1070                            deleteValue(value.getValueId());
1071                    }
1072            }
1073    
1074            public void deleteValue(
1075                            long companyId, String className, String tableName,
1076                            String columnName, long classPK)
1077                    throws PortalException, SystemException {
1078    
1079                    long classNameId = PortalUtil.getClassNameId(className);
1080    
1081                    expandoValueLocalService.deleteValue(
1082                            companyId, classNameId, tableName, columnName, classPK);
1083            }
1084    
1085            public void deleteValues(long classNameId, long classPK)
1086                    throws SystemException {
1087    
1088                    List<ExpandoValue> values = expandoValuePersistence.findByC_C(
1089                            classNameId, classPK);
1090    
1091                    for (ExpandoValue value : values) {
1092                            deleteValue(value);
1093                    }
1094            }
1095    
1096            public void deleteValues(String className, long classPK)
1097                    throws SystemException {
1098    
1099                    long classNameId = PortalUtil.getClassNameId(className);
1100    
1101                    expandoValueLocalService.deleteValues(classNameId, classPK);
1102            }
1103    
1104            public List<ExpandoValue> getColumnValues(long columnId, int start, int end)
1105                    throws SystemException {
1106    
1107                    return expandoValuePersistence.findByColumnId(columnId, start, end);
1108            }
1109    
1110            public List<ExpandoValue> getColumnValues(
1111                            long companyId, long classNameId, String tableName,
1112                            String columnName, int start, int end)
1113                    throws SystemException {
1114    
1115                    return expandoValueLocalService.getColumnValues(
1116                            companyId, classNameId, tableName, columnName, null, start, end);
1117            }
1118    
1119            public List<ExpandoValue> getColumnValues(
1120                            long companyId, long classNameId, String tableName,
1121                            String columnName, String data, int start, int end)
1122                    throws SystemException {
1123    
1124                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1125                            companyId, classNameId, tableName);
1126    
1127                    if (table == null) {
1128                            return Collections.emptyList();
1129                    }
1130    
1131                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1132                            table.getTableId(), columnName);
1133    
1134                    if (column == null) {
1135                            return Collections.emptyList();
1136                    }
1137    
1138                    if (data == null) {
1139                            return expandoValuePersistence.findByT_C(
1140                                    table.getTableId(), column.getColumnId(), start, end);
1141                    }
1142                    else {
1143                            return expandoValuePersistence.findByT_C_D(
1144                                    table.getTableId(), column.getColumnId(), data, start, end);
1145                    }
1146            }
1147    
1148            public List<ExpandoValue> getColumnValues(
1149                            long companyId, String className, String tableName,
1150                            String columnName, int start, int end)
1151                    throws SystemException {
1152    
1153                    long classNameId = PortalUtil.getClassNameId(className);
1154    
1155                    return expandoValueLocalService.getColumnValues(
1156                            companyId, classNameId, tableName, columnName, start, end);
1157            }
1158    
1159            public List<ExpandoValue> getColumnValues(
1160                            long companyId, String className, String tableName,
1161                            String columnName, String data, int start, int end)
1162                    throws SystemException {
1163    
1164                    long classNameId = PortalUtil.getClassNameId(className);
1165    
1166                    return expandoValueLocalService.getColumnValues(
1167                            companyId, classNameId, tableName, columnName, data, start, end);
1168            }
1169    
1170            /**
1171             * @deprecated {@link #getColumnValues(long, String, String, String, String,
1172             *             int, int)}
1173             */
1174            public List<ExpandoValue> getColumnValues(
1175                            String className, String tableName, String columnName, String data,
1176                            int start, int end)
1177                    throws SystemException {
1178    
1179                    long companyId = CompanyThreadLocal.getCompanyId();
1180    
1181                    return expandoValueLocalService.getColumnValues(
1182                            companyId, className, tableName, columnName, data, start, end);
1183            }
1184    
1185            public int getColumnValuesCount(long columnId) throws SystemException {
1186                    return expandoValuePersistence.countByColumnId(columnId);
1187            }
1188    
1189            public int getColumnValuesCount(
1190                            long companyId, long classNameId, String tableName,
1191                            String columnName)
1192                    throws SystemException {
1193    
1194                    return expandoValueLocalService.getColumnValuesCount(
1195                            companyId, classNameId, tableName, columnName, null);
1196            }
1197    
1198            public int getColumnValuesCount(
1199                            long companyId, long classNameId, String tableName,
1200                            String columnName, String data)
1201                    throws SystemException {
1202    
1203                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1204                            companyId, classNameId, tableName);
1205    
1206                    if (table == null) {
1207                            return 0;
1208                    }
1209    
1210                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1211                            table.getTableId(), columnName);
1212    
1213                    if (column == null) {
1214                            return 0;
1215                    }
1216    
1217                    if (data == null) {
1218                            return expandoValuePersistence.countByT_C(
1219                                    table.getTableId(), column.getColumnId());
1220                    }
1221                    else {
1222                            return expandoValuePersistence.countByT_C_D(
1223                                    table.getTableId(), column.getColumnId(), data);
1224                    }
1225            }
1226    
1227            public int getColumnValuesCount(
1228                            long companyId, String className, String tableName,
1229                            String columnName)
1230                    throws SystemException {
1231    
1232                    long classNameId = PortalUtil.getClassNameId(className);
1233    
1234                    return expandoValueLocalService.getColumnValuesCount(
1235                            companyId, classNameId, tableName, columnName);
1236            }
1237    
1238            public int getColumnValuesCount(
1239                            long companyId, String className, String tableName,
1240                            String columnName, String data)
1241                    throws SystemException {
1242    
1243                    long classNameId = PortalUtil.getClassNameId(className);
1244    
1245                    return expandoValueLocalService.getColumnValuesCount(
1246                            companyId, classNameId, tableName, columnName, data);
1247            }
1248    
1249            /**
1250             * @deprecated {@link #getColumnValuesCount(long, String, String, String,
1251             *             String)}
1252             */
1253            public int getColumnValuesCount(
1254                            String className, String tableName, String columnName, String data)
1255                    throws SystemException {
1256    
1257                    long companyId = CompanyThreadLocal.getCompanyId();
1258    
1259                    return expandoValueLocalService.getColumnValuesCount(
1260                            companyId, className, tableName, columnName, data);
1261            }
1262    
1263            public Map<String, Serializable> getData(
1264                            long companyId, String className, String tableName,
1265                            Collection<String> columnNames, long classPK)
1266                    throws PortalException, SystemException {
1267    
1268                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
1269                            companyId, className, tableName, columnNames);
1270    
1271                    Map<String, Serializable> attributeValues =
1272                            new HashMap<String, Serializable>((int)(columnNames.size() * 1.4));
1273    
1274                    ExpandoValue value = new ExpandoValueImpl();
1275    
1276                    for (ExpandoColumn column : columns) {
1277                            value.setColumn(column);
1278                            value.setData(column.getDefaultData());
1279    
1280                            Serializable attributeValue = doGetData(
1281                                    companyId, className, tableName, column.getName(), classPK,
1282                                    value, column.getType());
1283    
1284                            attributeValues.put(column.getName(), attributeValue);
1285                    }
1286    
1287                    return attributeValues;
1288            }
1289    
1290            public Serializable getData(
1291                            long companyId, String className, String tableName,
1292                            String columnName, long classPK)
1293                    throws PortalException, SystemException {
1294    
1295                    ExpandoColumn column = expandoColumnLocalService.getColumn(
1296                            companyId, className, tableName, columnName);
1297    
1298                    ExpandoValue value = new ExpandoValueImpl();
1299    
1300                    value.setColumn(column);
1301                    value.setData(column.getDefaultData());
1302    
1303                    return doGetData(
1304                            companyId, className, tableName, columnName, classPK, value,
1305                            column.getType());
1306            }
1307    
1308            public boolean getData(
1309                            long companyId, String className, String tableName,
1310                            String columnName, long classPK, boolean defaultData)
1311                    throws PortalException, SystemException {
1312    
1313                    ExpandoValue value = expandoValueLocalService.getValue(
1314                            companyId, className, tableName, columnName, classPK);
1315    
1316                    if (value == null) {
1317                            return defaultData;
1318                    }
1319                    else {
1320                            return value.getBoolean();
1321                    }
1322            }
1323    
1324            public boolean[] getData(
1325                            long companyId, String className, String tableName,
1326                            String columnName, long classPK, boolean[] defaultData)
1327                    throws PortalException, SystemException {
1328    
1329                    ExpandoValue value = expandoValueLocalService.getValue(
1330                            companyId, className, tableName, columnName, classPK);
1331    
1332                    if (value == null) {
1333                            return defaultData;
1334                    }
1335                    else {
1336                            return value.getBooleanArray();
1337                    }
1338            }
1339    
1340            public Date getData(
1341                            long companyId, String className, String tableName,
1342                            String columnName, long classPK, Date defaultData)
1343                    throws PortalException, SystemException {
1344    
1345                    ExpandoValue value = expandoValueLocalService.getValue(
1346                            companyId, className, tableName, columnName, classPK);
1347    
1348                    if (value == null) {
1349                            return defaultData;
1350                    }
1351                    else {
1352                            return value.getDate();
1353                    }
1354            }
1355    
1356            public Date[] getData(
1357                            long companyId, String className, String tableName,
1358                            String columnName, long classPK, Date[] defaultData)
1359                    throws PortalException, SystemException {
1360    
1361                    ExpandoValue value = expandoValueLocalService.getValue(
1362                            companyId, className, tableName, columnName, classPK);
1363    
1364                    if (value == null) {
1365                            return defaultData;
1366                    }
1367                    else {
1368                            return value.getDateArray();
1369                    }
1370            }
1371    
1372            public double getData(
1373                            long companyId, String className, String tableName,
1374                            String columnName, long classPK, double defaultData)
1375                    throws PortalException, SystemException {
1376    
1377                    ExpandoValue value = expandoValueLocalService.getValue(
1378                            companyId, className, tableName, columnName, classPK);
1379    
1380                    if (value == null) {
1381                            return defaultData;
1382                    }
1383                    else {
1384                            return value.getDouble();
1385                    }
1386            }
1387    
1388            public double[] getData(
1389                            long companyId, String className, String tableName,
1390                            String columnName, long classPK, double[] defaultData)
1391                    throws PortalException, SystemException {
1392    
1393                    ExpandoValue value = expandoValueLocalService.getValue(
1394                            companyId, className, tableName, columnName, classPK);
1395    
1396                    if (value == null) {
1397                            return defaultData;
1398                    }
1399                    else {
1400                            return value.getDoubleArray();
1401                    }
1402            }
1403    
1404            public float getData(
1405                            long companyId, String className, String tableName,
1406                            String columnName, long classPK, float defaultData)
1407                    throws PortalException, SystemException {
1408    
1409                    ExpandoValue value = expandoValueLocalService.getValue(
1410                            companyId, className, tableName, columnName, classPK);
1411    
1412                    if (value == null) {
1413                            return defaultData;
1414                    }
1415                    else {
1416                            return value.getFloat();
1417                    }
1418            }
1419    
1420            public float[] getData(
1421                            long companyId, String className, String tableName,
1422                            String columnName, long classPK, float[] defaultData)
1423                    throws PortalException, SystemException {
1424    
1425                    ExpandoValue value = expandoValueLocalService.getValue(
1426                            companyId, className, tableName, columnName, classPK);
1427    
1428                    if (value == null) {
1429                            return defaultData;
1430                    }
1431                    else {
1432                            return value.getFloatArray();
1433                    }
1434            }
1435    
1436            public int getData(
1437                            long companyId, String className, String tableName,
1438                            String columnName, long classPK, int defaultData)
1439                    throws PortalException, SystemException {
1440    
1441                    ExpandoValue value = expandoValueLocalService.getValue(
1442                            companyId, className, tableName, columnName, classPK);
1443    
1444                    if (value == null) {
1445                            return defaultData;
1446                    }
1447                    else {
1448                            return value.getInteger();
1449                    }
1450            }
1451    
1452            public int[] getData(
1453                            long companyId, String className, String tableName,
1454                            String columnName, long classPK, int[] defaultData)
1455                    throws PortalException, SystemException {
1456    
1457                    ExpandoValue value = expandoValueLocalService.getValue(
1458                            companyId, className, tableName, columnName, classPK);
1459    
1460                    if (value == null) {
1461                            return defaultData;
1462                    }
1463                    else {
1464                            return value.getIntegerArray();
1465                    }
1466            }
1467    
1468            public long getData(
1469                            long companyId, String className, String tableName,
1470                            String columnName, long classPK, long defaultData)
1471                    throws PortalException, SystemException {
1472    
1473                    ExpandoValue value = expandoValueLocalService.getValue(
1474                            companyId, className, tableName, columnName, classPK);
1475    
1476                    if (value == null) {
1477                            return defaultData;
1478                    }
1479                    else {
1480                            return value.getLong();
1481                    }
1482            }
1483    
1484            public long[] getData(
1485                            long companyId, String className, String tableName,
1486                            String columnName, long classPK, long[] defaultData)
1487                    throws PortalException, SystemException {
1488    
1489                    ExpandoValue value = expandoValueLocalService.getValue(
1490                            companyId, className, tableName, columnName, classPK);
1491    
1492                    if (value == null) {
1493                            return defaultData;
1494                    }
1495                    else {
1496                            return value.getLongArray();
1497                    }
1498            }
1499    
1500            public Map<?, ?> getData(
1501                            long companyId, String className, String tableName,
1502                            String columnName, long classPK, Map<?, ?> defaultData)
1503                    throws PortalException, SystemException {
1504    
1505                    ExpandoValue value = expandoValueLocalService.getValue(
1506                            companyId, className, tableName, columnName, classPK);
1507    
1508                    if (value == null) {
1509                            return defaultData;
1510                    }
1511    
1512                    ExpandoColumn column = value.getColumn();
1513    
1514                    int type = column.getType();
1515    
1516                    if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
1517                            return value.getStringArrayMap();
1518                    }
1519                    else {
1520                            return value.getStringMap();
1521                    }
1522            }
1523    
1524            public Number getData(
1525                            long companyId, String className, String tableName,
1526                            String columnName, long classPK, Number defaultData)
1527                    throws PortalException, SystemException {
1528    
1529                    ExpandoValue value = expandoValueLocalService.getValue(
1530                            companyId, className, tableName, columnName, classPK);
1531    
1532                    if (value == null) {
1533                            return defaultData;
1534                    }
1535                    else {
1536                            return value.getNumber();
1537                    }
1538            }
1539    
1540            public Number[] getData(
1541                            long companyId, String className, String tableName,
1542                            String columnName, long classPK, Number[] defaultData)
1543                    throws PortalException, SystemException {
1544    
1545                    ExpandoValue value = expandoValueLocalService.getValue(
1546                            companyId, className, tableName, columnName, classPK);
1547    
1548                    if (value == null) {
1549                            return defaultData;
1550                    }
1551                    else {
1552                            return value.getNumberArray();
1553                    }
1554            }
1555    
1556            public short getData(
1557                            long companyId, String className, String tableName,
1558                            String columnName, long classPK, short defaultData)
1559                    throws PortalException, SystemException {
1560    
1561                    ExpandoValue value = expandoValueLocalService.getValue(
1562                            companyId, className, tableName, columnName, classPK);
1563    
1564                    if (value == null) {
1565                            return defaultData;
1566                    }
1567                    else {
1568                            return value.getShort();
1569                    }
1570            }
1571    
1572            public short[] getData(
1573                            long companyId, String className, String tableName,
1574                            String columnName, long classPK, short[] defaultData)
1575                    throws PortalException, SystemException {
1576    
1577                    ExpandoValue value = expandoValueLocalService.getValue(
1578                            companyId, className, tableName, columnName, classPK);
1579    
1580                    if (value == null) {
1581                            return defaultData;
1582                    }
1583                    else {
1584                            return value.getShortArray();
1585                    }
1586            }
1587    
1588            public String getData(
1589                            long companyId, String className, String tableName,
1590                            String columnName, long classPK, String defaultData)
1591                    throws PortalException, SystemException {
1592    
1593                    ExpandoValue value = expandoValueLocalService.getValue(
1594                            companyId, className, tableName, columnName, classPK);
1595    
1596                    if (value == null) {
1597                            return defaultData;
1598                    }
1599                    else {
1600                            return value.getString();
1601                    }
1602            }
1603    
1604            public String[] getData(
1605                            long companyId, String className, String tableName,
1606                            String columnName, long classPK, String[] defaultData)
1607                    throws PortalException, SystemException {
1608    
1609                    ExpandoValue value = expandoValueLocalService.getValue(
1610                            companyId, className, tableName, columnName, classPK);
1611    
1612                    if (value == null) {
1613                            return defaultData;
1614                    }
1615                    else {
1616                            return value.getStringArray();
1617                    }
1618            }
1619    
1620            /**
1621             * @deprecated {@link #getData(long, String, String, String, long)}
1622             */
1623            public Serializable getData(
1624                            String className, String tableName, String columnName, long classPK)
1625                    throws PortalException, SystemException {
1626    
1627                    long companyId = CompanyThreadLocal.getCompanyId();
1628    
1629                    return expandoValueLocalService.getData(
1630                            companyId, className, tableName, columnName, classPK);
1631            }
1632    
1633            /**
1634             * @deprecated {@link #getData(long, String, String, String, long,
1635             *             boolean[])}
1636             */
1637            public boolean getData(
1638                            String className, String tableName, String columnName, long classPK,
1639                            boolean defaultData)
1640                    throws PortalException, SystemException {
1641    
1642                    long companyId = CompanyThreadLocal.getCompanyId();
1643    
1644                    return expandoValueLocalService.getData(
1645                            companyId, className, tableName, columnName, classPK, defaultData);
1646            }
1647    
1648            /**
1649             * @deprecated {@link #getData(long, String, String, String, long,
1650             *             boolean[])}
1651             */
1652            public boolean[] getData(
1653                            String className, String tableName, String columnName, long classPK,
1654                            boolean[] defaultData)
1655                    throws PortalException, SystemException {
1656    
1657                    long companyId = CompanyThreadLocal.getCompanyId();
1658    
1659                    return expandoValueLocalService.getData(
1660                            companyId, className, tableName, columnName, classPK, defaultData);
1661            }
1662    
1663            /**
1664             * @deprecated {@link #getData(long, String, String, String, long, Date[])}
1665             */
1666            public Date getData(
1667                            String className, String tableName, String columnName, long classPK,
1668                            Date defaultData)
1669                    throws PortalException, SystemException {
1670    
1671                    long companyId = CompanyThreadLocal.getCompanyId();
1672    
1673                    return expandoValueLocalService.getData(
1674                            companyId, className, tableName, columnName, classPK, defaultData);
1675            }
1676    
1677            /**
1678             * @deprecated {@link #getData(long, String, String, String, long, Date[])}
1679             */
1680            public Date[] getData(
1681                            String className, String tableName, String columnName, long classPK,
1682                            Date[] defaultData)
1683                    throws PortalException, SystemException {
1684    
1685                    long companyId = CompanyThreadLocal.getCompanyId();
1686    
1687                    return expandoValueLocalService.getData(
1688                            companyId, className, tableName, columnName, classPK, defaultData);
1689            }
1690    
1691            /**
1692             * @deprecated {@link #getData(long, String, String, String, long,
1693             *             double[])}
1694             */
1695            public double getData(
1696                            String className, String tableName, String columnName, long classPK,
1697                            double defaultData)
1698                    throws PortalException, SystemException {
1699    
1700                    long companyId = CompanyThreadLocal.getCompanyId();
1701    
1702                    return expandoValueLocalService.getData(
1703                            companyId, className, tableName, columnName, classPK, defaultData);
1704            }
1705    
1706            /**
1707             * @deprecated {@link #getData(long, String, String, String, long,
1708             *             double[])}
1709             */
1710            public double[] getData(
1711                            String className, String tableName, String columnName, long classPK,
1712                            double[] defaultData)
1713                    throws PortalException, SystemException {
1714    
1715                    long companyId = CompanyThreadLocal.getCompanyId();
1716    
1717                    return expandoValueLocalService.getData(
1718                            companyId, className, tableName, columnName, classPK, defaultData);
1719            }
1720    
1721            /**
1722             * @deprecated {@link #getData(long, String, String, String, long, float[])}
1723             */
1724            public float getData(
1725                            String className, String tableName, String columnName, long classPK,
1726                            float defaultData)
1727                    throws PortalException, SystemException {
1728    
1729                    long companyId = CompanyThreadLocal.getCompanyId();
1730    
1731                    return expandoValueLocalService.getData(
1732                            companyId, className, tableName, columnName, classPK, defaultData);
1733            }
1734    
1735            /**
1736             * @deprecated {@link #getData(long, String, String, String, long, float[])}
1737             */
1738            public float[] getData(
1739                            String className, String tableName, String columnName, long classPK,
1740                            float[] defaultData)
1741                    throws PortalException, SystemException {
1742    
1743                    long companyId = CompanyThreadLocal.getCompanyId();
1744    
1745                    return expandoValueLocalService.getData(
1746                            companyId, className, tableName, columnName, classPK, defaultData);
1747            }
1748    
1749            /**
1750             * @deprecated {@link #getData(long, String, String, String, long, int[])}
1751             */
1752            public int getData(
1753                            String className, String tableName, String columnName, long classPK,
1754                            int defaultData)
1755                    throws PortalException, SystemException {
1756    
1757                    long companyId = CompanyThreadLocal.getCompanyId();
1758    
1759                    return expandoValueLocalService.getData(
1760                            companyId, className, tableName, columnName, classPK, defaultData);
1761            }
1762    
1763            /**
1764             * @deprecated {@link #getData(long, String, String, String, long, int[])}
1765             */
1766            public int[] getData(
1767                            String className, String tableName, String columnName, long classPK,
1768                            int[] defaultData)
1769                    throws PortalException, SystemException {
1770    
1771                    long companyId = CompanyThreadLocal.getCompanyId();
1772    
1773                    return expandoValueLocalService.getData(
1774                            companyId, className, tableName, columnName, classPK, defaultData);
1775            }
1776    
1777            /**
1778             * @deprecated {@link #getData(long, String, String, String, long, long[])}
1779             */
1780            public long getData(
1781                            String className, String tableName, String columnName, long classPK,
1782                            long 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 {@link #getData(long, String, String, String, long, long[])}
1793             */
1794            public long[] getData(
1795                            String className, String tableName, String columnName, long classPK,
1796                            long[] defaultData)
1797                    throws PortalException, SystemException {
1798    
1799                    long companyId = CompanyThreadLocal.getCompanyId();
1800    
1801                    return expandoValueLocalService.getData(
1802                            companyId, className, tableName, columnName, classPK, defaultData);
1803            }
1804    
1805            /**
1806             * @deprecated {@link #getData(long, String, String, String, long, short[])}
1807             */
1808            public short getData(
1809                            String className, String tableName, String columnName, long classPK,
1810                            short defaultData)
1811                    throws PortalException, SystemException {
1812    
1813                    long companyId = CompanyThreadLocal.getCompanyId();
1814    
1815                    return expandoValueLocalService.getData(
1816                            companyId, className, tableName, columnName, classPK, defaultData);
1817            }
1818    
1819            /**
1820             * @deprecated {@link #getData(long, String, String, String, long, short[])}
1821             */
1822            public short[] getData(
1823                            String className, String tableName, String columnName, long classPK,
1824                            short[] defaultData)
1825                    throws PortalException, SystemException {
1826    
1827                    long companyId = CompanyThreadLocal.getCompanyId();
1828    
1829                    return expandoValueLocalService.getData(
1830                            companyId, className, tableName, columnName, classPK, defaultData);
1831            }
1832    
1833            /**
1834             * @deprecated {@link #getData(long, String, String, String, long,
1835             *             String[])}
1836             */
1837            public String getData(
1838                            String className, String tableName, String columnName, long classPK,
1839                            String defaultData)
1840                    throws PortalException, SystemException {
1841    
1842                    long companyId = CompanyThreadLocal.getCompanyId();
1843    
1844                    return expandoValueLocalService.getData(
1845                            companyId, className, tableName, columnName, classPK, defaultData);
1846            }
1847    
1848            /**
1849             * @deprecated {@link #getData(long, String, String, String, long,
1850             *             String[])}
1851             */
1852            public String[] getData(
1853                            String className, String tableName, String columnName, long classPK,
1854                            String[] defaultData)
1855                    throws PortalException, SystemException {
1856    
1857                    long companyId = CompanyThreadLocal.getCompanyId();
1858    
1859                    return expandoValueLocalService.getData(
1860                            companyId, className, tableName, columnName, classPK, defaultData);
1861            }
1862    
1863            public List<ExpandoValue> getDefaultTableColumnValues(
1864                            long companyId, long classNameId, String columnName, int start,
1865                            int end)
1866                    throws SystemException {
1867    
1868                    return expandoValueLocalService.getColumnValues(
1869                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
1870                            columnName, start, end);
1871            }
1872    
1873            public List<ExpandoValue> getDefaultTableColumnValues(
1874                            long companyId, String className, String columnName, int start,
1875                            int end)
1876                    throws SystemException {
1877    
1878                    long classNameId = PortalUtil.getClassNameId(className);
1879    
1880                    return expandoValueLocalService.getDefaultTableColumnValues(
1881                            companyId, classNameId, columnName, start, end);
1882            }
1883    
1884            public int getDefaultTableColumnValuesCount(
1885                            long companyId, long classNameId, String columnName)
1886                    throws SystemException {
1887    
1888                    return expandoValueLocalService.getColumnValuesCount(
1889                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
1890                            columnName);
1891            }
1892    
1893            public int getDefaultTableColumnValuesCount(
1894                            long companyId, String className, String columnName)
1895                    throws SystemException {
1896    
1897                    long classNameId = PortalUtil.getClassNameId(className);
1898    
1899                    return expandoValueLocalService.getDefaultTableColumnValuesCount(
1900                            companyId, classNameId, columnName);
1901            }
1902    
1903            public List<ExpandoValue> getRowValues(long rowId) throws SystemException {
1904                    return expandoValuePersistence.findByRowId(rowId);
1905            }
1906    
1907            public List<ExpandoValue> getRowValues(long rowId, int start, int end)
1908                    throws SystemException {
1909    
1910                    return expandoValuePersistence.findByRowId(rowId, start, end);
1911            }
1912    
1913            public List<ExpandoValue> getRowValues(
1914                            long companyId, long classNameId, String tableName, long classPK,
1915                            int start, int end)
1916                    throws SystemException {
1917    
1918                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1919                            companyId, classNameId, tableName);
1920    
1921                    if (table == null) {
1922                            return Collections.emptyList();
1923                    }
1924    
1925                    return expandoValuePersistence.findByT_CPK(
1926                            table.getTableId(), classPK, start, end);
1927            }
1928    
1929            public List<ExpandoValue> getRowValues(
1930                            long companyId, String className, String tableName, long classPK,
1931                            int start, int end)
1932                    throws SystemException {
1933    
1934                    long classNameId = PortalUtil.getClassNameId(className);
1935    
1936                    return expandoValueLocalService.getRowValues(
1937                            companyId, classNameId, tableName, classPK, start, end);
1938            }
1939    
1940            public int getRowValuesCount(long rowId) throws SystemException {
1941                    return expandoValuePersistence.countByRowId(rowId);
1942            }
1943    
1944            public int getRowValuesCount(
1945                            long companyId, long classNameId, String tableName, long classPK)
1946                    throws SystemException {
1947    
1948                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1949                            companyId, classNameId, tableName);
1950    
1951                    if (table == null) {
1952                            return 0;
1953                    }
1954    
1955                    return expandoValuePersistence.countByT_CPK(
1956                            table.getTableId(), classPK);
1957            }
1958    
1959            public int getRowValuesCount(
1960                            long companyId, String className, String tableName, long classPK)
1961                    throws SystemException {
1962    
1963                    long classNameId = PortalUtil.getClassNameId(className);
1964    
1965                    return expandoValueLocalService.getRowValuesCount(
1966                            companyId, classNameId, tableName, classPK);
1967            }
1968    
1969            public ExpandoValue getValue(long valueId)
1970                    throws PortalException, SystemException {
1971    
1972                    return expandoValuePersistence.findByPrimaryKey(valueId);
1973            }
1974    
1975            public ExpandoValue getValue(long columnId, long rowId)
1976                    throws PortalException, SystemException {
1977    
1978                    return expandoValuePersistence.findByC_R(columnId, rowId);
1979            }
1980    
1981            public ExpandoValue getValue(long tableId, long columnId, long classPK)
1982                    throws SystemException {
1983    
1984                    return expandoValuePersistence.fetchByT_C_C(tableId, columnId, classPK);
1985            }
1986    
1987            public ExpandoValue getValue(
1988                            long companyId, long classNameId, String tableName,
1989                            String columnName, long classPK)
1990                    throws SystemException {
1991    
1992                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1993                            companyId, classNameId, tableName);
1994    
1995                    if (table == null) {
1996                            return null;
1997                    }
1998    
1999                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
2000                            table.getTableId(), columnName);
2001    
2002                    if (column == null) {
2003                            return null;
2004                    }
2005    
2006                    return expandoValuePersistence.fetchByT_C_C(
2007                            table.getTableId(), column.getColumnId(), classPK);
2008            }
2009    
2010            /**
2011             * @deprecated {@link #getValue(long, long, String, String, long)}
2012             */
2013            public ExpandoValue getValue(
2014                            long classNameId, String tableName, String columnName, long classPK)
2015                    throws SystemException {
2016    
2017                    long companyId = CompanyThreadLocal.getCompanyId();
2018    
2019                    return expandoValueLocalService.getValue(
2020                            companyId, classNameId, tableName, columnName, classPK);
2021            }
2022    
2023            public ExpandoValue getValue(
2024                            long companyId, String className, String tableName,
2025                            String columnName, long classPK)
2026                    throws SystemException {
2027    
2028                    long classNameId = PortalUtil.getClassNameId(className);
2029    
2030                    return expandoValueLocalService.getValue(
2031                            companyId, classNameId, tableName, columnName, classPK);
2032            }
2033    
2034            /**
2035             * @deprecated {@link #getValue(long, String, String, String, long)}
2036             */
2037            public ExpandoValue getValue(
2038                            String className, String tableName, String columnName, long classPK)
2039                    throws SystemException {
2040    
2041                    long companyId = CompanyThreadLocal.getCompanyId();
2042    
2043                    return expandoValueLocalService.getValue(
2044                            companyId, className, tableName, columnName, classPK);
2045            }
2046    
2047            protected ExpandoValue doAddValue(
2048                            long companyId, long classNameId, long tableId, long columnId,
2049                            long classPK, String data)
2050                    throws SystemException {
2051    
2052                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
2053    
2054                    if (row == null) {
2055                            long rowId = counterLocalService.increment();
2056    
2057                            row = expandoRowPersistence.create(rowId);
2058    
2059                            row.setCompanyId(companyId);
2060                            row.setTableId(tableId);
2061                            row.setClassPK(classPK);
2062    
2063                            expandoRowPersistence.update(row);
2064                    }
2065    
2066                    ExpandoValue value = expandoValuePersistence.fetchByC_R(
2067                            columnId, row.getRowId());
2068    
2069                    if (value == null) {
2070                            long valueId = counterLocalService.increment();
2071    
2072                            value = expandoValuePersistence.create(valueId);
2073    
2074                            value.setCompanyId(companyId);
2075                            value.setTableId(tableId);
2076                            value.setColumnId(columnId);
2077                            value.setRowId(row.getRowId());
2078                            value.setClassNameId(classNameId);
2079                            value.setClassPK(classPK);
2080                    }
2081    
2082                    if (value.isNew() || !Validator.equals(value.getData(), data)) {
2083                            value.setData(data);
2084    
2085                            expandoValuePersistence.update(value);
2086    
2087                            row.setModifiedDate(new Date());
2088    
2089                            expandoRowPersistence.update(row);
2090                    }
2091    
2092                    return value;
2093            }
2094    
2095            protected Serializable doGetData(
2096                            long companyId, String className, String tableName,
2097                            String columnName, long classPK, ExpandoValue value, int type)
2098                    throws PortalException, SystemException {
2099    
2100                    if (type == ExpandoColumnConstants.BOOLEAN) {
2101                            return expandoValueLocalService.getData(
2102                                    companyId, className, tableName, columnName, classPK,
2103                                    value.getBoolean());
2104                    }
2105                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2106                            return expandoValueLocalService.getData(
2107                                    companyId, className, tableName, columnName, classPK,
2108                                    new boolean[0]);
2109                    }
2110                    else if (type == ExpandoColumnConstants.DATE) {
2111                            return expandoValueLocalService.getData(
2112                                    companyId, className, tableName, columnName, classPK,
2113                                    value.getDate());
2114                    }
2115                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2116                            return expandoValueLocalService.getData(
2117                                    companyId, className, tableName, columnName, classPK,
2118                                    new Date[0]);
2119                    }
2120                    else if (type == ExpandoColumnConstants.DOUBLE) {
2121                            return expandoValueLocalService.getData(
2122                                    companyId, className, tableName, columnName, classPK,
2123                                    value.getDouble());
2124                    }
2125                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2126                            return expandoValueLocalService.getData(
2127                                    companyId, className, tableName, columnName, classPK,
2128                                    new double[0]);
2129                    }
2130                    else if (type == ExpandoColumnConstants.FLOAT) {
2131                            return expandoValueLocalService.getData(
2132                                    companyId, className, tableName, columnName, classPK,
2133                                    value.getFloat());
2134                    }
2135                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2136                            return expandoValueLocalService.getData(
2137                                    companyId, className, tableName, columnName, classPK,
2138                                    new float[0]);
2139                    }
2140                    else if (type == ExpandoColumnConstants.INTEGER) {
2141                            return expandoValueLocalService.getData(
2142                                    companyId, className, tableName, columnName, classPK,
2143                                    value.getInteger());
2144                    }
2145                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2146                            return expandoValueLocalService.getData(
2147                                    companyId, className, tableName, columnName, classPK,
2148                                    new int[0]);
2149                    }
2150                    else if (type == ExpandoColumnConstants.LONG) {
2151                            return expandoValueLocalService.getData(
2152                                    companyId, className, tableName, columnName, classPK,
2153                                    value.getLong());
2154                    }
2155                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2156                            return expandoValueLocalService.getData(
2157                                    companyId, className, tableName, columnName, classPK,
2158                                    new long[0]);
2159                    }
2160                    else if (type == ExpandoColumnConstants.NUMBER) {
2161                            return expandoValueLocalService.getData(
2162                                    companyId, className, tableName, columnName, classPK,
2163                                    value.getNumber());
2164                    }
2165                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2166                            return expandoValueLocalService.getData(
2167                                    companyId, className, tableName, columnName, classPK,
2168                                    new Number[0]);
2169                    }
2170                    else if (type == ExpandoColumnConstants.SHORT) {
2171                            return expandoValueLocalService.getData(
2172                                    companyId, className, tableName, columnName, classPK,
2173                                    value.getShort());
2174                    }
2175                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2176                            return expandoValueLocalService.getData(
2177                                    companyId, className, tableName, columnName, classPK,
2178                                    new short[0]);
2179                    }
2180                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2181                            return expandoValueLocalService.getData(
2182                                    companyId, className, tableName, columnName, classPK,
2183                                    new String[0]);
2184                    }
2185                    else if (type == ExpandoColumnConstants.STRING) {
2186                            return expandoValueLocalService.getData(
2187                                    companyId, className, tableName, columnName, classPK,
2188                                    value.getString());
2189                    }
2190                    else {
2191                            return (Serializable)expandoValueLocalService.getData(
2192                                    companyId, className, tableName, columnName, classPK,
2193                                    new HashMap<Object, Object>());
2194                    }
2195            }
2196    
2197    }