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);
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) throws SystemException {
112                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
113                            tableId, name);
114    
115                    if (!columns.isEmpty()) {
116                            deleteColumn(columns.get(0));
117                    }
118            }
119    
120            public void deleteColumn(
121                            long companyId, String className, String tableName, String name)
122                    throws PortalException, SystemException {
123    
124                    long classNameId = PortalUtil.getClassNameId(className);
125    
126                    deleteColumn(companyId, classNameId, tableName, name);
127            }
128    
129            public void deleteColumns(long tableId) throws SystemException {
130                    List<ExpandoColumn> columns = expandoColumnPersistence.findByTableId(
131                            tableId);
132    
133                    for (ExpandoColumn column : columns) {
134                            deleteColumn(column);
135                    }
136            }
137    
138            public void deleteColumns(
139                            long companyId, long classNameId, String tableName)
140                    throws PortalException, SystemException {
141    
142                    ExpandoTable table = expandoTableLocalService.getTable(
143                            companyId, classNameId, tableName);
144    
145                    deleteColumns(table.getTableId());
146            }
147    
148            public void deleteColumns(
149                            long companyId, String className, String tableName)
150                    throws PortalException, SystemException {
151    
152                    long classNameId = PortalUtil.getClassNameId(className);
153    
154                    deleteColumns(companyId, classNameId, tableName);
155            }
156    
157            public ExpandoColumn getColumn(long columnId)
158                    throws PortalException, SystemException {
159    
160                    return expandoColumnPersistence.findByPrimaryKey(columnId);
161            }
162    
163            public ExpandoColumn getColumn(
164                            long companyId, long classNameId, String tableName, String name)
165                    throws SystemException {
166    
167                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
168                            companyId, classNameId, tableName);
169    
170                    if (table == null) {
171                            return null;
172                    }
173    
174                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
175                            table.getTableId(), name);
176    
177                    if (!columns.isEmpty()) {
178                            return columns.get(0);
179                    }
180    
181                    return null;
182            }
183    
184            public ExpandoColumn getColumn(long tableId, String name)
185                    throws SystemException {
186    
187                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
188                            tableId, name);
189    
190                    if (!columns.isEmpty()) {
191                            return columns.get(0);
192                    }
193    
194                    return null;
195            }
196    
197            public ExpandoColumn getColumn(
198                            long companyId, String className, String tableName, String name)
199                    throws SystemException {
200    
201                    long classNameId = PortalUtil.getClassNameId(className);
202    
203                    return getColumn(companyId, classNameId, tableName, name);
204            }
205    
206            public List<ExpandoColumn> getColumns(long tableId) throws SystemException {
207                    return expandoColumnPersistence.findByTableId(tableId);
208            }
209    
210            public List<ExpandoColumn> getColumns(
211                            long tableId, Collection<String> names)
212                    throws SystemException {
213    
214                    return expandoColumnPersistence.findByT_N(
215                            tableId, names.toArray(new String[names.size()]));
216            }
217    
218            public List<ExpandoColumn> getColumns(
219                            long companyId, long classNameId, String tableName)
220                    throws SystemException {
221    
222                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
223                            companyId, classNameId, tableName);
224    
225                    if (table == null) {
226                            return Collections.emptyList();
227                    }
228    
229                    return expandoColumnPersistence.findByTableId(table.getTableId());
230            }
231    
232            public List<ExpandoColumn> getColumns(
233                            long companyId, long classNameId, String tableName,
234                            Collection<String> names)
235                    throws SystemException {
236    
237                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
238                            companyId, classNameId, tableName);
239    
240                    if (table == null) {
241                            return Collections.emptyList();
242                    }
243    
244                    return expandoColumnPersistence.findByT_N(
245                            table.getTableId(), names.toArray(new String[names.size()]));
246            }
247    
248            public List<ExpandoColumn> getColumns(
249                            long companyId, String className, String tableName)
250                    throws SystemException {
251    
252                    long classNameId = PortalUtil.getClassNameId(className);
253    
254                    return getColumns(companyId, classNameId, tableName);
255            }
256    
257            public List<ExpandoColumn> getColumns(
258                            long companyId, String className, String tableName,
259                            Collection<String> columnNames)
260                    throws SystemException {
261    
262                    long classNameId = PortalUtil.getClassNameId(className);
263    
264                    return getColumns(companyId, classNameId, tableName, columnNames);
265            }
266    
267            public int getColumnsCount(long tableId) throws SystemException {
268                    return expandoColumnPersistence.countByTableId(tableId);
269            }
270    
271            public int getColumnsCount(
272                            long companyId, long classNameId, String tableName)
273                    throws SystemException {
274    
275                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
276                            companyId, classNameId, tableName);
277    
278                    if (table == null) {
279                            return 0;
280                    }
281    
282                    return expandoColumnPersistence.countByTableId(table.getTableId());
283            }
284    
285            public int getColumnsCount(
286                            long companyId, String className, String tableName)
287                    throws SystemException {
288    
289                    long classNameId = PortalUtil.getClassNameId(className);
290    
291                    return getColumnsCount(companyId, classNameId, tableName);
292            }
293    
294            public ExpandoColumn getDefaultTableColumn(
295                            long companyId, long classNameId, String name)
296                    throws SystemException {
297    
298                    return getColumn(
299                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
300                            name);
301            }
302    
303            public ExpandoColumn getDefaultTableColumn(
304                            long companyId, String className, String name)
305                    throws SystemException {
306    
307                    long classNameId = PortalUtil.getClassNameId(className);
308    
309                    return getColumn(
310                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME,
311                            name);
312            }
313    
314            public List<ExpandoColumn> getDefaultTableColumns(
315                            long companyId, long classNameId)
316                    throws SystemException {
317    
318                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
319                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
320    
321                    if (table == null) {
322                            return Collections.emptyList();
323                    }
324    
325                    return expandoColumnPersistence.findByTableId(table.getTableId());
326            }
327    
328            public List<ExpandoColumn> getDefaultTableColumns(
329                            long companyId, String className)
330                    throws SystemException {
331    
332                    long classNameId = PortalUtil.getClassNameId(className);
333    
334                    return getColumns(
335                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
336            }
337    
338            public int getDefaultTableColumnsCount(long companyId, long classNameId)
339                    throws SystemException {
340    
341                    ExpandoTable table = expandoTablePersistence.fetchByC_C_N(
342                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
343    
344                    if (table == null) {
345                            return 0;
346                    }
347    
348                    return expandoColumnPersistence.countByTableId(table.getTableId());
349            }
350    
351            public int getDefaultTableColumnsCount(long companyId, String className)
352                    throws SystemException {
353    
354                    long classNameId = PortalUtil.getClassNameId(className);
355    
356                    return getColumnsCount(
357                            companyId, classNameId, ExpandoTableConstants.DEFAULT_TABLE_NAME);
358            }
359    
360            public ExpandoColumn updateColumn(long columnId, String name, int type)
361                    throws PortalException, SystemException {
362    
363                    return expandoColumnLocalService.updateColumn(
364                            columnId, name, type, null);
365            }
366    
367            public ExpandoColumn updateColumn(
368                            long columnId, String name, int type, Object defaultData)
369                    throws PortalException, SystemException {
370    
371                    ExpandoColumn column = expandoColumnPersistence.findByPrimaryKey(
372                            columnId);
373    
374                    ExpandoValue value = validate(
375                            columnId, column.getTableId(), name, type, defaultData);
376    
377                    column.setName(name);
378                    column.setType(type);
379                    column.setDefaultData(value.getData());
380    
381                    expandoColumnPersistence.update(column);
382    
383                    return column;
384            }
385    
386            public ExpandoColumn updateTypeSettings(long columnId, String typeSettings)
387                    throws PortalException, SystemException {
388    
389                    ExpandoColumn column = expandoColumnPersistence.findByPrimaryKey(
390                            columnId);
391    
392                    column.setTypeSettings(typeSettings);
393    
394                    expandoColumnPersistence.update(column);
395    
396                    return column;
397            }
398    
399            protected ExpandoValue validate(
400                            long columnId, long tableId, String name, int type,
401                            Object defaultData)
402                    throws PortalException, SystemException {
403    
404                    if (Validator.isNull(name)) {
405                            throw new ColumnNameException();
406                    }
407    
408                    List<ExpandoColumn> columns = expandoColumnPersistence.findByT_N(
409                            tableId, name);
410    
411                    if (!columns.isEmpty()) {
412                            ExpandoColumn column = columns.get(0);
413    
414                            if (column.getColumnId() != columnId) {
415                                    throw new DuplicateColumnNameException();
416                            }
417                    }
418    
419                    if ((type != ExpandoColumnConstants.BOOLEAN) &&
420                            (type != ExpandoColumnConstants.BOOLEAN_ARRAY) &&
421                            (type != ExpandoColumnConstants.DATE) &&
422                            (type != ExpandoColumnConstants.DATE_ARRAY) &&
423                            (type != ExpandoColumnConstants.DOUBLE) &&
424                            (type != ExpandoColumnConstants.DOUBLE_ARRAY) &&
425                            (type != ExpandoColumnConstants.FLOAT) &&
426                            (type != ExpandoColumnConstants.FLOAT_ARRAY) &&
427                            (type != ExpandoColumnConstants.INTEGER) &&
428                            (type != ExpandoColumnConstants.INTEGER_ARRAY) &&
429                            (type != ExpandoColumnConstants.LONG) &&
430                            (type != ExpandoColumnConstants.LONG_ARRAY) &&
431                            (type != ExpandoColumnConstants.NUMBER) &&
432                            (type != ExpandoColumnConstants.NUMBER_ARRAY) &&
433                            (type != ExpandoColumnConstants.SHORT) &&
434                            (type != ExpandoColumnConstants.SHORT_ARRAY) &&
435                            (type != ExpandoColumnConstants.STRING) &&
436                            (type != ExpandoColumnConstants.STRING_ARRAY)) {
437    
438                            throw new ColumnTypeException();
439                    }
440    
441                    ExpandoValue value = new ExpandoValueImpl();
442    
443                    if (defaultData != null) {
444                            value.setColumnId(columnId);
445    
446                            if (type == ExpandoColumnConstants.BOOLEAN) {
447                                    value.setBoolean((Boolean)defaultData);
448                            }
449                            else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
450                                    value.setBooleanArray((boolean[])defaultData);
451                            }
452                            else if (type == ExpandoColumnConstants.DATE) {
453                                    value.setDate((Date)defaultData);
454                            }
455                            else if (type == ExpandoColumnConstants.DATE_ARRAY) {
456                                    value.setDateArray((Date[])defaultData);
457                            }
458                            else if (type == ExpandoColumnConstants.DOUBLE) {
459                                    value.setDouble((Double)defaultData);
460                            }
461                            else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
462                                    value.setDoubleArray((double[])defaultData);
463                            }
464                            else if (type == ExpandoColumnConstants.FLOAT) {
465                                    value.setFloat((Float)defaultData);
466                            }
467                            else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
468                                    value.setFloatArray((float[])defaultData);
469                            }
470                            else if (type == ExpandoColumnConstants.INTEGER) {
471                                    value.setInteger((Integer)defaultData);
472                            }
473                            else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
474                                    value.setIntegerArray((int[])defaultData);
475                            }
476                            else if (type == ExpandoColumnConstants.LONG) {
477                                    value.setLong((Long)defaultData);
478                            }
479                            else if (type == ExpandoColumnConstants.LONG_ARRAY) {
480                                    value.setLongArray((long[])defaultData);
481                            }
482                            else if (type == ExpandoColumnConstants.NUMBER) {
483                                    value.setNumber((Number)defaultData);
484                            }
485                            else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
486                                    value.setNumberArray((Number[])defaultData);
487                            }
488                            else if (type == ExpandoColumnConstants.SHORT) {
489                                    value.setShort((Short)defaultData);
490                            }
491                            else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
492                                    value.setShortArray((short[])defaultData);
493                            }
494                            else if (type == ExpandoColumnConstants.STRING) {
495                                    value.setString((String)defaultData);
496                            }
497                            else if (type == ExpandoColumnConstants.STRING_ARRAY) {
498                                    value.setStringArray((String[])defaultData);
499                            }
500                    }
501    
502                    return value;
503            }
504    
505    }