001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatamapping.storage;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.util.OrderByComparator;
019    import com.liferay.portal.kernel.util.Validator;
020    import com.liferay.portal.service.ServiceContext;
021    import com.liferay.portlet.dynamicdatamapping.StorageException;
022    import com.liferay.portlet.dynamicdatamapping.StorageFieldNameException;
023    import com.liferay.portlet.dynamicdatamapping.StorageFieldRequiredException;
024    import com.liferay.portlet.dynamicdatamapping.model.DDMStorageLink;
025    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
026    import com.liferay.portlet.dynamicdatamapping.service.DDMStorageLinkLocalServiceUtil;
027    import com.liferay.portlet.dynamicdatamapping.service.DDMStructureLocalServiceUtil;
028    import com.liferay.portlet.dynamicdatamapping.storage.query.Condition;
029    import com.liferay.portlet.dynamicdatamapping.util.DDMFormValuesToFieldsConverterUtil;
030    import com.liferay.portlet.dynamicdatamapping.util.DDMFormValuesTransformer;
031    import com.liferay.portlet.dynamicdatamapping.util.DocumentLibraryDDMFormFieldValueTransformer;
032    import com.liferay.portlet.dynamicdatamapping.util.FieldsToDDMFormValuesConverterUtil;
033    import com.liferay.portlet.dynamicdatamapping.util.HTMLSanitizerDDMFormFieldValueTransformer;
034    
035    import java.util.List;
036    import java.util.Map;
037    
038    /**
039     * @author Eduardo Lundgren
040     * @author Brian Wing Shun Chan
041     * @author Marcellus Tavares
042     */
043    public abstract class BaseStorageAdapter implements StorageAdapter {
044    
045            @Override
046            public long create(
047                            long companyId, long ddmStructureId, Fields fields,
048                            ServiceContext serviceContext)
049                    throws StorageException {
050    
051                    try {
052                            validateDDMStructureFields(ddmStructureId, fields);
053    
054                            fields = transformFields(ddmStructureId, fields, serviceContext);
055    
056                            return doCreate(companyId, ddmStructureId, fields, serviceContext);
057                    }
058                    catch (StorageException se) {
059                            throw se;
060                    }
061                    catch (Exception e) {
062                            throw new StorageException(e);
063                    }
064            }
065    
066            @Override
067            public void deleteByClass(long classPK) throws StorageException {
068                    try {
069                            doDeleteByClass(classPK);
070                    }
071                    catch (StorageException se) {
072                            throw se;
073                    }
074                    catch (Exception e) {
075                            throw new StorageException(e);
076                    }
077            }
078    
079            @Override
080            public void deleteByDDMStructure(long ddmStructureId)
081                    throws StorageException {
082    
083                    try {
084                            doDeleteByDDMStructure(ddmStructureId);
085                    }
086                    catch (StorageException se) {
087                            throw se;
088                    }
089                    catch (Exception e) {
090                            throw new StorageException(e);
091                    }
092            }
093    
094            @Override
095            public Fields getFields(long classPK) throws StorageException {
096                    return getFields(classPK, null);
097            }
098    
099            @Override
100            public Fields getFields(long classPK, List<String> fieldNames)
101                    throws StorageException {
102    
103                    try {
104                            DDMStorageLink ddmStorageLink =
105                                    DDMStorageLinkLocalServiceUtil.getClassStorageLink(classPK);
106    
107                            Map<Long, Fields> fieldsMapByClasses = getFieldsMap(
108                                    ddmStorageLink.getStructureId(), new long[] {classPK},
109                                    fieldNames);
110    
111                            return fieldsMapByClasses.get(classPK);
112                    }
113                    catch (StorageException se) {
114                            throw se;
115                    }
116                    catch (Exception e) {
117                            throw new StorageException(e);
118                    }
119            }
120    
121            @Override
122            public List<Fields> getFieldsList(
123                            long ddmStructureId, List<String> fieldNames)
124                    throws StorageException {
125    
126                    return getFieldsList(ddmStructureId, fieldNames, null);
127            }
128    
129            @Override
130            public List<Fields> getFieldsList(
131                            long ddmStructureId, List<String> fieldNames,
132                            OrderByComparator<Fields> orderByComparator)
133                    throws StorageException {
134    
135                    try {
136                            return doGetFieldsListByDDMStructure(
137                                    ddmStructureId, fieldNames, orderByComparator);
138                    }
139                    catch (StorageException se) {
140                            throw se;
141                    }
142                    catch (Exception e) {
143                            throw new StorageException(e);
144                    }
145            }
146    
147            @Override
148            public List<Fields> getFieldsList(
149                            long ddmStructureId, long[] classPKs, List<String> fieldNames,
150                            OrderByComparator<Fields> orderByComparator)
151                    throws StorageException {
152    
153                    try {
154                            return doGetFieldsListByClasses(
155                                    ddmStructureId, classPKs, fieldNames, orderByComparator);
156                    }
157                    catch (StorageException se) {
158                            throw se;
159                    }
160                    catch (Exception e) {
161                            throw new StorageException(e);
162                    }
163            }
164    
165            @Override
166            public List<Fields> getFieldsList(
167                            long ddmStructureId, long[] classPKs,
168                            OrderByComparator<Fields> orderByComparator)
169                    throws StorageException {
170    
171                    return getFieldsList(ddmStructureId, classPKs, null, orderByComparator);
172            }
173    
174            @Override
175            public Map<Long, Fields> getFieldsMap(long ddmStructureId, long[] classPKs)
176                    throws StorageException {
177    
178                    return getFieldsMap(ddmStructureId, classPKs, null);
179            }
180    
181            @Override
182            public Map<Long, Fields> getFieldsMap(
183                            long ddmStructureId, long[] classPKs, List<String> fieldNames)
184                    throws StorageException {
185    
186                    try {
187                            return doGetFieldsMapByClasses(
188                                    ddmStructureId, classPKs, fieldNames);
189                    }
190                    catch (StorageException se) {
191                            throw se;
192                    }
193                    catch (Exception e) {
194                            throw new StorageException(e);
195                    }
196            }
197    
198            @Override
199            public List<Fields> query(
200                            long ddmStructureId, List<String> fieldNames, Condition condition,
201                            OrderByComparator<Fields> orderByComparator)
202                    throws StorageException {
203    
204                    try {
205                            return doQuery(
206                                    ddmStructureId, fieldNames, condition, orderByComparator);
207                    }
208                    catch (StorageException se) {
209                            throw se;
210                    }
211                    catch (Exception e) {
212                            throw new StorageException(e);
213                    }
214            }
215    
216            @Override
217            public int queryCount(long ddmStructureId, Condition condition)
218                    throws StorageException {
219    
220                    try {
221                            return doQueryCount(ddmStructureId, condition);
222                    }
223                    catch (StorageException se) {
224                            throw se;
225                    }
226                    catch (Exception e) {
227                            throw new StorageException(e);
228                    }
229            }
230    
231            @Override
232            public void update(
233                            long classPK, Fields fields, boolean mergeFields,
234                            ServiceContext serviceContext)
235                    throws StorageException {
236    
237                    try {
238                            DDMStorageLink ddmStorageLink =
239                                    DDMStorageLinkLocalServiceUtil.getClassStorageLink(classPK);
240    
241                            validateDDMStructureFields(ddmStorageLink.getStructureId(), fields);
242    
243                            fields = transformFields(
244                                    ddmStorageLink.getStructureId(), fields, serviceContext);
245    
246                            doUpdate(classPK, fields, mergeFields, serviceContext);
247                    }
248                    catch (StorageException se) {
249                            throw se;
250                    }
251                    catch (Exception e) {
252                            throw new StorageException(e);
253                    }
254            }
255    
256            @Override
257            public void update(
258                            long classPK, Fields fields, ServiceContext serviceContext)
259                    throws StorageException {
260    
261                    update(classPK, fields, false, serviceContext);
262            }
263    
264            protected abstract long doCreate(
265                            long companyId, long ddmStructureId, Fields fields,
266                            ServiceContext serviceContext)
267                    throws Exception;
268    
269            protected abstract void doDeleteByClass(long classPK) throws Exception;
270    
271            protected abstract void doDeleteByDDMStructure(long ddmStructureId)
272                    throws Exception;
273    
274            protected abstract List<Fields> doGetFieldsListByClasses(
275                            long ddmStructureId, long[] classPKs, List<String> fieldNames,
276                            OrderByComparator<Fields> orderByComparator)
277                    throws Exception;
278    
279            protected abstract List<Fields> doGetFieldsListByDDMStructure(
280                            long ddmStructureId, List<String> fieldNames,
281                            OrderByComparator<Fields> orderByComparator)
282                    throws Exception;
283    
284            protected abstract Map<Long, Fields> doGetFieldsMapByClasses(
285                            long ddmStructureId, long[] classPKs, List<String> fieldNames)
286                    throws Exception;
287    
288            protected abstract List<Fields> doQuery(
289                            long ddmStructureId, List<String> fieldNames, Condition condition,
290                            OrderByComparator<Fields> orderByComparator)
291                    throws Exception;
292    
293            protected abstract int doQueryCount(
294                            long ddmStructureId, Condition condition)
295                    throws Exception;
296    
297            protected abstract void doUpdate(
298                            long classPK, Fields fields, boolean mergeFields,
299                            ServiceContext serviceContext)
300                    throws Exception;
301    
302            protected Fields transformFields(
303                            long ddmStructureId, Fields fields, ServiceContext serviceContext)
304                    throws PortalException {
305    
306                    DDMStructure ddmStructure =
307                            DDMStructureLocalServiceUtil.getDDMStructure(ddmStructureId);
308    
309                    DDMFormValues ddmFormValues =
310                            FieldsToDDMFormValuesConverterUtil.convert(ddmStructure, fields);
311    
312                    DDMFormValuesTransformer ddmFormValuesTransformer =
313                            new DDMFormValuesTransformer(ddmFormValues);
314    
315                    ddmFormValuesTransformer.addTransformer(
316                            new DocumentLibraryDDMFormFieldValueTransformer());
317    
318                    ddmFormValuesTransformer.addTransformer(
319                            new HTMLSanitizerDDMFormFieldValueTransformer(
320                                    serviceContext.getCompanyId(), serviceContext.getScopeGroupId(),
321                                    serviceContext.getUserId()));
322    
323                    ddmFormValuesTransformer.transform();
324    
325                    return DDMFormValuesToFieldsConverterUtil.convert(
326                            ddmStructure, ddmFormValues);
327            }
328    
329            protected void validateDDMStructureFields(
330                            long ddmStructureId, Fields fields)
331                    throws PortalException {
332    
333                    DDMStructure ddmStructure =
334                            DDMStructureLocalServiceUtil.getDDMStructure(ddmStructureId);
335    
336                    for (Field field : fields) {
337                            if (!ddmStructure.hasField(field.getName())) {
338                                    throw new StorageFieldNameException();
339                            }
340    
341                            if (ddmStructure.getFieldRequired(field.getName()) &&
342                                    Validator.isNull(field.getValue())) {
343    
344                                    throw new StorageFieldRequiredException();
345                            }
346                    }
347            }
348    
349    }