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