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