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