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