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.LocaleUtil;
019    import com.liferay.portal.kernel.util.StringBundler;
020    import com.liferay.portal.kernel.util.Validator;
021    import com.liferay.portlet.expando.exception.ColumnNameException;
022    import com.liferay.portlet.expando.exception.ColumnTypeException;
023    import com.liferay.portlet.expando.exception.DuplicateColumnNameException;
024    import com.liferay.portlet.expando.model.ExpandoColumn;
025    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
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.ExpandoColumnLocalServiceBaseImpl;
031    
032    import java.util.Collection;
033    import java.util.Collections;
034    import java.util.Date;
035    import java.util.List;
036    import java.util.Locale;
037    import java.util.Map;
038    
039    /**
040     * @author Raymond Aug??
041     * @author Brian Wing Shun Chan
042     */
043    public class ExpandoColumnLocalServiceImpl
044            extends ExpandoColumnLocalServiceBaseImpl {
045    
046            @Override
047            public ExpandoColumn addColumn(long tableId, String name, int type)
048                    throws PortalException {
049    
050                    return addColumn(tableId, name, type, null);
051            }
052    
053            @Override
054            public ExpandoColumn addColumn(
055                            long tableId, String name, int type, Object defaultData)
056                    throws PortalException {
057    
058                    // Column
059    
060                    ExpandoTable table = expandoTablePersistence.findByPrimaryKey(tableId);
061    
062                    ExpandoValue value = validate(0, tableId, name, type, defaultData);
063    
064                    long columnId = counterLocalService.increment();
065    
066                    ExpandoColumn column = expandoColumnPersistence.create(columnId);
067    
068                    column.setCompanyId(table.getCompanyId());
069                    column.setTableId(tableId);
070                    column.setName(name);
071                    column.setType(type);
072                    column.setDefaultData(value.getData());
073    
074                    expandoColumnPersistence.update(column);
075    
076                    // Resources
077    
078                    resourceLocalService.addResources(
079                            table.getCompanyId(), 0, 0, ExpandoColumn.class.getName(),
080                            column.getColumnId(), false, false, false);
081    
082                    return column;
083            }
084    
085            @Override
086            public void deleteColumn(ExpandoColumn column) {
087    
088                    // Column
089    
090                    expandoColumnPersistence.remove(column);
091    
092                    // Values
093    
094                    expandoValueLocalService.deleteColumnValues(column.getColumnId());
095            }
096    
097            @Override
098            public void deleteColumn(long columnId) throws PortalException {
099                    ExpandoColumn column = expandoColumnPersistence.findByPrimaryKey(
100                            columnId);
101    
102                    deleteColumn(column);
103            }
104    
105            @Override
106            public void deleteColumn(
107                            long companyId, long classNameId, String tableName, String name)
108                    throws PortalException {
109    
110                    ExpandoTable table = expandoTableLocalService.getTable(
111                            companyId, classNameId, tableName);
112    
113                    deleteColumn(table.getTableId(), name);
114            }
115    
116            @Override
117            public void deleteColumn(long tableId, String name) {
118                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
119                            tableId, name);
120    
121                    if (column != null) {
122                            expandoColumnPersistence.remove(column);
123                    }
124            }
125    
126            @Override
127            public void deleteColumn(
128                            long companyId, String className, String tableName, String name)
129                    throws PortalException {
130    
131                    long classNameId = classNameLocalService.getClassNameId(className);
132    
133                    deleteColumn(companyId, classNameId, tableName, name);
134            }
135    
136            @Override
137            public void deleteColumns(long tableId) {
138                    List<ExpandoColumn> columns = expandoColumnPersistence.findByTableId(
139                            tableId);
140    
141                    for (ExpandoColumn column : columns) {
142                            deleteColumn(column);
143                    }
144            }
145    
146            @Override
147            public void deleteColumns(
148                            long companyId, long classNameId, String tableName)
149                    throws PortalException {
150    
151                    ExpandoTable table = expandoTableLocalService.getTable(
152                            companyId, classNameId, tableName);
153    
154                    deleteColumns(table.getTableId());
155            }
156    
157            @Override
158            public void deleteColumns(
159                            long companyId, String className, String tableName)
160                    throws PortalException {
161    
162                    long classNameId = classNameLocalService.getClassNameId(className);
163    
164                    deleteColumns(companyId, classNameId, tableName);
165            }
166    
167            @Override
168            public ExpandoColumn getColumn(long columnId) throws PortalException {
169                    return expandoColumnPersistence.findByPrimaryKey(columnId);
170            }
171    
172            @Override
173            public ExpandoColumn getColumn(
174                    long companyId, long classNameId, String tableName, String name) {
175    
176                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
177                            companyId, classNameId, tableName);
178    
179                    if (table == null) {
180                            return null;
181                    }
182    
183                    return expandoColumnPersistence.fetchByT_N(table.getTableId(), name);
184            }
185    
186            @Override
187            public ExpandoColumn getColumn(long tableId, String name) {
188                    return expandoColumnPersistence.fetchByT_N(tableId, name);
189            }
190    
191            @Override
192            public ExpandoColumn getColumn(
193                    long companyId, String className, String tableName, String name) {
194    
195                    long classNameId = classNameLocalService.getClassNameId(className);
196    
197                    return getColumn(companyId, classNameId, tableName, name);
198            }
199    
200            @Override
201            public List<ExpandoColumn> getColumns(long tableId) {
202                    return expandoColumnPersistence.findByTableId(tableId);
203            }
204    
205            @Override
206            public List<ExpandoColumn> getColumns(
207                    long tableId, Collection<String> names) {
208    
209                    return expandoColumnPersistence.findByT_N(
210                            tableId, names.toArray(new String[names.size()]));
211            }
212    
213            @Override
214            public List<ExpandoColumn> getColumns(
215                    long companyId, long classNameId, String tableName) {
216    
217                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
218                            companyId, classNameId, tableName);
219    
220                    if (table == null) {
221                            return Collections.emptyList();
222                    }
223    
224                    return expandoColumnPersistence.findByTableId(table.getTableId());
225            }
226    
227            @Override
228            public List<ExpandoColumn> getColumns(
229                    long companyId, long classNameId, String tableName,
230                    Collection<String> names) {
231    
232                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
233                            companyId, classNameId, tableName);
234    
235                    if (table == null) {
236                            return Collections.emptyList();
237                    }
238    
239                    return expandoColumnPersistence.findByT_N(
240                            table.getTableId(), names.toArray(new String[names.size()]));
241            }
242    
243            @Override
244            public List<ExpandoColumn> getColumns(
245                    long companyId, String className, String tableName) {
246    
247                    long classNameId = classNameLocalService.getClassNameId(className);
248    
249                    return getColumns(companyId, classNameId, tableName);
250            }
251    
252            @Override
253            public List<ExpandoColumn> getColumns(
254                    long companyId, String className, String tableName,
255                    Collection<String> columnNames) {
256    
257                    long classNameId = classNameLocalService.getClassNameId(className);
258    
259                    return getColumns(companyId, classNameId, tableName, columnNames);
260            }
261    
262            @Override
263            public int getColumnsCount(long tableId) {
264                    return expandoColumnPersistence.countByTableId(tableId);
265            }
266    
267            @Override
268            public int getColumnsCount(
269                    long companyId, long classNameId, String tableName) {
270    
271                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
272                            companyId, classNameId, tableName);
273    
274                    if (table == null) {
275                            return 0;
276                    }
277    
278                    return expandoColumnPersistence.countByTableId(table.getTableId());
279            }
280    
281            @Override
282            public int getColumnsCount(
283                    long companyId, String className, String tableName) {
284    
285                    long classNameId = classNameLocalService.getClassNameId(className);
286    
287                    return getColumnsCount(companyId, classNameId, tableName);
288            }
289    
290            @Override
291            public ExpandoColumn getDefaultTableColumn(
292                    long companyId, long classNameId, String name) {
293    
294                    return getColumn(
295                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
296                            name);
297            }
298    
299            @Override
300            public ExpandoColumn getDefaultTableColumn(
301                    long companyId, String className, String name) {
302    
303                    long classNameId = classNameLocalService.getClassNameId(className);
304    
305                    return getColumn(
306                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
307                            name);
308            }
309    
310            @Override
311            public List<ExpandoColumn> getDefaultTableColumns(
312                    long companyId, long classNameId) {
313    
314                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
315                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
316    
317                    if (table == null) {
318                            return Collections.emptyList();
319                    }
320    
321                    return expandoColumnPersistence.findByTableId(table.getTableId());
322            }
323    
324            @Override
325            public List<ExpandoColumn> getDefaultTableColumns(
326                    long companyId, String className) {
327    
328                    long classNameId = classNameLocalService.getClassNameId(className);
329    
330                    return getColumns(
331                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
332            }
333    
334            @Override
335            public int getDefaultTableColumnsCount(long companyId, long classNameId) {
336                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
337                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
338    
339                    if (table == null) {
340                            return 0;
341                    }
342    
343                    return expandoColumnPersistence.countByTableId(table.getTableId());
344            }
345    
346            @Override
347            public int getDefaultTableColumnsCount(long companyId, String className) {
348                    long classNameId = classNameLocalService.getClassNameId(className);
349    
350                    return getColumnsCount(
351                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
352            }
353    
354            @Override
355            public ExpandoColumn updateColumn(long columnId, String name, int type)
356                    throws PortalException {
357    
358                    return expandoColumnLocalService.updateColumn(
359                            columnId, name, type, null);
360            }
361    
362            @Override
363            public ExpandoColumn updateColumn(
364                            long columnId, String name, int type, Object defaultData)
365                    throws PortalException {
366    
367                    ExpandoColumn column = expandoColumnPersistence.findByPrimaryKey(
368                            columnId);
369    
370                    ExpandoValue value = validate(
371                            columnId, column.getTableId(), name, type, defaultData);
372    
373                    column.setName(name);
374                    column.setType(type);
375                    column.setDefaultData(value.getData());
376    
377                    expandoColumnPersistence.update(column);
378    
379                    return column;
380            }
381    
382            @Override
383            public ExpandoColumn updateTypeSettings(long columnId, String typeSettings)
384                    throws PortalException {
385    
386                    ExpandoColumn column = expandoColumnPersistence.findByPrimaryKey(
387                            columnId);
388    
389                    column.setTypeSettings(typeSettings);
390    
391                    expandoColumnPersistence.update(column);
392    
393                    return column;
394            }
395    
396            protected ExpandoValue validate(
397                            long columnId, long tableId, String name, int type,
398                            Object defaultData)
399                    throws PortalException {
400    
401                    if (Validator.isNull(name)) {
402                            throw new ColumnNameException("Name is null");
403                    }
404    
405                    ExpandoColumn column = expandoColumnPersistence.fetchByT_N(
406                            tableId, name);
407    
408                    if ((column != null) && (column.getColumnId() != columnId)) {
409                            StringBundler sb = new StringBundler(7);
410    
411                            sb.append("{tableId=");
412                            sb.append(tableId);
413                            sb.append(", columnId=");
414                            sb.append(columnId);
415                            sb.append(", name=");
416                            sb.append(name);
417                            sb.append("}");
418    
419                            throw new DuplicateColumnNameException(sb.toString());
420                    }
421    
422                    if ((type != ExpandoColumnConstants.BOOLEAN) &&
423                            (type != ExpandoColumnConstants.BOOLEAN_ARRAY) &&
424                            (type != ExpandoColumnConstants.DATE) &&
425                            (type != ExpandoColumnConstants.DATE_ARRAY) &&
426                            (type != ExpandoColumnConstants.DOUBLE) &&
427                            (type != ExpandoColumnConstants.DOUBLE_ARRAY) &&
428                            (type != ExpandoColumnConstants.FLOAT) &&
429                            (type != ExpandoColumnConstants.FLOAT_ARRAY) &&
430                            (type != ExpandoColumnConstants.INTEGER) &&
431                            (type != ExpandoColumnConstants.INTEGER_ARRAY) &&
432                            (type != ExpandoColumnConstants.LONG) &&
433                            (type != ExpandoColumnConstants.LONG_ARRAY) &&
434                            (type != ExpandoColumnConstants.NUMBER) &&
435                            (type != ExpandoColumnConstants.NUMBER_ARRAY) &&
436                            (type != ExpandoColumnConstants.SHORT) &&
437                            (type != ExpandoColumnConstants.SHORT_ARRAY) &&
438                            (type != ExpandoColumnConstants.STRING) &&
439                            (type != ExpandoColumnConstants.STRING_ARRAY) &&
440                            (type != ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) &&
441                            (type != ExpandoColumnConstants.STRING_LOCALIZED)) {
442    
443                            throw new ColumnTypeException("Invalid type " + type);
444                    }
445    
446                    ExpandoValue value = new ExpandoValueImpl();
447    
448                    if (defaultData == null) {
449                            return value;
450                    }
451    
452                    value.setColumnId(columnId);
453    
454                    if (type == ExpandoColumnConstants.BOOLEAN) {
455                            value.setBoolean((Boolean)defaultData);
456                    }
457                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
458                            value.setBooleanArray((boolean[])defaultData);
459                    }
460                    else if (type == ExpandoColumnConstants.DATE) {
461                            value.setDate((Date)defaultData);
462                    }
463                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
464                            value.setDateArray((Date[])defaultData);
465                    }
466                    else if (type == ExpandoColumnConstants.DOUBLE) {
467                            value.setDouble((Double)defaultData);
468                    }
469                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
470                            value.setDoubleArray((double[])defaultData);
471                    }
472                    else if (type == ExpandoColumnConstants.FLOAT) {
473                            value.setFloat((Float)defaultData);
474                    }
475                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
476                            value.setFloatArray((float[])defaultData);
477                    }
478                    else if (type == ExpandoColumnConstants.INTEGER) {
479                            value.setInteger((Integer)defaultData);
480                    }
481                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
482                            value.setIntegerArray((int[])defaultData);
483                    }
484                    else if (type == ExpandoColumnConstants.LONG) {
485                            value.setLong((Long)defaultData);
486                    }
487                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
488                            value.setLongArray((long[])defaultData);
489                    }
490                    else if (type == ExpandoColumnConstants.NUMBER) {
491                            value.setNumber((Number)defaultData);
492                    }
493                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
494                            value.setNumberArray((Number[])defaultData);
495                    }
496                    else if (type == ExpandoColumnConstants.SHORT) {
497                            value.setShort((Short)defaultData);
498                    }
499                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
500                            value.setShortArray((short[])defaultData);
501                    }
502                    else if (type == ExpandoColumnConstants.STRING) {
503                            value.setString((String)defaultData);
504                    }
505                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
506                            value.setStringArray((String[])defaultData);
507                    }
508                    else if (type == ExpandoColumnConstants.STRING_ARRAY_LOCALIZED) {
509                            value.setStringArrayMap(
510                                    (Map<Locale, String[]>)defaultData, LocaleUtil.getDefault());
511                    }
512                    else if (type == ExpandoColumnConstants.STRING_LOCALIZED) {
513                            value.setStringMap(
514                                    (Map<Locale, String>)defaultData, LocaleUtil.getDefault());
515                    }
516    
517                    return value;
518            }
519    
520    }