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    import com.liferay.portlet.dynamicdatamapping.validator.DDMFormValuesValidatorUtil;
035    
036    import java.util.List;
037    import java.util.Map;
038    
039    /**
040     * @author Eduardo Lundgren
041     * @author Brian Wing Shun Chan
042     * @author Marcellus Tavares
043     */
044    public abstract class BaseStorageAdapter implements StorageAdapter {
045    
046            @Override
047            public long create(
048                            long companyId, long ddmStructureId, DDMFormValues ddmFormValues,
049                            ServiceContext serviceContext)
050                    throws StorageException {
051    
052                    try {
053                            validateDDMFormValues(ddmFormValues);
054    
055                            transformDDMFormValues(ddmFormValues, serviceContext);
056    
057                            return doCreate(
058                                    companyId, ddmStructureId, ddmFormValues, serviceContext);
059                    }
060                    catch (StorageException se) {
061                            throw se;
062                    }
063                    catch (Exception e) {
064                            throw new StorageException(e);
065                    }
066            }
067    
068            @Override
069            public long create(
070                            long companyId, long ddmStructureId, Fields fields,
071                            ServiceContext serviceContext)
072                    throws StorageException {
073    
074                    try {
075                            validateDDMStructureFields(ddmStructureId, fields);
076    
077                            fields = transformFields(ddmStructureId, fields, serviceContext);
078    
079                            return doCreate(companyId, ddmStructureId, fields, serviceContext);
080                    }
081                    catch (StorageException se) {
082                            throw se;
083                    }
084                    catch (Exception e) {
085                            throw new StorageException(e);
086                    }
087            }
088    
089            @Override
090            public void deleteByClass(long classPK) throws StorageException {
091                    try {
092                            doDeleteByClass(classPK);
093                    }
094                    catch (StorageException se) {
095                            throw se;
096                    }
097                    catch (Exception e) {
098                            throw new StorageException(e);
099                    }
100            }
101    
102            @Override
103            public void deleteByDDMStructure(long ddmStructureId)
104                    throws StorageException {
105    
106                    try {
107                            doDeleteByDDMStructure(ddmStructureId);
108                    }
109                    catch (StorageException se) {
110                            throw se;
111                    }
112                    catch (Exception e) {
113                            throw new StorageException(e);
114                    }
115            }
116    
117            @Override
118            public DDMFormValues getDDMFormValues(long classPK)
119                    throws StorageException {
120    
121                    try {
122                            return doGetDDMFormValues(classPK);
123                    }
124                    catch (StorageException se) {
125                            throw se;
126                    }
127                    catch (Exception e) {
128                            throw new StorageException(e);
129                    }
130            }
131    
132            @Override
133            public Fields getFields(long classPK) throws StorageException {
134                    return getFields(classPK, null);
135            }
136    
137            @Override
138            public Fields getFields(long classPK, List<String> fieldNames)
139                    throws StorageException {
140    
141                    try {
142                            DDMStorageLink ddmStorageLink =
143                                    DDMStorageLinkLocalServiceUtil.getClassStorageLink(classPK);
144    
145                            Map<Long, Fields> fieldsMapByClasses = getFieldsMap(
146                                    ddmStorageLink.getStructureId(), new long[] {classPK},
147                                    fieldNames);
148    
149                            return fieldsMapByClasses.get(classPK);
150                    }
151                    catch (StorageException se) {
152                            throw se;
153                    }
154                    catch (Exception e) {
155                            throw new StorageException(e);
156                    }
157            }
158    
159            @Override
160            public List<Fields> getFieldsList(
161                            long ddmStructureId, List<String> fieldNames)
162                    throws StorageException {
163    
164                    return getFieldsList(ddmStructureId, fieldNames, null);
165            }
166    
167            @Override
168            public List<Fields> getFieldsList(
169                            long ddmStructureId, List<String> fieldNames,
170                            OrderByComparator<Fields> orderByComparator)
171                    throws StorageException {
172    
173                    try {
174                            return doGetFieldsListByDDMStructure(
175                                    ddmStructureId, fieldNames, orderByComparator);
176                    }
177                    catch (StorageException se) {
178                            throw se;
179                    }
180                    catch (Exception e) {
181                            throw new StorageException(e);
182                    }
183            }
184    
185            @Override
186            public List<Fields> getFieldsList(
187                            long ddmStructureId, long[] classPKs, List<String> fieldNames,
188                            OrderByComparator<Fields> orderByComparator)
189                    throws StorageException {
190    
191                    try {
192                            return doGetFieldsListByClasses(
193                                    ddmStructureId, classPKs, fieldNames, orderByComparator);
194                    }
195                    catch (StorageException se) {
196                            throw se;
197                    }
198                    catch (Exception e) {
199                            throw new StorageException(e);
200                    }
201            }
202    
203            @Override
204            public List<Fields> getFieldsList(
205                            long ddmStructureId, long[] classPKs,
206                            OrderByComparator<Fields> orderByComparator)
207                    throws StorageException {
208    
209                    return getFieldsList(ddmStructureId, classPKs, null, orderByComparator);
210            }
211    
212            @Override
213            public Map<Long, Fields> getFieldsMap(long ddmStructureId, long[] classPKs)
214                    throws StorageException {
215    
216                    return getFieldsMap(ddmStructureId, classPKs, null);
217            }
218    
219            @Override
220            public Map<Long, Fields> getFieldsMap(
221                            long ddmStructureId, long[] classPKs, List<String> fieldNames)
222                    throws StorageException {
223    
224                    try {
225                            return doGetFieldsMapByClasses(
226                                    ddmStructureId, classPKs, fieldNames);
227                    }
228                    catch (StorageException se) {
229                            throw se;
230                    }
231                    catch (Exception e) {
232                            throw new StorageException(e);
233                    }
234            }
235    
236            @Override
237            public List<Fields> query(
238                            long ddmStructureId, List<String> fieldNames, Condition condition,
239                            OrderByComparator<Fields> orderByComparator)
240                    throws StorageException {
241    
242                    try {
243                            return doQuery(
244                                    ddmStructureId, fieldNames, condition, orderByComparator);
245                    }
246                    catch (StorageException se) {
247                            throw se;
248                    }
249                    catch (Exception e) {
250                            throw new StorageException(e);
251                    }
252            }
253    
254            @Override
255            public int queryCount(long ddmStructureId, Condition condition)
256                    throws StorageException {
257    
258                    try {
259                            return doQueryCount(ddmStructureId, condition);
260                    }
261                    catch (StorageException se) {
262                            throw se;
263                    }
264                    catch (Exception e) {
265                            throw new StorageException(e);
266                    }
267            }
268    
269            @Override
270            public void update(
271                            long classPK, DDMFormValues ddmFormValues,
272                            ServiceContext serviceContext)
273                    throws StorageException {
274    
275                    try {
276                            validateDDMFormValues(ddmFormValues);
277    
278                            transformDDMFormValues(ddmFormValues, serviceContext);
279    
280                            doUpdate(classPK, ddmFormValues, serviceContext);
281                    }
282                    catch (StorageException se) {
283                            throw se;
284                    }
285                    catch (Exception e) {
286                            throw new StorageException(e);
287                    }
288            }
289    
290            @Override
291            public void update(
292                            long classPK, Fields fields, boolean mergeFields,
293                            ServiceContext serviceContext)
294                    throws StorageException {
295    
296                    try {
297                            DDMStorageLink ddmStorageLink =
298                                    DDMStorageLinkLocalServiceUtil.getClassStorageLink(classPK);
299    
300                            validateDDMStructureFields(ddmStorageLink.getStructureId(), fields);
301    
302                            fields = transformFields(
303                                    ddmStorageLink.getStructureId(), fields, serviceContext);
304    
305                            doUpdate(classPK, fields, mergeFields, serviceContext);
306                    }
307                    catch (StorageException se) {
308                            throw se;
309                    }
310                    catch (Exception e) {
311                            throw new StorageException(e);
312                    }
313            }
314    
315            @Override
316            public void update(
317                            long classPK, Fields fields, ServiceContext serviceContext)
318                    throws StorageException {
319    
320                    update(classPK, fields, false, serviceContext);
321            }
322    
323            protected long doCreate(
324                            long companyId, long ddmStructureId, DDMFormValues ddmFormValues,
325                            ServiceContext serviceContext)
326                    throws Exception {
327    
328                    DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getStructure(
329                            ddmStructureId);
330    
331                    Fields fields = DDMFormValuesToFieldsConverterUtil.convert(
332                            ddmStructure, ddmFormValues);
333    
334                    return doCreate(companyId, ddmStructureId, fields, serviceContext);
335            }
336    
337            protected abstract long doCreate(
338                            long companyId, long ddmStructureId, Fields fields,
339                            ServiceContext serviceContext)
340                    throws Exception;
341    
342            protected abstract void doDeleteByClass(long classPK) throws Exception;
343    
344            protected abstract void doDeleteByDDMStructure(long ddmStructureId)
345                    throws Exception;
346    
347            protected DDMFormValues doGetDDMFormValues(long classPK) throws Exception {
348                    DDMStorageLink ddmStorageLink =
349                            DDMStorageLinkLocalServiceUtil.getClassStorageLink(classPK);
350    
351                    DDMStructure ddmStructure = ddmStorageLink.getStructure();
352    
353                    Fields fields = getFields(classPK);
354    
355                    return FieldsToDDMFormValuesConverterUtil.convert(ddmStructure, fields);
356            }
357    
358            protected abstract List<Fields> doGetFieldsListByClasses(
359                            long ddmStructureId, long[] classPKs, List<String> fieldNames,
360                            OrderByComparator<Fields> orderByComparator)
361                    throws Exception;
362    
363            protected abstract List<Fields> doGetFieldsListByDDMStructure(
364                            long ddmStructureId, List<String> fieldNames,
365                            OrderByComparator<Fields> orderByComparator)
366                    throws Exception;
367    
368            protected abstract Map<Long, Fields> doGetFieldsMapByClasses(
369                            long ddmStructureId, long[] classPKs, List<String> fieldNames)
370                    throws Exception;
371    
372            protected abstract List<Fields> doQuery(
373                            long ddmStructureId, List<String> fieldNames, Condition condition,
374                            OrderByComparator<Fields> orderByComparator)
375                    throws Exception;
376    
377            protected abstract int doQueryCount(
378                            long ddmStructureId, Condition condition)
379                    throws Exception;
380    
381            protected void doUpdate(
382                            long classPK, DDMFormValues ddmFormValues,
383                            ServiceContext serviceContext)
384                    throws Exception {
385    
386                    DDMStorageLink ddmStorageLink =
387                            DDMStorageLinkLocalServiceUtil.getClassStorageLink(classPK);
388    
389                    DDMStructure ddmStructure = ddmStorageLink.getStructure();
390    
391                    Fields fields = DDMFormValuesToFieldsConverterUtil.convert(
392                            ddmStructure, ddmFormValues);
393    
394                    doUpdate(classPK, fields, false, serviceContext);
395            }
396    
397            protected abstract void doUpdate(
398                            long classPK, Fields fields, boolean mergeFields,
399                            ServiceContext serviceContext)
400                    throws Exception;
401    
402            protected void transformDDMFormValues(
403                            DDMFormValues ddmFormValues, ServiceContext serviceContext)
404                    throws PortalException {
405    
406                    DDMFormValuesTransformer ddmFormValuesTransformer =
407                            new DDMFormValuesTransformer(ddmFormValues);
408    
409                    ddmFormValuesTransformer.addTransformer(
410                            new DocumentLibraryDDMFormFieldValueTransformer());
411    
412                    ddmFormValuesTransformer.addTransformer(
413                            new HTMLSanitizerDDMFormFieldValueTransformer(
414                                    serviceContext.getCompanyId(), serviceContext.getScopeGroupId(),
415                                    serviceContext.getUserId()));
416    
417                    ddmFormValuesTransformer.transform();
418            }
419    
420            protected Fields transformFields(
421                            long ddmStructureId, Fields fields, ServiceContext serviceContext)
422                    throws PortalException {
423    
424                    DDMStructure ddmStructure =
425                            DDMStructureLocalServiceUtil.getDDMStructure(ddmStructureId);
426    
427                    DDMFormValues ddmFormValues =
428                            FieldsToDDMFormValuesConverterUtil.convert(ddmStructure, fields);
429    
430                    transformDDMFormValues(ddmFormValues, serviceContext);
431    
432                    return DDMFormValuesToFieldsConverterUtil.convert(
433                            ddmStructure, ddmFormValues);
434            }
435    
436            protected void validateDDMFormValues(DDMFormValues ddmFormValues)
437                    throws PortalException {
438    
439                    DDMFormValuesValidatorUtil.validate(ddmFormValues);
440            }
441    
442            protected void validateDDMStructureFields(
443                            long ddmStructureId, Fields fields)
444                    throws PortalException {
445    
446                    DDMStructure ddmStructure =
447                            DDMStructureLocalServiceUtil.getDDMStructure(ddmStructureId);
448    
449                    for (Field field : fields) {
450                            if (!ddmStructure.hasField(field.getName())) {
451                                    throw new StorageFieldNameException();
452                            }
453    
454                            if (ddmStructure.getFieldRequired(field.getName()) &&
455                                    Validator.isNull(field.getValue())) {
456    
457                                    throw new StorageFieldRequiredException();
458                            }
459                    }
460            }
461    
462    }