001
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
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 }