001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.expando.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.security.auth.CompanyThreadLocal;
020    import com.liferay.portal.util.PortalUtil;
021    import com.liferay.portlet.expando.model.ExpandoColumn;
022    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
023    import com.liferay.portlet.expando.model.ExpandoRow;
024    import com.liferay.portlet.expando.model.ExpandoTable;
025    import com.liferay.portlet.expando.model.ExpandoTableConstants;
026    import com.liferay.portlet.expando.model.ExpandoValue;
027    import com.liferay.portlet.expando.model.impl.ExpandoValueImpl;
028    import com.liferay.portlet.expando.service.base.ExpandoValueLocalServiceBaseImpl;
029    
030    import java.io.Serializable;
031    
032    import java.util.Collection;
033    import java.util.Collections;
034    import java.util.Date;
035    import java.util.HashMap;
036    import java.util.List;
037    import java.util.Map;
038    
039    /**
040     * @author Raymond Augé
041     * @author Brian Wing Shun Chan
042     * @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.NUMBER) {
914                                    value.setNumber((Number)attributeValue);
915                            }
916                            else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
917                                    value.setNumberArray((Number[])attributeValue);
918                            }
919                            else if (type == ExpandoColumnConstants.SHORT) {
920                                    value.setShort((Short)attributeValue);
921                            }
922                            else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
923                                    value.setShortArray((short[])attributeValue);
924                            }
925                            else if (type == ExpandoColumnConstants.STRING_ARRAY) {
926                                    value.setStringArray((String[])attributeValue);
927                            }
928                            else {
929                                    value.setString((String)attributeValue);
930                            }
931    
932                            doAddValue(
933                                    companyId, classNameId, table.getTableId(),
934                                    column.getColumnId(), classPK, value.getData());
935                    }
936            }
937    
938            public void addValues(
939                            long companyId, String className, String tableName, long classPK,
940                            Map<String, Serializable> attributes)
941                    throws PortalException, SystemException {
942    
943                    long classNameId = PortalUtil.getClassNameId(className);
944    
945                    addValues(companyId, classNameId, tableName, classPK, attributes);
946            }
947    
948            public void deleteColumnValues(long columnId) throws SystemException {
949                    List<ExpandoValue> values = expandoValuePersistence.findByColumnId(
950                            columnId);
951    
952                    for (ExpandoValue value : values) {
953                            deleteValue(value);
954                    }
955            }
956    
957            public void deleteRowValues(long rowId) throws SystemException {
958                    List<ExpandoValue> values = expandoValuePersistence.findByRowId(rowId);
959    
960                    for (ExpandoValue value : values) {
961                            deleteValue(value);
962                    }
963            }
964    
965            public void deleteTableValues(long tableId) throws SystemException {
966                    List<ExpandoValue> values = expandoValuePersistence.findByTableId(
967                            tableId);
968    
969                    for (ExpandoValue value : values) {
970                            deleteValue(value);
971                    }
972            }
973    
974            public void deleteValue(ExpandoValue value) throws SystemException {
975                    expandoValuePersistence.remove(value);
976            }
977    
978            public void deleteValue(long valueId)
979                    throws PortalException, SystemException {
980    
981                    ExpandoValue value = expandoValuePersistence.findByPrimaryKey(valueId);
982    
983                    deleteValue(value);
984            }
985    
986            public void deleteValue(long columnId, long rowId)
987                    throws PortalException, SystemException {
988    
989                    ExpandoValue value = expandoValuePersistence.findByC_R(columnId, rowId);
990    
991                    deleteValue(value);
992            }
993    
994            public void deleteValue(
995                            long companyId, long classNameId, String tableName,
996                            String columnName, long classPK)
997                    throws PortalException, SystemException {
998    
999                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1000                            companyId, classNameId, tableName);
1001    
1002                    if (table == null) {
1003                            return;
1004                    }
1005    
1006                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
1007                            table.getTableId(), columnName);
1008    
1009                    if (columns.isEmpty()) {
1010                            return;
1011                    }
1012    
1013                    ExpandoColumn column = columns.get(0);
1014    
1015                    ExpandoValue value = expandoValuePersistence.fetchByT_C_C(
1016                            table.getTableId(), column.getColumnId(), classPK);
1017    
1018                    if (value != null) {
1019                            deleteValue(value.getValueId());
1020                    }
1021            }
1022    
1023            public void deleteValue(
1024                            long companyId, String className, String tableName,
1025                            String columnName, long classPK)
1026                    throws PortalException, SystemException {
1027    
1028                    long classNameId = PortalUtil.getClassNameId(className);
1029    
1030                    expandoValueLocalService.deleteValue(
1031                            companyId, classNameId, tableName, columnName, classPK);
1032            }
1033    
1034            public void deleteValues(long classNameId, long classPK)
1035                    throws SystemException {
1036    
1037                    List<ExpandoValue> values = expandoValuePersistence.findByC_C(
1038                            classNameId, classPK);
1039    
1040                    for (ExpandoValue value : values) {
1041                            deleteValue(value);
1042                    }
1043            }
1044    
1045            public void deleteValues(String className, long classPK)
1046                    throws SystemException {
1047    
1048                    long classNameId = PortalUtil.getClassNameId(className);
1049    
1050                    expandoValueLocalService.deleteValues(classNameId, classPK);
1051            }
1052    
1053            public List<ExpandoValue> getColumnValues(long columnId, int start, int end)
1054                    throws SystemException {
1055    
1056                    return expandoValuePersistence.findByColumnId(columnId, start, end);
1057            }
1058    
1059            public List<ExpandoValue> getColumnValues(
1060                            long companyId, long classNameId, String tableName,
1061                            String columnName, int start, int end)
1062                    throws SystemException {
1063    
1064                    return expandoValueLocalService.getColumnValues(
1065                            companyId, classNameId, tableName, columnName, null, start, end);
1066            }
1067    
1068            public List<ExpandoValue> getColumnValues(
1069                            long companyId, long classNameId, String tableName,
1070                            String columnName, String data, int start, int end)
1071                    throws SystemException {
1072    
1073                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1074                            companyId, classNameId, tableName);
1075    
1076                    if (table == null) {
1077                            return Collections.emptyList();
1078                    }
1079    
1080                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
1081                            table.getTableId(), columnName);
1082    
1083                    if (columns.isEmpty()) {
1084                            return Collections.emptyList();
1085                    }
1086    
1087                    ExpandoColumn column = columns.get(0);
1088    
1089                    if (data == null) {
1090                            return expandoValuePersistence.findByT_C(
1091                                    table.getTableId(), column.getColumnId(), start, end);
1092                    }
1093                    else {
1094                            return expandoValuePersistence.findByT_C_D(
1095                                    table.getTableId(), column.getColumnId(), data, start, end);
1096                    }
1097            }
1098    
1099            public List<ExpandoValue> getColumnValues(
1100                            long companyId, String className, String tableName,
1101                            String columnName, int start, int end)
1102                    throws SystemException {
1103    
1104                    long classNameId = PortalUtil.getClassNameId(className);
1105    
1106                    return expandoValueLocalService.getColumnValues(
1107                            companyId, classNameId, tableName, columnName, start, end);
1108            }
1109    
1110            public List<ExpandoValue> getColumnValues(
1111                            long companyId, String className, String tableName,
1112                            String columnName, String data, int start, int end)
1113                    throws SystemException {
1114    
1115                    long classNameId = PortalUtil.getClassNameId(className);
1116    
1117                    return expandoValueLocalService.getColumnValues(
1118                            companyId, classNameId, tableName, columnName, data, start, end);
1119            }
1120    
1121            /**
1122             * @deprecated {@link #getColumnValues(long, String, String, String, String,
1123             *             int, int)}
1124             */
1125            public List<ExpandoValue> getColumnValues(
1126                            String className, String tableName, String columnName, String data,
1127                            int start, int end)
1128                    throws SystemException {
1129    
1130                    long companyId = CompanyThreadLocal.getCompanyId();
1131    
1132                    return expandoValueLocalService.getColumnValues(
1133                            companyId, className, tableName, columnName, data, start, end);
1134            }
1135    
1136            public int getColumnValuesCount(long columnId) throws SystemException {
1137                    return expandoValuePersistence.countByColumnId(columnId);
1138            }
1139    
1140            public int getColumnValuesCount(
1141                            long companyId, long classNameId, String tableName,
1142                            String columnName)
1143                    throws SystemException {
1144    
1145                    return expandoValueLocalService.getColumnValuesCount(
1146                            companyId, classNameId, tableName, columnName, null);
1147            }
1148    
1149            public int getColumnValuesCount(
1150                            long companyId, long classNameId, String tableName,
1151                            String columnName, String data)
1152                    throws SystemException {
1153    
1154                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1155                            companyId, classNameId, tableName);
1156    
1157                    if (table == null) {
1158                            return 0;
1159                    }
1160    
1161                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
1162                            table.getTableId(), columnName);
1163    
1164                    if (columns.isEmpty()) {
1165                            return 0;
1166                    }
1167    
1168                    ExpandoColumn column = columns.get(0);
1169    
1170                    if (data == null) {
1171                            return expandoValuePersistence.countByT_C(
1172                                    table.getTableId(), column.getColumnId());
1173                    }
1174                    else {
1175                            return expandoValuePersistence.countByT_C_D(
1176                                    table.getTableId(), column.getColumnId(), data);
1177                    }
1178            }
1179    
1180            public int getColumnValuesCount(
1181                            long companyId, String className, String tableName,
1182                            String columnName)
1183                    throws SystemException {
1184    
1185                    long classNameId = PortalUtil.getClassNameId(className);
1186    
1187                    return expandoValueLocalService.getColumnValuesCount(
1188                            companyId, classNameId, tableName, columnName);
1189            }
1190    
1191            public int getColumnValuesCount(
1192                            long companyId, String className, String tableName,
1193                            String columnName, String data)
1194                    throws SystemException {
1195    
1196                    long classNameId = PortalUtil.getClassNameId(className);
1197    
1198                    return expandoValueLocalService.getColumnValuesCount(
1199                            companyId, classNameId, tableName, columnName, data);
1200            }
1201    
1202            /**
1203             * @deprecated {@link #getColumnValuesCount(long, String, String, String,
1204             *             String)}
1205             */
1206            public int getColumnValuesCount(
1207                            String className, String tableName, String columnName, String data)
1208                    throws SystemException {
1209    
1210                    long companyId = CompanyThreadLocal.getCompanyId();
1211    
1212                    return expandoValueLocalService.getColumnValuesCount(
1213                            companyId, className, tableName, columnName, data);
1214            }
1215    
1216            public Map<String, Serializable> getData(
1217                            long companyId, String className, String tableName,
1218                            Collection<String> columnNames, long classPK)
1219                    throws PortalException, SystemException {
1220    
1221                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
1222                            companyId, className, tableName, columnNames);
1223    
1224                    Map<String, Serializable> attributeValues =
1225                            new HashMap<String, Serializable>((int)(columnNames.size() * 1.4));
1226    
1227                    ExpandoValue value = new ExpandoValueImpl();
1228    
1229                    for (ExpandoColumn column : columns) {
1230                            value.setColumn(column);
1231                            value.setData(column.getDefaultData());
1232    
1233                            Serializable attributeValue = doGetData(
1234                                    companyId, className, tableName, column.getName(), classPK,
1235                                    value, column.getType());
1236    
1237                            attributeValues.put(column.getName(), attributeValue);
1238                    }
1239    
1240                    return attributeValues;
1241            }
1242    
1243            public Serializable getData(
1244                            long companyId, String className, String tableName,
1245                            String columnName, long classPK)
1246                    throws PortalException, SystemException {
1247    
1248                    ExpandoColumn column = expandoColumnLocalService.getColumn(
1249                            companyId, className, tableName, columnName);
1250    
1251                    ExpandoValue value = new ExpandoValueImpl();
1252    
1253                    value.setColumn(column);
1254                    value.setData(column.getDefaultData());
1255    
1256                    return doGetData(
1257                            companyId, className, tableName, columnName, classPK, value,
1258                            column.getType());
1259            }
1260    
1261            public boolean getData(
1262                            long companyId, String className, String tableName,
1263                            String columnName, long classPK, boolean defaultData)
1264                    throws PortalException, SystemException {
1265    
1266                    ExpandoValue value = expandoValueLocalService.getValue(
1267                            companyId, className, tableName, columnName, classPK);
1268    
1269                    if (value == null) {
1270                            return defaultData;
1271                    }
1272                    else {
1273                            return value.getBoolean();
1274                    }
1275            }
1276    
1277            public boolean[] getData(
1278                            long companyId, String className, String tableName,
1279                            String columnName, long classPK, boolean[] defaultData)
1280                    throws PortalException, SystemException {
1281    
1282                    ExpandoValue value = expandoValueLocalService.getValue(
1283                            companyId, className, tableName, columnName, classPK);
1284    
1285                    if (value == null) {
1286                            return defaultData;
1287                    }
1288                    else {
1289                            return value.getBooleanArray();
1290                    }
1291            }
1292    
1293            public Date getData(
1294                            long companyId, String className, String tableName,
1295                            String columnName, long classPK, Date defaultData)
1296                    throws PortalException, SystemException {
1297    
1298                    ExpandoValue value = expandoValueLocalService.getValue(
1299                            companyId, className, tableName, columnName, classPK);
1300    
1301                    if (value == null) {
1302                            return defaultData;
1303                    }
1304                    else {
1305                            return value.getDate();
1306                    }
1307            }
1308    
1309            public Date[] getData(
1310                            long companyId, String className, String tableName,
1311                            String columnName, long classPK, Date[] defaultData)
1312                    throws PortalException, SystemException {
1313    
1314                    ExpandoValue value = expandoValueLocalService.getValue(
1315                            companyId, className, tableName, columnName, classPK);
1316    
1317                    if (value == null) {
1318                            return defaultData;
1319                    }
1320                    else {
1321                            return value.getDateArray();
1322                    }
1323            }
1324    
1325            public double getData(
1326                            long companyId, String className, String tableName,
1327                            String columnName, long classPK, double defaultData)
1328                    throws PortalException, SystemException {
1329    
1330                    ExpandoValue value = expandoValueLocalService.getValue(
1331                            companyId, className, tableName, columnName, classPK);
1332    
1333                    if (value == null) {
1334                            return defaultData;
1335                    }
1336                    else {
1337                            return value.getDouble();
1338                    }
1339            }
1340    
1341            public double[] getData(
1342                            long companyId, String className, String tableName,
1343                            String columnName, long classPK, double[] defaultData)
1344                    throws PortalException, SystemException {
1345    
1346                    ExpandoValue value = expandoValueLocalService.getValue(
1347                            companyId, className, tableName, columnName, classPK);
1348    
1349                    if (value == null) {
1350                            return defaultData;
1351                    }
1352                    else {
1353                            return value.getDoubleArray();
1354                    }
1355            }
1356    
1357            public float getData(
1358                            long companyId, String className, String tableName,
1359                            String columnName, long classPK, float defaultData)
1360                    throws PortalException, SystemException {
1361    
1362                    ExpandoValue value = expandoValueLocalService.getValue(
1363                            companyId, className, tableName, columnName, classPK);
1364    
1365                    if (value == null) {
1366                            return defaultData;
1367                    }
1368                    else {
1369                            return value.getFloat();
1370                    }
1371            }
1372    
1373            public float[] getData(
1374                            long companyId, String className, String tableName,
1375                            String columnName, long classPK, float[] defaultData)
1376                    throws PortalException, SystemException {
1377    
1378                    ExpandoValue value = expandoValueLocalService.getValue(
1379                            companyId, className, tableName, columnName, classPK);
1380    
1381                    if (value == null) {
1382                            return defaultData;
1383                    }
1384                    else {
1385                            return value.getFloatArray();
1386                    }
1387            }
1388    
1389            public int getData(
1390                            long companyId, String className, String tableName,
1391                            String columnName, long classPK, int defaultData)
1392                    throws PortalException, SystemException {
1393    
1394                    ExpandoValue value = expandoValueLocalService.getValue(
1395                            companyId, className, tableName, columnName, classPK);
1396    
1397                    if (value == null) {
1398                            return defaultData;
1399                    }
1400                    else {
1401                            return value.getInteger();
1402                    }
1403            }
1404    
1405            public int[] getData(
1406                            long companyId, String className, String tableName,
1407                            String columnName, long classPK, int[] defaultData)
1408                    throws PortalException, SystemException {
1409    
1410                    ExpandoValue value = expandoValueLocalService.getValue(
1411                            companyId, className, tableName, columnName, classPK);
1412    
1413                    if (value == null) {
1414                            return defaultData;
1415                    }
1416                    else {
1417                            return value.getIntegerArray();
1418                    }
1419            }
1420    
1421            public long getData(
1422                            long companyId, String className, String tableName,
1423                            String columnName, long classPK, long defaultData)
1424                    throws PortalException, SystemException {
1425    
1426                    ExpandoValue value = expandoValueLocalService.getValue(
1427                            companyId, className, tableName, columnName, classPK);
1428    
1429                    if (value == null) {
1430                            return defaultData;
1431                    }
1432                    else {
1433                            return value.getLong();
1434                    }
1435            }
1436    
1437            public long[] getData(
1438                            long companyId, String className, String tableName,
1439                            String columnName, long classPK, long[] defaultData)
1440                    throws PortalException, SystemException {
1441    
1442                    ExpandoValue value = expandoValueLocalService.getValue(
1443                            companyId, className, tableName, columnName, classPK);
1444    
1445                    if (value == null) {
1446                            return defaultData;
1447                    }
1448                    else {
1449                            return value.getLongArray();
1450                    }
1451            }
1452    
1453            public Number getData(
1454                            long companyId, String className, String tableName,
1455                            String columnName, long classPK, Number defaultData)
1456                    throws PortalException, SystemException {
1457    
1458                    ExpandoValue value = expandoValueLocalService.getValue(
1459                            companyId, className, tableName, columnName, classPK);
1460    
1461                    if (value == null) {
1462                            return defaultData;
1463                    }
1464                    else {
1465                            return value.getNumber();
1466                    }
1467            }
1468    
1469            public Number[] getData(
1470                            long companyId, String className, String tableName,
1471                            String columnName, long classPK, Number[] defaultData)
1472                    throws PortalException, SystemException {
1473    
1474                    ExpandoValue value = expandoValueLocalService.getValue(
1475                            companyId, className, tableName, columnName, classPK);
1476    
1477                    if (value == null) {
1478                            return defaultData;
1479                    }
1480                    else {
1481                            return value.getNumberArray();
1482                    }
1483            }
1484    
1485            public short getData(
1486                            long companyId, String className, String tableName,
1487                            String columnName, long classPK, short defaultData)
1488                    throws PortalException, SystemException {
1489    
1490                    ExpandoValue value = expandoValueLocalService.getValue(
1491                            companyId, className, tableName, columnName, classPK);
1492    
1493                    if (value == null) {
1494                            return defaultData;
1495                    }
1496                    else {
1497                            return value.getShort();
1498                    }
1499            }
1500    
1501            public short[] getData(
1502                            long companyId, String className, String tableName,
1503                            String columnName, long classPK, short[] defaultData)
1504                    throws PortalException, SystemException {
1505    
1506                    ExpandoValue value = expandoValueLocalService.getValue(
1507                            companyId, className, tableName, columnName, classPK);
1508    
1509                    if (value == null) {
1510                            return defaultData;
1511                    }
1512                    else {
1513                            return value.getShortArray();
1514                    }
1515            }
1516    
1517            public String getData(
1518                            long companyId, String className, String tableName,
1519                            String columnName, long classPK, String defaultData)
1520                    throws PortalException, SystemException {
1521    
1522                    ExpandoValue value = expandoValueLocalService.getValue(
1523                            companyId, className, tableName, columnName, classPK);
1524    
1525                    if (value == null) {
1526                            return defaultData;
1527                    }
1528                    else {
1529                            return value.getString();
1530                    }
1531            }
1532    
1533            public String[] getData(
1534                            long companyId, String className, String tableName,
1535                            String columnName, long classPK, String[] defaultData)
1536                    throws PortalException, SystemException {
1537    
1538                    ExpandoValue value = expandoValueLocalService.getValue(
1539                            companyId, className, tableName, columnName, classPK);
1540    
1541                    if (value == null) {
1542                            return defaultData;
1543                    }
1544                    else {
1545                            return value.getStringArray();
1546                    }
1547            }
1548    
1549            /**
1550             * @deprecated {@link #getData(long, String, String, String, long)}
1551             */
1552            public Serializable getData(
1553                            String className, String tableName, String columnName, long classPK)
1554                    throws PortalException, SystemException {
1555    
1556                    long companyId = CompanyThreadLocal.getCompanyId();
1557    
1558                    return expandoValueLocalService.getData(
1559                            companyId, className, tableName, columnName, classPK);
1560            }
1561    
1562            /**
1563             * @deprecated {@link #getData(long, String, String, String, long,
1564             *             boolean[])}
1565             */
1566            public boolean getData(
1567                            String className, String tableName, String columnName, long classPK,
1568                            boolean defaultData)
1569                    throws PortalException, SystemException {
1570    
1571                    long companyId = CompanyThreadLocal.getCompanyId();
1572    
1573                    return expandoValueLocalService.getData(
1574                            companyId, className, tableName, columnName, classPK, defaultData);
1575            }
1576    
1577            /**
1578             * @deprecated {@link #getData(long, String, String, String, long,
1579             *             boolean[])}
1580             */
1581            public boolean[] getData(
1582                            String className, String tableName, String columnName, long classPK,
1583                            boolean[] defaultData)
1584                    throws PortalException, SystemException {
1585    
1586                    long companyId = CompanyThreadLocal.getCompanyId();
1587    
1588                    return expandoValueLocalService.getData(
1589                            companyId, className, tableName, columnName, classPK, defaultData);
1590            }
1591    
1592            /**
1593             * @deprecated {@link #getData(long, String, String, String, long, Date[])}
1594             */
1595            public Date getData(
1596                            String className, String tableName, String columnName, long classPK,
1597                            Date defaultData)
1598                    throws PortalException, SystemException {
1599    
1600                    long companyId = CompanyThreadLocal.getCompanyId();
1601    
1602                    return expandoValueLocalService.getData(
1603                            companyId, className, tableName, columnName, classPK, defaultData);
1604            }
1605    
1606            /**
1607             * @deprecated {@link #getData(long, String, String, String, long, Date[])}
1608             */
1609            public Date[] getData(
1610                            String className, String tableName, String columnName, long classPK,
1611                            Date[] defaultData)
1612                    throws PortalException, SystemException {
1613    
1614                    long companyId = CompanyThreadLocal.getCompanyId();
1615    
1616                    return expandoValueLocalService.getData(
1617                            companyId, className, tableName, columnName, classPK, defaultData);
1618            }
1619    
1620            /**
1621             * @deprecated {@link #getData(long, String, String, String, long,
1622             *             double[])}
1623             */
1624            public double getData(
1625                            String className, String tableName, String columnName, long classPK,
1626                            double defaultData)
1627                    throws PortalException, SystemException {
1628    
1629                    long companyId = CompanyThreadLocal.getCompanyId();
1630    
1631                    return expandoValueLocalService.getData(
1632                            companyId, className, tableName, columnName, classPK, defaultData);
1633            }
1634    
1635            /**
1636             * @deprecated {@link #getData(long, String, String, String, long,
1637             *             double[])}
1638             */
1639            public double[] getData(
1640                            String className, String tableName, String columnName, long classPK,
1641                            double[] defaultData)
1642                    throws PortalException, SystemException {
1643    
1644                    long companyId = CompanyThreadLocal.getCompanyId();
1645    
1646                    return expandoValueLocalService.getData(
1647                            companyId, className, tableName, columnName, classPK, defaultData);
1648            }
1649    
1650            /**
1651             * @deprecated {@link #getData(long, String, String, String, long, float[])}
1652             */
1653            public float getData(
1654                            String className, String tableName, String columnName, long classPK,
1655                            float defaultData)
1656                    throws PortalException, SystemException {
1657    
1658                    long companyId = CompanyThreadLocal.getCompanyId();
1659    
1660                    return expandoValueLocalService.getData(
1661                            companyId, className, tableName, columnName, classPK, defaultData);
1662            }
1663    
1664            /**
1665             * @deprecated {@link #getData(long, String, String, String, long, float[])}
1666             */
1667            public float[] getData(
1668                            String className, String tableName, String columnName, long classPK,
1669                            float[] defaultData)
1670                    throws PortalException, SystemException {
1671    
1672                    long companyId = CompanyThreadLocal.getCompanyId();
1673    
1674                    return expandoValueLocalService.getData(
1675                            companyId, className, tableName, columnName, classPK, defaultData);
1676            }
1677    
1678            /**
1679             * @deprecated {@link #getData(long, String, String, String, long, int[])}
1680             */
1681            public int getData(
1682                            String className, String tableName, String columnName, long classPK,
1683                            int defaultData)
1684                    throws PortalException, SystemException {
1685    
1686                    long companyId = CompanyThreadLocal.getCompanyId();
1687    
1688                    return expandoValueLocalService.getData(
1689                            companyId, className, tableName, columnName, classPK, defaultData);
1690            }
1691    
1692            /**
1693             * @deprecated {@link #getData(long, String, String, String, long, int[])}
1694             */
1695            public int[] getData(
1696                            String className, String tableName, String columnName, long classPK,
1697                            int[] defaultData)
1698                    throws PortalException, SystemException {
1699    
1700                    long companyId = CompanyThreadLocal.getCompanyId();
1701    
1702                    return expandoValueLocalService.getData(
1703                            companyId, className, tableName, columnName, classPK, defaultData);
1704            }
1705    
1706            /**
1707             * @deprecated {@link #getData(long, String, String, String, long, long[])}
1708             */
1709            public long getData(
1710                            String className, String tableName, String columnName, long classPK,
1711                            long defaultData)
1712                    throws PortalException, SystemException {
1713    
1714                    long companyId = CompanyThreadLocal.getCompanyId();
1715    
1716                    return expandoValueLocalService.getData(
1717                            companyId, className, tableName, columnName, classPK, defaultData);
1718            }
1719    
1720            /**
1721             * @deprecated {@link #getData(long, String, String, String, long, long[])}
1722             */
1723            public long[] getData(
1724                            String className, String tableName, String columnName, long classPK,
1725                            long[] defaultData)
1726                    throws PortalException, SystemException {
1727    
1728                    long companyId = CompanyThreadLocal.getCompanyId();
1729    
1730                    return expandoValueLocalService.getData(
1731                            companyId, className, tableName, columnName, classPK, defaultData);
1732            }
1733    
1734            /**
1735             * @deprecated {@link #getData(long, String, String, String, long, short[])}
1736             */
1737            public short getData(
1738                            String className, String tableName, String columnName, long classPK,
1739                            short defaultData)
1740                    throws PortalException, SystemException {
1741    
1742                    long companyId = CompanyThreadLocal.getCompanyId();
1743    
1744                    return expandoValueLocalService.getData(
1745                            companyId, className, tableName, columnName, classPK, defaultData);
1746            }
1747    
1748            /**
1749             * @deprecated {@link #getData(long, String, String, String, long, short[])}
1750             */
1751            public short[] getData(
1752                            String className, String tableName, String columnName, long classPK,
1753                            short[] defaultData)
1754                    throws PortalException, SystemException {
1755    
1756                    long companyId = CompanyThreadLocal.getCompanyId();
1757    
1758                    return expandoValueLocalService.getData(
1759                            companyId, className, tableName, columnName, classPK, defaultData);
1760            }
1761    
1762            /**
1763             * @deprecated {@link #getData(long, String, String, String, long,
1764             *             String[])}
1765             */
1766            public String getData(
1767                            String className, String tableName, String columnName, long classPK,
1768                            String defaultData)
1769                    throws PortalException, SystemException {
1770    
1771                    long companyId = CompanyThreadLocal.getCompanyId();
1772    
1773                    return expandoValueLocalService.getData(
1774                            companyId, className, tableName, columnName, classPK, defaultData);
1775            }
1776    
1777            /**
1778             * @deprecated {@link #getData(long, String, String, String, long,
1779             *             String[])}
1780             */
1781            public String[] getData(
1782                            String className, String tableName, String columnName, long classPK,
1783                            String[] defaultData)
1784                    throws PortalException, SystemException {
1785    
1786                    long companyId = CompanyThreadLocal.getCompanyId();
1787    
1788                    return expandoValueLocalService.getData(
1789                            companyId, className, tableName, columnName, classPK, defaultData);
1790            }
1791    
1792            public List<ExpandoValue> getDefaultTableColumnValues(
1793                            long companyId, long classNameId, String columnName, int start,
1794                            int end)
1795                    throws SystemException {
1796    
1797                    return expandoValueLocalService.getColumnValues(
1798                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
1799                            columnName, start, end);
1800            }
1801    
1802            public List<ExpandoValue> getDefaultTableColumnValues(
1803                            long companyId, String className, String columnName, int start,
1804                            int end)
1805                    throws SystemException {
1806    
1807                    long classNameId = PortalUtil.getClassNameId(className);
1808    
1809                    return expandoValueLocalService.getDefaultTableColumnValues(
1810                            companyId, classNameId, columnName, start, end);
1811            }
1812    
1813            public int getDefaultTableColumnValuesCount(
1814                            long companyId, long classNameId, String columnName)
1815                    throws SystemException {
1816    
1817                    return expandoValueLocalService.getColumnValuesCount(
1818                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
1819                            columnName);
1820            }
1821    
1822            public int getDefaultTableColumnValuesCount(
1823                            long companyId, String className, String columnName)
1824                    throws SystemException {
1825    
1826                    long classNameId = PortalUtil.getClassNameId(className);
1827    
1828                    return expandoValueLocalService.getDefaultTableColumnValuesCount(
1829                            companyId, classNameId, columnName);
1830            }
1831    
1832            public List<ExpandoValue> getRowValues(long rowId) throws SystemException {
1833                    return expandoValuePersistence.findByRowId(rowId);
1834            }
1835    
1836            public List<ExpandoValue> getRowValues(long rowId, int start, int end)
1837                    throws SystemException {
1838    
1839                    return expandoValuePersistence.findByRowId(rowId, start, end);
1840            }
1841    
1842            public List<ExpandoValue> getRowValues(
1843                            long companyId, long classNameId, String tableName, long classPK,
1844                            int start, int end)
1845                    throws SystemException {
1846    
1847                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1848                            companyId, classNameId, tableName);
1849    
1850                    if (table == null) {
1851                            return Collections.emptyList();
1852                    }
1853    
1854                    return expandoValuePersistence.findByT_CPK(
1855                            table.getTableId(), classPK, start, end);
1856            }
1857    
1858            public List<ExpandoValue> getRowValues(
1859                            long companyId, String className, String tableName, long classPK,
1860                            int start, int end)
1861                    throws SystemException {
1862    
1863                    long classNameId = PortalUtil.getClassNameId(className);
1864    
1865                    return expandoValueLocalService.getRowValues(
1866                            companyId, classNameId, tableName, classPK, start, end);
1867            }
1868    
1869            public int getRowValuesCount(long rowId) throws SystemException {
1870                    return expandoValuePersistence.countByRowId(rowId);
1871            }
1872    
1873            public int getRowValuesCount(
1874                            long companyId, long classNameId, String tableName, long classPK)
1875                    throws SystemException {
1876    
1877                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1878                            companyId, classNameId, tableName);
1879    
1880                    if (table == null) {
1881                            return 0;
1882                    }
1883    
1884                    return expandoValuePersistence.countByT_CPK(
1885                            table.getTableId(), classPK);
1886            }
1887    
1888            public int getRowValuesCount(
1889                            long companyId, String className, String tableName, long classPK)
1890                    throws SystemException {
1891    
1892                    long classNameId = PortalUtil.getClassNameId(className);
1893    
1894                    return expandoValueLocalService.getRowValuesCount(
1895                            companyId, classNameId, tableName, classPK);
1896            }
1897    
1898            public ExpandoValue getValue(long valueId)
1899                    throws PortalException, SystemException {
1900    
1901                    return expandoValuePersistence.findByPrimaryKey(valueId);
1902            }
1903    
1904            public ExpandoValue getValue(long columnId, long rowId)
1905                    throws PortalException, SystemException {
1906    
1907                    return expandoValuePersistence.findByC_R(columnId, rowId);
1908            }
1909    
1910            public ExpandoValue getValue(long tableId, long columnId, long classPK)
1911                    throws SystemException {
1912    
1913                    return expandoValuePersistence.fetchByT_C_C(tableId, columnId, classPK);
1914            }
1915    
1916            public ExpandoValue getValue(
1917                            long companyId, long classNameId, String tableName,
1918                            String columnName, long classPK)
1919                    throws SystemException {
1920    
1921                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1922                            companyId, classNameId, tableName);
1923    
1924                    if (table == null) {
1925                            return null;
1926                    }
1927    
1928                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
1929                            table.getTableId(), columnName);
1930    
1931                    if (columns.isEmpty()) {
1932                            return null;
1933                    }
1934    
1935                    ExpandoColumn column = columns.get(0);
1936    
1937                    return expandoValuePersistence.fetchByT_C_C(
1938                            table.getTableId(), column.getColumnId(), classPK);
1939            }
1940    
1941            /**
1942             * @deprecated {@link #getValue(long, long, String, String, long)}
1943             */
1944            public ExpandoValue getValue(
1945                            long classNameId, String tableName, String columnName, long classPK)
1946                    throws SystemException {
1947    
1948                    long companyId = CompanyThreadLocal.getCompanyId();
1949    
1950                    return expandoValueLocalService.getValue(
1951                            companyId, classNameId, tableName, columnName, classPK);
1952            }
1953    
1954            public ExpandoValue getValue(
1955                            long companyId, String className, String tableName,
1956                            String columnName, long classPK)
1957                    throws SystemException {
1958    
1959                    long classNameId = PortalUtil.getClassNameId(className);
1960    
1961                    return expandoValueLocalService.getValue(
1962                            companyId, classNameId, tableName, columnName, classPK);
1963            }
1964    
1965            /**
1966             * @deprecated {@link #getValue(long, String, String, String, long)}
1967             */
1968            public ExpandoValue getValue(
1969                            String className, String tableName, String columnName, long classPK)
1970                    throws SystemException {
1971    
1972                    long companyId = CompanyThreadLocal.getCompanyId();
1973    
1974                    return expandoValueLocalService.getValue(
1975                            companyId, className, tableName, columnName, classPK);
1976            }
1977    
1978            protected ExpandoValue doAddValue(
1979                            long companyId, long classNameId, long tableId, long columnId,
1980                            long classPK, String data)
1981                    throws SystemException {
1982    
1983                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
1984    
1985                    if (row == null) {
1986                            long rowId = counterLocalService.increment();
1987    
1988                            row = expandoRowPersistence.create(rowId);
1989    
1990                            row.setCompanyId(companyId);
1991                            row.setTableId(tableId);
1992                            row.setClassPK(classPK);
1993    
1994                            expandoRowPersistence.update(row, false);
1995                    }
1996    
1997                    ExpandoValue value = expandoValuePersistence.fetchByC_R(
1998                            columnId, row.getRowId());
1999    
2000                    if (value == null) {
2001                            long valueId = counterLocalService.increment();
2002    
2003                            value = expandoValuePersistence.create(valueId);
2004    
2005                            value.setCompanyId(companyId);
2006                            value.setTableId(tableId);
2007                            value.setColumnId(columnId);
2008                            value.setRowId(row.getRowId());
2009                            value.setClassNameId(classNameId);
2010                            value.setClassPK(classPK);
2011                    }
2012    
2013                    value.setData(data);
2014    
2015                    expandoValuePersistence.update(value, false);
2016    
2017                    return value;
2018            }
2019    
2020            protected Serializable doGetData(
2021                            long companyId, String className, String tableName,
2022                            String columnName, long classPK, ExpandoValue value, int type)
2023                    throws PortalException, SystemException {
2024    
2025                    if (type == ExpandoColumnConstants.BOOLEAN) {
2026                            return expandoValueLocalService.getData(
2027                                    companyId, className, tableName, columnName, classPK,
2028                                    value.getBoolean());
2029                    }
2030                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2031                            return expandoValueLocalService.getData(
2032                                    companyId, className, tableName, columnName, classPK,
2033                                    new boolean[0]);
2034                    }
2035                    else if (type == ExpandoColumnConstants.DATE) {
2036                            return expandoValueLocalService.getData(
2037                                    companyId, className, tableName, columnName, classPK,
2038                                    value.getDate());
2039                    }
2040                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2041                            return expandoValueLocalService.getData(
2042                                    companyId, className, tableName, columnName, classPK,
2043                                    new Date[0]);
2044                    }
2045                    else if (type == ExpandoColumnConstants.DOUBLE) {
2046                            return expandoValueLocalService.getData(
2047                                    companyId, className, tableName, columnName, classPK,
2048                                    value.getDouble());
2049                    }
2050                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2051                            return expandoValueLocalService.getData(
2052                                    companyId, className, tableName, columnName, classPK,
2053                                    new double[0]);
2054                    }
2055                    else if (type == ExpandoColumnConstants.FLOAT) {
2056                            return expandoValueLocalService.getData(
2057                                    companyId, className, tableName, columnName, classPK,
2058                                    value.getFloat());
2059                    }
2060                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2061                            return expandoValueLocalService.getData(
2062                                    companyId, className, tableName, columnName, classPK,
2063                                    new float[0]);
2064                    }
2065                    else if (type == ExpandoColumnConstants.INTEGER) {
2066                            return expandoValueLocalService.getData(
2067                                    companyId, className, tableName, columnName, classPK,
2068                                    value.getInteger());
2069                    }
2070                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2071                            return expandoValueLocalService.getData(
2072                                    companyId, className, tableName, columnName, classPK,
2073                                    new int[0]);
2074                    }
2075                    else if (type == ExpandoColumnConstants.LONG) {
2076                            return expandoValueLocalService.getData(
2077                                    companyId, className, tableName, columnName, classPK,
2078                                    value.getLong());
2079                    }
2080                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2081                            return expandoValueLocalService.getData(
2082                                    companyId, className, tableName, columnName, classPK,
2083                                    new long[0]);
2084                    }
2085                    else if (type == ExpandoColumnConstants.NUMBER) {
2086                            return expandoValueLocalService.getData(
2087                                    companyId, className, tableName, columnName, classPK,
2088                                    value.getNumber());
2089                    }
2090                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2091                            return expandoValueLocalService.getData(
2092                                    companyId, className, tableName, columnName, classPK,
2093                                    new Number[0]);
2094                    }
2095                    else if (type == ExpandoColumnConstants.SHORT) {
2096                            return expandoValueLocalService.getData(
2097                                    companyId, className, tableName, columnName, classPK,
2098                                    value.getShort());
2099                    }
2100                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2101                            return expandoValueLocalService.getData(
2102                                    companyId, className, tableName, columnName, classPK,
2103                                    new short[0]);
2104                    }
2105                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2106                            return expandoValueLocalService.getData(
2107                                    companyId, className, tableName, columnName, classPK,
2108                                    new String[0]);
2109                    }
2110                    else {
2111                            return expandoValueLocalService.getData(
2112                                    companyId, className, tableName, columnName, classPK,
2113                                    value.getString());
2114                    }
2115            }
2116    
2117    }