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