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