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.expando.kernel.model.ExpandoColumn;
018    import com.liferay.expando.kernel.model.ExpandoColumnConstants;
019    import com.liferay.expando.kernel.model.ExpandoRow;
020    import com.liferay.expando.kernel.model.ExpandoTable;
021    import com.liferay.expando.kernel.model.ExpandoTableConstants;
022    import com.liferay.expando.kernel.model.ExpandoValue;
023    import com.liferay.portal.kernel.exception.PortalException;
024    import com.liferay.portal.kernel.util.StringPool;
025    import com.liferay.portal.typeconverter.DateArrayConverter;
026    import com.liferay.portal.typeconverter.NumberArrayConverter;
027    import com.liferay.portal.typeconverter.NumberConverter;
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.Locale;
039    import java.util.Map;
040    import java.util.Objects;
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() || !Objects.equals(value.getData(), dataString)) {
687                                    value.setData(dataString);
688    
689                                    expandoValuePersistence.update(value);
690    
691                                    rowModified = true;
692                            }
693                    }
694    
695                    if (rowModified) {
696                            row.setModifiedDate(new Date());
697    
698                            expandoRowPersistence.update(row);
699                    }
700            }
701    
702            @Override
703            public void addValues(
704                            long companyId, long classNameId, String tableName, long classPK,
705                            Map<String, Serializable> attributes)
706                    throws PortalException {
707    
708                    ExpandoTable table = expandoTableLocalService.getTable(
709                            companyId, classNameId, tableName);
710    
711                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
712                            table.getTableId(), attributes.keySet());
713    
714                    ExpandoValue value = new ExpandoValueImpl();
715    
716                    value.setCompanyId(companyId);
717    
718                    for (ExpandoColumn column : columns) {
719                            Serializable attributeValue = attributes.get(column.getName());
720    
721                            value.setColumn(column);
722    
723                            int type = column.getType();
724    
725                            if (type == ExpandoColumnConstants.BOOLEAN) {
726                                    value.setBoolean((Boolean)attributeValue);
727                            }
728                            else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
729                                    value.setBooleanArray((boolean[])attributeValue);
730                            }
731                            else if (type == ExpandoColumnConstants.DATE) {
732                                    value.setDate((Date)attributeValue);
733                            }
734                            else if (type == ExpandoColumnConstants.DATE_ARRAY) {
735                                    value.setDateArray((Date[])attributeValue);
736                            }
737                            else if (type == ExpandoColumnConstants.DOUBLE) {
738                                    value.setDouble((Double)attributeValue);
739                            }
740                            else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
741                                    value.setDoubleArray((double[])attributeValue);
742                            }
743                            else if (type == ExpandoColumnConstants.FLOAT) {
744                                    value.setFloat((Float)attributeValue);
745                            }
746                            else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
747                                    value.setFloatArray((float[])attributeValue);
748                            }
749                            else if (type == ExpandoColumnConstants.INTEGER) {
750                                    value.setInteger((Integer)attributeValue);
751                            }
752                            else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
753                                    value.setIntegerArray((int[])attributeValue);
754                            }
755                            else if (type == ExpandoColumnConstants.LONG) {
756                                    value.setLong((Long)attributeValue);
757                            }
758                            else if (type == ExpandoColumnConstants.LONG_ARRAY) {
759                                    value.setLongArray((long[])attributeValue);
760                            }
761                            else if (type == ExpandoColumnConstants.NUMBER) {
762                                    value.setNumber((Number)attributeValue);
763                            }
764                            else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
765                                    value.setNumberArray((Number[])attributeValue);
766                            }
767                            else if (type == ExpandoColumnConstants.SHORT) {
768                                    value.setShort((Short)attributeValue);
769                            }
770                            else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
771                                    value.setShortArray((short[])attributeValue);
772                            }
773                            else if (type == ExpandoColumnConstants.STRING_ARRAY) {
774                                    value.setStringArray((String[])attributeValue);
775                            }
776                            else if (type == ExpandoColumnConstants.STRING_LOCALIZED) {
777                                    value.setStringMap(
778                                            (Map<Locale, String>)attributeValue, Locale.getDefault());
779                            }
780                            else {
781                                    value.setString((String)attributeValue);
782                            }
783    
784                            doAddValue(
785                                    companyId, classNameId, table.getTableId(),
786                                    column.getColumnId(), classPK, value.getData());
787                    }
788            }
789    
790            @Override
791            public void addValues(
792                            long companyId, String className, String tableName, long classPK,
793                            Map<String, Serializable> attributes)
794                    throws PortalException {
795    
796                    long classNameId = classNameLocalService.getClassNameId(className);
797    
798                    addValues(companyId, classNameId, tableName, classPK, attributes);
799            }
800    
801            @Override
802            public void deleteColumnValues(long columnId) {
803                    List<ExpandoValue> values = expandoValuePersistence.findByColumnId(
804                            columnId);
805    
806                    for (ExpandoValue value : values) {
807                            deleteValue(value);
808                    }
809            }
810    
811            @Override
812            public void deleteRowValues(long rowId) {
813                    List<ExpandoValue> values = expandoValuePersistence.findByRowId(rowId);
814    
815                    for (ExpandoValue value : values) {
816                            deleteValue(value);
817                    }
818            }
819    
820            @Override
821            public void deleteTableValues(long tableId) {
822                    List<ExpandoValue> values = expandoValuePersistence.findByTableId(
823                            tableId);
824    
825                    for (ExpandoValue value : values) {
826                            deleteValue(value);
827                    }
828            }
829    
830            @Override
831            public void deleteValue(ExpandoValue value) {
832                    expandoValuePersistence.remove(value);
833            }
834    
835            @Override
836            public void deleteValue(long valueId) throws PortalException {
837                    ExpandoValue value = expandoValuePersistence.findByPrimaryKey(valueId);
838    
839                    deleteValue(value);
840            }
841    
842            @Override
843            public void deleteValue(long columnId, long rowId) throws PortalException {
844                    ExpandoValue value = expandoValuePersistence.findByC_R(columnId, rowId);
845    
846                    deleteValue(value);
847            }
848    
849            @Override
850            public void deleteValue(
851                            long companyId, long classNameId, String tableName,
852                            String columnName, long classPK)
853                    throws PortalException {
854    
855                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
856                            companyId, classNameId, tableName);
857    
858                    if (table == null) {
859                            return;
860                    }
861    
862                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
863                            table.getTableId(), columnName);
864    
865                    if (column == null) {
866                            return;
867                    }
868    
869                    ExpandoValue value = expandoValuePersistence.fetchByT_C_C(
870                            table.getTableId(), column.getColumnId(), classPK);
871    
872                    if (value != null) {
873                            deleteValue(value.getValueId());
874                    }
875            }
876    
877            @Override
878            public void deleteValue(
879                            long companyId, String className, String tableName,
880                            String columnName, long classPK)
881                    throws PortalException {
882    
883                    long classNameId = classNameLocalService.getClassNameId(className);
884    
885                    expandoValueLocalService.deleteValue(
886                            companyId, classNameId, tableName, columnName, classPK);
887            }
888    
889            @Override
890            public void deleteValues(long classNameId, long classPK) {
891                    List<ExpandoValue> values = expandoValuePersistence.findByC_C(
892                            classNameId, classPK);
893    
894                    for (ExpandoValue value : values) {
895                            deleteValue(value);
896                    }
897            }
898    
899            @Override
900            public void deleteValues(String className, long classPK) {
901                    long classNameId = classNameLocalService.getClassNameId(className);
902    
903                    expandoValueLocalService.deleteValues(classNameId, classPK);
904            }
905    
906            @Override
907            public List<ExpandoValue> getColumnValues(
908                    long columnId, int start, int end) {
909    
910                    return expandoValuePersistence.findByColumnId(columnId, start, end);
911            }
912    
913            @Override
914            public List<ExpandoValue> getColumnValues(
915                    long companyId, long classNameId, String tableName, String columnName,
916                    int start, int end) {
917    
918                    return expandoValueLocalService.getColumnValues(
919                            companyId, classNameId, tableName, columnName, null, start, end);
920            }
921    
922            @Override
923            public List<ExpandoValue> getColumnValues(
924                    long companyId, long classNameId, String tableName, String columnName,
925                    String data, int start, int end) {
926    
927                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
928                            companyId, classNameId, tableName);
929    
930                    if (table == null) {
931                            return Collections.emptyList();
932                    }
933    
934                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
935                            table.getTableId(), columnName);
936    
937                    if (column == null) {
938                            return Collections.emptyList();
939                    }
940    
941                    if (data == null) {
942                            return expandoValuePersistence.findByT_C(
943                                    table.getTableId(), column.getColumnId(), start, end);
944                    }
945                    else {
946                            return expandoValuePersistence.findByT_C_D(
947                                    table.getTableId(), column.getColumnId(), data, start, end);
948                    }
949            }
950    
951            @Override
952            public List<ExpandoValue> getColumnValues(
953                    long companyId, String className, String tableName, String columnName,
954                    int start, int end) {
955    
956                    long classNameId = classNameLocalService.getClassNameId(className);
957    
958                    return expandoValueLocalService.getColumnValues(
959                            companyId, classNameId, tableName, columnName, start, end);
960            }
961    
962            @Override
963            public List<ExpandoValue> getColumnValues(
964                    long companyId, String className, String tableName, String columnName,
965                    String data, int start, int end) {
966    
967                    long classNameId = classNameLocalService.getClassNameId(className);
968    
969                    return expandoValueLocalService.getColumnValues(
970                            companyId, classNameId, tableName, columnName, data, start, end);
971            }
972    
973            @Override
974            public int getColumnValuesCount(long columnId) {
975                    return expandoValuePersistence.countByColumnId(columnId);
976            }
977    
978            @Override
979            public int getColumnValuesCount(
980                    long companyId, long classNameId, String tableName, String columnName) {
981    
982                    return expandoValueLocalService.getColumnValuesCount(
983                            companyId, classNameId, tableName, columnName, null);
984            }
985    
986            @Override
987            public int getColumnValuesCount(
988                    long companyId, long classNameId, String tableName, String columnName,
989                    String data) {
990    
991                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
992                            companyId, classNameId, tableName);
993    
994                    if (table == null) {
995                            return 0;
996                    }
997    
998                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
999                            table.getTableId(), columnName);
1000    
1001                    if (column == null) {
1002                            return 0;
1003                    }
1004    
1005                    if (data == null) {
1006                            return expandoValuePersistence.countByT_C(
1007                                    table.getTableId(), column.getColumnId());
1008                    }
1009                    else {
1010                            return expandoValuePersistence.countByT_C_D(
1011                                    table.getTableId(), column.getColumnId(), data);
1012                    }
1013            }
1014    
1015            @Override
1016            public int getColumnValuesCount(
1017                    long companyId, String className, String tableName, String columnName) {
1018    
1019                    long classNameId = classNameLocalService.getClassNameId(className);
1020    
1021                    return expandoValueLocalService.getColumnValuesCount(
1022                            companyId, classNameId, tableName, columnName);
1023            }
1024    
1025            @Override
1026            public int getColumnValuesCount(
1027                    long companyId, String className, String tableName, String columnName,
1028                    String data) {
1029    
1030                    long classNameId = classNameLocalService.getClassNameId(className);
1031    
1032                    return expandoValueLocalService.getColumnValuesCount(
1033                            companyId, classNameId, tableName, columnName, data);
1034            }
1035    
1036            @Override
1037            public Map<String, Serializable> getData(
1038                            long companyId, String className, String tableName,
1039                            Collection<String> columnNames, long classPK)
1040                    throws PortalException {
1041    
1042                    List<ExpandoColumn> columns = expandoColumnLocalService.getColumns(
1043                            companyId, className, tableName, columnNames);
1044    
1045                    Map<String, Serializable> attributeValues = new HashMap<>(
1046                            (int)(columnNames.size() * 1.4));
1047    
1048                    ExpandoValue value = new ExpandoValueImpl();
1049    
1050                    for (ExpandoColumn column : columns) {
1051                            value.setColumn(column);
1052                            value.setData(column.getDefaultData());
1053    
1054                            Serializable attributeValue = doGetData(
1055                                    companyId, className, tableName, column.getName(), classPK,
1056                                    value, column.getType());
1057    
1058                            attributeValues.put(column.getName(), attributeValue);
1059                    }
1060    
1061                    return attributeValues;
1062            }
1063    
1064            @Override
1065            public Serializable getData(
1066                            long companyId, String className, String tableName,
1067                            String columnName, long classPK)
1068                    throws PortalException {
1069    
1070                    ExpandoColumn column = expandoColumnLocalService.getColumn(
1071                            companyId, className, tableName, columnName);
1072    
1073                    if (column == null) {
1074                            return null;
1075                    }
1076    
1077                    ExpandoValue value = new ExpandoValueImpl();
1078    
1079                    value.setColumn(column);
1080                    value.setData(column.getDefaultData());
1081    
1082                    return doGetData(
1083                            companyId, className, tableName, columnName, classPK, value,
1084                            column.getType());
1085            }
1086    
1087            @Override
1088            public boolean getData(
1089                            long companyId, String className, String tableName,
1090                            String columnName, long classPK, boolean defaultData)
1091                    throws PortalException {
1092    
1093                    ExpandoValue value = expandoValueLocalService.getValue(
1094                            companyId, className, tableName, columnName, classPK);
1095    
1096                    if (value == null) {
1097                            return defaultData;
1098                    }
1099                    else {
1100                            return value.getBoolean();
1101                    }
1102            }
1103    
1104            @Override
1105            public boolean[] getData(
1106                            long companyId, String className, String tableName,
1107                            String columnName, long classPK, boolean[] defaultData)
1108                    throws PortalException {
1109    
1110                    ExpandoValue value = expandoValueLocalService.getValue(
1111                            companyId, className, tableName, columnName, classPK);
1112    
1113                    if (value == null) {
1114                            return defaultData;
1115                    }
1116                    else {
1117                            return value.getBooleanArray();
1118                    }
1119            }
1120    
1121            @Override
1122            public Date getData(
1123                            long companyId, String className, String tableName,
1124                            String columnName, long classPK, Date defaultData)
1125                    throws PortalException {
1126    
1127                    ExpandoValue value = expandoValueLocalService.getValue(
1128                            companyId, className, tableName, columnName, classPK);
1129    
1130                    if (value == null) {
1131                            return defaultData;
1132                    }
1133                    else {
1134                            return value.getDate();
1135                    }
1136            }
1137    
1138            @Override
1139            public Date[] getData(
1140                            long companyId, String className, String tableName,
1141                            String columnName, long classPK, Date[] defaultData)
1142                    throws PortalException {
1143    
1144                    ExpandoValue value = expandoValueLocalService.getValue(
1145                            companyId, className, tableName, columnName, classPK);
1146    
1147                    if (value == null) {
1148                            return defaultData;
1149                    }
1150                    else {
1151                            return value.getDateArray();
1152                    }
1153            }
1154    
1155            @Override
1156            public double getData(
1157                            long companyId, String className, String tableName,
1158                            String columnName, long classPK, double defaultData)
1159                    throws PortalException {
1160    
1161                    ExpandoValue value = expandoValueLocalService.getValue(
1162                            companyId, className, tableName, columnName, classPK);
1163    
1164                    if (value == null) {
1165                            return defaultData;
1166                    }
1167                    else {
1168                            return value.getDouble();
1169                    }
1170            }
1171    
1172            @Override
1173            public double[] getData(
1174                            long companyId, String className, String tableName,
1175                            String columnName, long classPK, double[] defaultData)
1176                    throws PortalException {
1177    
1178                    ExpandoValue value = expandoValueLocalService.getValue(
1179                            companyId, className, tableName, columnName, classPK);
1180    
1181                    if (value == null) {
1182                            return defaultData;
1183                    }
1184                    else {
1185                            return value.getDoubleArray();
1186                    }
1187            }
1188    
1189            @Override
1190            public float getData(
1191                            long companyId, String className, String tableName,
1192                            String columnName, long classPK, float defaultData)
1193                    throws PortalException {
1194    
1195                    ExpandoValue value = expandoValueLocalService.getValue(
1196                            companyId, className, tableName, columnName, classPK);
1197    
1198                    if (value == null) {
1199                            return defaultData;
1200                    }
1201                    else {
1202                            return value.getFloat();
1203                    }
1204            }
1205    
1206            @Override
1207            public float[] getData(
1208                            long companyId, String className, String tableName,
1209                            String columnName, long classPK, float[] defaultData)
1210                    throws PortalException {
1211    
1212                    ExpandoValue value = expandoValueLocalService.getValue(
1213                            companyId, className, tableName, columnName, classPK);
1214    
1215                    if (value == null) {
1216                            return defaultData;
1217                    }
1218                    else {
1219                            return value.getFloatArray();
1220                    }
1221            }
1222    
1223            @Override
1224            public int getData(
1225                            long companyId, String className, String tableName,
1226                            String columnName, long classPK, int defaultData)
1227                    throws PortalException {
1228    
1229                    ExpandoValue value = expandoValueLocalService.getValue(
1230                            companyId, className, tableName, columnName, classPK);
1231    
1232                    if (value == null) {
1233                            return defaultData;
1234                    }
1235                    else {
1236                            return value.getInteger();
1237                    }
1238            }
1239    
1240            @Override
1241            public int[] getData(
1242                            long companyId, String className, String tableName,
1243                            String columnName, long classPK, int[] defaultData)
1244                    throws PortalException {
1245    
1246                    ExpandoValue value = expandoValueLocalService.getValue(
1247                            companyId, className, tableName, columnName, classPK);
1248    
1249                    if (value == null) {
1250                            return defaultData;
1251                    }
1252                    else {
1253                            return value.getIntegerArray();
1254                    }
1255            }
1256    
1257            @Override
1258            public long getData(
1259                            long companyId, String className, String tableName,
1260                            String columnName, long classPK, long defaultData)
1261                    throws PortalException {
1262    
1263                    ExpandoValue value = expandoValueLocalService.getValue(
1264                            companyId, className, tableName, columnName, classPK);
1265    
1266                    if (value == null) {
1267                            return defaultData;
1268                    }
1269                    else {
1270                            return value.getLong();
1271                    }
1272            }
1273    
1274            @Override
1275            public long[] getData(
1276                            long companyId, String className, String tableName,
1277                            String columnName, long classPK, long[] defaultData)
1278                    throws PortalException {
1279    
1280                    ExpandoValue value = expandoValueLocalService.getValue(
1281                            companyId, className, tableName, columnName, classPK);
1282    
1283                    if (value == null) {
1284                            return defaultData;
1285                    }
1286                    else {
1287                            return value.getLongArray();
1288                    }
1289            }
1290    
1291            @Override
1292            public Map<?, ?> getData(
1293                            long companyId, String className, String tableName,
1294                            String columnName, long classPK, Map<?, ?> defaultData)
1295                    throws PortalException {
1296    
1297                    ExpandoValue value = expandoValueLocalService.getValue(
1298                            companyId, className, tableName, columnName, classPK);
1299    
1300                    if (value == null) {
1301                            return defaultData;
1302                    }
1303    
1304                    ExpandoColumn column = value.getColumn();
1305    
1306                    int type = column.getType();
1307    
1308                    if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
1309                            return value.getStringArrayMap();
1310                    }
1311                    else {
1312                            return value.getStringMap();
1313                    }
1314            }
1315    
1316            @Override
1317            public Number getData(
1318                            long companyId, String className, String tableName,
1319                            String columnName, long classPK, Number defaultData)
1320                    throws PortalException {
1321    
1322                    ExpandoValue value = expandoValueLocalService.getValue(
1323                            companyId, className, tableName, columnName, classPK);
1324    
1325                    if (value == null) {
1326                            return defaultData;
1327                    }
1328                    else {
1329                            return value.getNumber();
1330                    }
1331            }
1332    
1333            @Override
1334            public Number[] getData(
1335                            long companyId, String className, String tableName,
1336                            String columnName, long classPK, Number[] defaultData)
1337                    throws PortalException {
1338    
1339                    ExpandoValue value = expandoValueLocalService.getValue(
1340                            companyId, className, tableName, columnName, classPK);
1341    
1342                    if (value == null) {
1343                            return defaultData;
1344                    }
1345                    else {
1346                            return value.getNumberArray();
1347                    }
1348            }
1349    
1350            @Override
1351            public short getData(
1352                            long companyId, String className, String tableName,
1353                            String columnName, long classPK, short defaultData)
1354                    throws PortalException {
1355    
1356                    ExpandoValue value = expandoValueLocalService.getValue(
1357                            companyId, className, tableName, columnName, classPK);
1358    
1359                    if (value == null) {
1360                            return defaultData;
1361                    }
1362                    else {
1363                            return value.getShort();
1364                    }
1365            }
1366    
1367            @Override
1368            public short[] getData(
1369                            long companyId, String className, String tableName,
1370                            String columnName, long classPK, short[] defaultData)
1371                    throws PortalException {
1372    
1373                    ExpandoValue value = expandoValueLocalService.getValue(
1374                            companyId, className, tableName, columnName, classPK);
1375    
1376                    if (value == null) {
1377                            return defaultData;
1378                    }
1379                    else {
1380                            return value.getShortArray();
1381                    }
1382            }
1383    
1384            @Override
1385            public String getData(
1386                            long companyId, String className, String tableName,
1387                            String columnName, long classPK, String defaultData)
1388                    throws PortalException {
1389    
1390                    ExpandoValue value = expandoValueLocalService.getValue(
1391                            companyId, className, tableName, columnName, classPK);
1392    
1393                    if (value == null) {
1394                            return defaultData;
1395                    }
1396                    else {
1397                            return value.getString();
1398                    }
1399            }
1400    
1401            @Override
1402            public String[] getData(
1403                            long companyId, String className, String tableName,
1404                            String columnName, long classPK, String[] defaultData)
1405                    throws PortalException {
1406    
1407                    ExpandoValue value = expandoValueLocalService.getValue(
1408                            companyId, className, tableName, columnName, classPK);
1409    
1410                    if (value == null) {
1411                            return defaultData;
1412                    }
1413                    else {
1414                            return value.getStringArray();
1415                    }
1416            }
1417    
1418            @Override
1419            public List<ExpandoValue> getDefaultTableColumnValues(
1420                    long companyId, long classNameId, String columnName, int start,
1421                    int end) {
1422    
1423                    return expandoValueLocalService.getColumnValues(
1424                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
1425                            columnName, start, end);
1426            }
1427    
1428            @Override
1429            public List<ExpandoValue> getDefaultTableColumnValues(
1430                    long companyId, String className, String columnName, int start,
1431                    int end) {
1432    
1433                    long classNameId = classNameLocalService.getClassNameId(className);
1434    
1435                    return expandoValueLocalService.getDefaultTableColumnValues(
1436                            companyId, classNameId, columnName, start, end);
1437            }
1438    
1439            @Override
1440            public int getDefaultTableColumnValuesCount(
1441                    long companyId, long classNameId, String columnName) {
1442    
1443                    return expandoValueLocalService.getColumnValuesCount(
1444                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
1445                            columnName);
1446            }
1447    
1448            @Override
1449            public int getDefaultTableColumnValuesCount(
1450                    long companyId, String className, String columnName) {
1451    
1452                    long classNameId = classNameLocalService.getClassNameId(className);
1453    
1454                    return expandoValueLocalService.getDefaultTableColumnValuesCount(
1455                            companyId, classNameId, columnName);
1456            }
1457    
1458            @Override
1459            public List<ExpandoValue> getRowValues(long rowId) {
1460                    return expandoValuePersistence.findByRowId(rowId);
1461            }
1462    
1463            @Override
1464            public List<ExpandoValue> getRowValues(long rowId, int start, int end) {
1465                    return expandoValuePersistence.findByRowId(rowId, start, end);
1466            }
1467    
1468            @Override
1469            public List<ExpandoValue> getRowValues(
1470                    long companyId, long classNameId, String tableName, long classPK,
1471                    int start, int end) {
1472    
1473                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1474                            companyId, classNameId, tableName);
1475    
1476                    if (table == null) {
1477                            return Collections.emptyList();
1478                    }
1479    
1480                    return expandoValuePersistence.findByT_CPK(
1481                            table.getTableId(), classPK, start, end);
1482            }
1483    
1484            @Override
1485            public List<ExpandoValue> getRowValues(
1486                    long companyId, String className, String tableName, long classPK,
1487                    int start, int end) {
1488    
1489                    long classNameId = classNameLocalService.getClassNameId(className);
1490    
1491                    return expandoValueLocalService.getRowValues(
1492                            companyId, classNameId, tableName, classPK, start, end);
1493            }
1494    
1495            @Override
1496            public int getRowValuesCount(long rowId) {
1497                    return expandoValuePersistence.countByRowId(rowId);
1498            }
1499    
1500            @Override
1501            public int getRowValuesCount(
1502                    long companyId, long classNameId, String tableName, long classPK) {
1503    
1504                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1505                            companyId, classNameId, tableName);
1506    
1507                    if (table == null) {
1508                            return 0;
1509                    }
1510    
1511                    return expandoValuePersistence.countByT_CPK(
1512                            table.getTableId(), classPK);
1513            }
1514    
1515            @Override
1516            public int getRowValuesCount(
1517                    long companyId, String className, String tableName, long classPK) {
1518    
1519                    long classNameId = classNameLocalService.getClassNameId(className);
1520    
1521                    return expandoValueLocalService.getRowValuesCount(
1522                            companyId, classNameId, tableName, classPK);
1523            }
1524    
1525            @Override
1526            public ExpandoValue getValue(long valueId) throws PortalException {
1527                    return expandoValuePersistence.findByPrimaryKey(valueId);
1528            }
1529    
1530            @Override
1531            public ExpandoValue getValue(long columnId, long rowId)
1532                    throws PortalException {
1533    
1534                    return expandoValuePersistence.findByC_R(columnId, rowId);
1535            }
1536    
1537            @Override
1538            public ExpandoValue getValue(long tableId, long columnId, long classPK) {
1539                    return expandoValuePersistence.fetchByT_C_C(tableId, columnId, classPK);
1540            }
1541    
1542            @Override
1543            public ExpandoValue getValue(
1544                    long companyId, long classNameId, String tableName, String columnName,
1545                    long classPK) {
1546    
1547                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
1548                            companyId, classNameId, tableName);
1549    
1550                    if (table == null) {
1551                            return null;
1552                    }
1553    
1554                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
1555                            table.getTableId(), columnName);
1556    
1557                    if (column == null) {
1558                            return null;
1559                    }
1560    
1561                    return expandoValuePersistence.fetchByT_C_C(
1562                            table.getTableId(), column.getColumnId(), classPK);
1563            }
1564    
1565            @Override
1566            public ExpandoValue getValue(
1567                    long companyId, String className, String tableName, String columnName,
1568                    long classPK) {
1569    
1570                    long classNameId = classNameLocalService.getClassNameId(className);
1571    
1572                    return expandoValueLocalService.getValue(
1573                            companyId, classNameId, tableName, columnName, classPK);
1574            }
1575    
1576            protected <T> T convertType(int type, Object data) {
1577                    if (data == null) {
1578                            return (T)data;
1579                    }
1580    
1581                    data = handleCollections(type, data);
1582                    data = handleStrings(type, data);
1583    
1584                    if (type == ExpandoColumnConstants.BOOLEAN) {
1585                            data = TypeConverterManager.convertType(data, Boolean.TYPE);
1586                    }
1587                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
1588                            data = TypeConverterManager.convertType(data, boolean[].class);
1589                    }
1590                    else if (type == ExpandoColumnConstants.DATE) {
1591                            data = TypeConverterManager.convertType(data, Date.class);
1592                    }
1593                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
1594                            data = TypeConverterManager.convertType(data, Date[].class);
1595                    }
1596                    else if (type == ExpandoColumnConstants.DOUBLE) {
1597                            data = TypeConverterManager.convertType(data, Double.TYPE);
1598                    }
1599                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
1600                            data = TypeConverterManager.convertType(data, double[].class);
1601                    }
1602                    else if (type == ExpandoColumnConstants.FLOAT) {
1603                            data = TypeConverterManager.convertType(data, Float.TYPE);
1604                    }
1605                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
1606                            data = TypeConverterManager.convertType(data, float[].class);
1607                    }
1608                    else if (type == ExpandoColumnConstants.INTEGER) {
1609                            data = TypeConverterManager.convertType(data, Integer.TYPE);
1610                    }
1611                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
1612                            data = TypeConverterManager.convertType(data, int[].class);
1613                    }
1614                    else if (type == ExpandoColumnConstants.LONG) {
1615                            data = TypeConverterManager.convertType(data, Long.TYPE);
1616                    }
1617                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
1618                            data = TypeConverterManager.convertType(data, long[].class);
1619                    }
1620                    else if (type == ExpandoColumnConstants.NUMBER) {
1621                            data = TypeConverterManager.convertType(data, Number.class);
1622                    }
1623                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
1624                            data = TypeConverterManager.convertType(data, Number[].class);
1625                    }
1626                    else if (type == ExpandoColumnConstants.SHORT) {
1627                            data = TypeConverterManager.convertType(data, Short.TYPE);
1628                    }
1629                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
1630                            data = TypeConverterManager.convertType(data, short[].class);
1631                    }
1632                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
1633                            data = TypeConverterManager.convertType(data, String[].class);
1634                    }
1635    
1636                    return (T)data;
1637            }
1638    
1639            protected ExpandoValue doAddValue(
1640                    long companyId, long classNameId, long tableId, long columnId,
1641                    long classPK, String data) {
1642    
1643                    ExpandoRow row = expandoRowPersistence.fetchByT_C(tableId, classPK);
1644    
1645                    if (row == null) {
1646                            long rowId = counterLocalService.increment();
1647    
1648                            row = expandoRowPersistence.create(rowId);
1649    
1650                            row.setCompanyId(companyId);
1651                            row.setTableId(tableId);
1652                            row.setClassPK(classPK);
1653    
1654                            expandoRowPersistence.update(row);
1655                    }
1656    
1657                    ExpandoValue value = expandoValuePersistence.fetchByC_R(
1658                            columnId, row.getRowId());
1659    
1660                    if (value == null) {
1661                            long valueId = counterLocalService.increment();
1662    
1663                            value = expandoValuePersistence.create(valueId);
1664    
1665                            value.setCompanyId(companyId);
1666                            value.setTableId(tableId);
1667                            value.setColumnId(columnId);
1668                            value.setRowId(row.getRowId());
1669                            value.setClassNameId(classNameId);
1670                            value.setClassPK(classPK);
1671                    }
1672    
1673                    if (value.isNew() || !Objects.equals(value.getData(), data)) {
1674                            value.setData(data);
1675    
1676                            expandoValuePersistence.update(value);
1677    
1678                            row.setModifiedDate(new Date());
1679    
1680                            expandoRowPersistence.update(row);
1681                    }
1682    
1683                    return value;
1684            }
1685    
1686            protected Serializable doGetData(
1687                            long companyId, String className, String tableName,
1688                            String columnName, long classPK, ExpandoValue value, int type)
1689                    throws PortalException {
1690    
1691                    if (type == ExpandoColumnConstants.BOOLEAN) {
1692                            return expandoValueLocalService.getData(
1693                                    companyId, className, tableName, columnName, classPK,
1694                                    value.getBoolean());
1695                    }
1696                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
1697                            return expandoValueLocalService.getData(
1698                                    companyId, className, tableName, columnName, classPK,
1699                                    new boolean[0]);
1700                    }
1701                    else if (type == ExpandoColumnConstants.DATE) {
1702                            return expandoValueLocalService.getData(
1703                                    companyId, className, tableName, columnName, classPK,
1704                                    value.getDate());
1705                    }
1706                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
1707                            return expandoValueLocalService.getData(
1708                                    companyId, className, tableName, columnName, classPK,
1709                                    new Date[0]);
1710                    }
1711                    else if (type == ExpandoColumnConstants.DOUBLE) {
1712                            return expandoValueLocalService.getData(
1713                                    companyId, className, tableName, columnName, classPK,
1714                                    value.getDouble());
1715                    }
1716                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
1717                            return expandoValueLocalService.getData(
1718                                    companyId, className, tableName, columnName, classPK,
1719                                    new double[0]);
1720                    }
1721                    else if (type == ExpandoColumnConstants.FLOAT) {
1722                            return expandoValueLocalService.getData(
1723                                    companyId, className, tableName, columnName, classPK,
1724                                    value.getFloat());
1725                    }
1726                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
1727                            return expandoValueLocalService.getData(
1728                                    companyId, className, tableName, columnName, classPK,
1729                                    new float[0]);
1730                    }
1731                    else if (type == ExpandoColumnConstants.INTEGER) {
1732                            return expandoValueLocalService.getData(
1733                                    companyId, className, tableName, columnName, classPK,
1734                                    value.getInteger());
1735                    }
1736                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
1737                            return expandoValueLocalService.getData(
1738                                    companyId, className, tableName, columnName, classPK,
1739                                    new int[0]);
1740                    }
1741                    else if (type == ExpandoColumnConstants.LONG) {
1742                            return expandoValueLocalService.getData(
1743                                    companyId, className, tableName, columnName, classPK,
1744                                    value.getLong());
1745                    }
1746                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
1747                            return expandoValueLocalService.getData(
1748                                    companyId, className, tableName, columnName, classPK,
1749                                    new long[0]);
1750                    }
1751                    else if (type == ExpandoColumnConstants.NUMBER) {
1752                            return expandoValueLocalService.getData(
1753                                    companyId, className, tableName, columnName, classPK,
1754                                    value.getNumber());
1755                    }
1756                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
1757                            return expandoValueLocalService.getData(
1758                                    companyId, className, tableName, columnName, classPK,
1759                                    new Number[0]);
1760                    }
1761                    else if (type == ExpandoColumnConstants.SHORT) {
1762                            return expandoValueLocalService.getData(
1763                                    companyId, className, tableName, columnName, classPK,
1764                                    value.getShort());
1765                    }
1766                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
1767                            return expandoValueLocalService.getData(
1768                                    companyId, className, tableName, columnName, classPK,
1769                                    new short[0]);
1770                    }
1771                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
1772                            return expandoValueLocalService.getData(
1773                                    companyId, className, tableName, columnName, classPK,
1774                                    new String[0]);
1775                    }
1776                    else if (type == ExpandoColumnConstants.STRING) {
1777                            return expandoValueLocalService.getData(
1778                                    companyId, className, tableName, columnName, classPK,
1779                                    value.getString());
1780                    }
1781                    else {
1782                            return (Serializable)expandoValueLocalService.getData(
1783                                    companyId, className, tableName, columnName, classPK,
1784                                    new HashMap<Object, Object>());
1785                    }
1786            }
1787    
1788            protected Object handleCollections(int type, Object object) {
1789                    if (!(object instanceof Collection) || !isTypeArray(type)) {
1790                            return object;
1791                    }
1792    
1793                    Collection<?> collection = (Collection<?>)object;
1794    
1795                    return collection.toArray();
1796            }
1797    
1798            protected Object handleStrings(int type, Object object) {
1799                    if (!(object instanceof String)) {
1800                            return object;
1801                    }
1802    
1803                    String string = (String)object;
1804    
1805                    if (string.startsWith(StringPool.OPEN_BRACKET) &&
1806                            string.endsWith(StringPool.CLOSE_BRACKET)) {
1807    
1808                            string = string.substring(1, (string.length() - 1));
1809                    }
1810    
1811                    return string;
1812            }
1813    
1814            protected boolean isTypeArray(int type) {
1815                    if ((type == ExpandoColumnConstants.BOOLEAN_ARRAY) ||
1816                            (type == ExpandoColumnConstants.DATE_ARRAY) ||
1817                            (type == ExpandoColumnConstants.DOUBLE_ARRAY) ||
1818                            (type == ExpandoColumnConstants.FLOAT_ARRAY) ||
1819                            (type == ExpandoColumnConstants.INTEGER_ARRAY) ||
1820                            (type == ExpandoColumnConstants.LONG_ARRAY) ||
1821                            (type == ExpandoColumnConstants.NUMBER_ARRAY) ||
1822                            (type == ExpandoColumnConstants.SHORT_ARRAY) ||
1823                            (type == ExpandoColumnConstants.STRING_ARRAY)) {
1824    
1825                            return true;
1826                    }
1827    
1828                    return false;
1829            }
1830    
1831    }