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