001
014
015 package com.liferay.portlet.dynamicdatamapping.service.impl;
016
017 import com.liferay.portal.LocaleException;
018 import com.liferay.portal.kernel.dao.orm.QueryUtil;
019 import com.liferay.portal.kernel.exception.PortalException;
020 import com.liferay.portal.kernel.exception.SystemException;
021 import com.liferay.portal.kernel.language.LanguageUtil;
022 import com.liferay.portal.kernel.log.Log;
023 import com.liferay.portal.kernel.log.LogFactoryUtil;
024 import com.liferay.portal.kernel.search.Indexer;
025 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
026 import com.liferay.portal.kernel.systemevent.SystemEvent;
027 import com.liferay.portal.kernel.util.ArrayUtil;
028 import com.liferay.portal.kernel.util.GetterUtil;
029 import com.liferay.portal.kernel.util.GroupThreadLocal;
030 import com.liferay.portal.kernel.util.HtmlUtil;
031 import com.liferay.portal.kernel.util.LocaleUtil;
032 import com.liferay.portal.kernel.util.OrderByComparator;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.Validator;
036 import com.liferay.portal.kernel.xml.Document;
037 import com.liferay.portal.kernel.xml.DocumentException;
038 import com.liferay.portal.kernel.xml.Element;
039 import com.liferay.portal.kernel.xml.Node;
040 import com.liferay.portal.kernel.xml.SAXReaderUtil;
041 import com.liferay.portal.kernel.xml.XPath;
042 import com.liferay.portal.model.Group;
043 import com.liferay.portal.model.ResourceConstants;
044 import com.liferay.portal.model.SystemEventConstants;
045 import com.liferay.portal.model.User;
046 import com.liferay.portal.security.auth.CompanyThreadLocal;
047 import com.liferay.portal.service.ServiceContext;
048 import com.liferay.portal.util.PortalUtil;
049 import com.liferay.portal.util.PropsValues;
050 import com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
051 import com.liferay.portlet.dynamicdatamapping.RequiredStructureException;
052 import com.liferay.portlet.dynamicdatamapping.StructureDuplicateElementException;
053 import com.liferay.portlet.dynamicdatamapping.StructureDuplicateStructureKeyException;
054 import com.liferay.portlet.dynamicdatamapping.StructureNameException;
055 import com.liferay.portlet.dynamicdatamapping.StructureXsdException;
056 import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
057 import com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants;
058 import com.liferay.portlet.dynamicdatamapping.model.DDMTemplate;
059 import com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants;
060 import com.liferay.portlet.dynamicdatamapping.service.base.DDMStructureLocalServiceBaseImpl;
061 import com.liferay.portlet.dynamicdatamapping.util.DDMTemplateHelperUtil;
062 import com.liferay.portlet.dynamicdatamapping.util.DDMXMLUtil;
063
064 import java.util.ArrayList;
065 import java.util.Date;
066 import java.util.HashSet;
067 import java.util.List;
068 import java.util.Locale;
069 import java.util.Map;
070 import java.util.Set;
071
072
097 public class DDMStructureLocalServiceImpl
098 extends DDMStructureLocalServiceBaseImpl {
099
100
129 @Override
130 public DDMStructure addStructure(
131 long userId, long groupId, long parentStructureId, long classNameId,
132 String structureKey, Map<Locale, String> nameMap,
133 Map<Locale, String> descriptionMap, String xsd, String storageType,
134 int type, ServiceContext serviceContext)
135 throws PortalException, SystemException {
136
137
138
139 User user = userPersistence.findByPrimaryKey(userId);
140
141 if (Validator.isNull(structureKey)) {
142 structureKey = String.valueOf(counterLocalService.increment());
143 }
144 else {
145 structureKey = StringUtil.toUpperCase(structureKey.trim());
146 }
147
148 try {
149 xsd = DDMXMLUtil.validateXML(xsd);
150 xsd = DDMXMLUtil.formatXML(xsd);
151 }
152 catch (Exception e) {
153 throw new StructureXsdException();
154 }
155
156 Date now = new Date();
157
158 validate(
159 groupId, parentStructureId, classNameId, structureKey, nameMap,
160 xsd);
161
162 long structureId = counterLocalService.increment();
163
164 DDMStructure structure = ddmStructurePersistence.create(structureId);
165
166 structure.setUuid(serviceContext.getUuid());
167 structure.setGroupId(groupId);
168 structure.setCompanyId(user.getCompanyId());
169 structure.setUserId(user.getUserId());
170 structure.setUserName(user.getFullName());
171 structure.setCreateDate(serviceContext.getCreateDate(now));
172 structure.setModifiedDate(serviceContext.getModifiedDate(now));
173 structure.setParentStructureId(parentStructureId);
174 structure.setClassNameId(classNameId);
175 structure.setStructureKey(structureKey);
176 structure.setNameMap(nameMap);
177 structure.setDescriptionMap(descriptionMap);
178 structure.setXsd(xsd);
179 structure.setStorageType(storageType);
180 structure.setType(type);
181
182 ddmStructurePersistence.update(structure);
183
184
185
186 if (serviceContext.isAddGroupPermissions() ||
187 serviceContext.isAddGuestPermissions()) {
188
189 addStructureResources(
190 structure, serviceContext.isAddGroupPermissions(),
191 serviceContext.isAddGuestPermissions());
192 }
193 else {
194 addStructureResources(
195 structure, serviceContext.getGroupPermissions(),
196 serviceContext.getGuestPermissions());
197 }
198
199 return structure;
200 }
201
202
223 @Override
224 public DDMStructure addStructure(
225 long userId, long groupId, long classNameId,
226 Map<Locale, String> nameMap, Map<Locale, String> descriptionMap,
227 String xsd, ServiceContext serviceContext)
228 throws PortalException, SystemException {
229
230 return addStructure(
231 userId, groupId, DDMStructureConstants.DEFAULT_PARENT_STRUCTURE_ID,
232 classNameId, null, nameMap, descriptionMap, xsd,
233 PropsValues.DYNAMIC_DATA_LISTS_STORAGE_TYPE,
234 DDMStructureConstants.TYPE_DEFAULT, serviceContext);
235 }
236
237
266 @Override
267 public DDMStructure addStructure(
268 long userId, long groupId, String parentStructureKey,
269 long classNameId, String structureKey, Map<Locale, String> nameMap,
270 Map<Locale, String> descriptionMap, String xsd, String storageType,
271 int type, ServiceContext serviceContext)
272 throws PortalException, SystemException {
273
274 DDMStructure parentStructure = fetchStructure(
275 groupId, classNameId, parentStructureKey);
276
277 long parentStructureId =
278 DDMStructureConstants.DEFAULT_PARENT_STRUCTURE_ID;
279
280 if (parentStructure != null) {
281 parentStructureId = parentStructure.getStructureId();
282 }
283
284 return addStructure(
285 userId, groupId, parentStructureId, classNameId, structureKey,
286 nameMap, descriptionMap, xsd, storageType, type, serviceContext);
287 }
288
289
298 @Override
299 public void addStructureResources(
300 DDMStructure structure, boolean addGroupPermissions,
301 boolean addGuestPermissions)
302 throws PortalException, SystemException {
303
304 resourceLocalService.addResources(
305 structure.getCompanyId(), structure.getGroupId(),
306 structure.getUserId(), DDMStructure.class.getName(),
307 structure.getStructureId(), false, addGroupPermissions,
308 addGuestPermissions);
309 }
310
311
320 @Override
321 public void addStructureResources(
322 DDMStructure structure, String[] groupPermissions,
323 String[] guestPermissions)
324 throws PortalException, SystemException {
325
326 resourceLocalService.addModelResources(
327 structure.getCompanyId(), structure.getGroupId(),
328 structure.getUserId(), DDMStructure.class.getName(),
329 structure.getStructureId(), groupPermissions, guestPermissions);
330 }
331
332
349 @Override
350 public DDMStructure copyStructure(
351 long userId, long structureId, Map<Locale, String> nameMap,
352 Map<Locale, String> descriptionMap, ServiceContext serviceContext)
353 throws PortalException, SystemException {
354
355 DDMStructure structure = ddmStructurePersistence.findByPrimaryKey(
356 structureId);
357
358 return addStructure(
359 userId, structure.getGroupId(), structure.getParentStructureId(),
360 structure.getClassNameId(), null, nameMap, descriptionMap,
361 structure.getXsd(), structure.getStorageType(), structure.getType(),
362 serviceContext);
363 }
364
365 @Override
366 public DDMStructure copyStructure(
367 long userId, long structureId, ServiceContext serviceContext)
368 throws PortalException, SystemException {
369
370 DDMStructure structure = ddmStructurePersistence.findByPrimaryKey(
371 structureId);
372
373 return addStructure(
374 userId, structure.getGroupId(), structure.getParentStructureId(),
375 structure.getClassNameId(), null, structure.getNameMap(),
376 structure.getDescriptionMap(), structure.getXsd(),
377 structure.getStorageType(), structure.getType(), serviceContext);
378 }
379
380
392 @Override
393 @SystemEvent(type = SystemEventConstants.TYPE_DELETE)
394 public void deleteStructure(DDMStructure structure)
395 throws PortalException, SystemException {
396
397 if (!GroupThreadLocal.isDeleteInProcess()) {
398 if (ddmStructureLinkPersistence.countByStructureId(
399 structure.getStructureId()) > 0) {
400
401 throw new RequiredStructureException(
402 RequiredStructureException.REFERENCED_STRUCTURE_LINK);
403 }
404
405 if (ddmStructurePersistence.countByParentStructureId(
406 structure.getStructureId()) > 0) {
407
408 throw new RequiredStructureException(
409 RequiredStructureException.REFERENCED_STRUCTURE);
410 }
411
412 long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
413
414 if (ddmTemplatePersistence.countByG_C_C(
415 structure.getGroupId(), classNameId,
416 structure.getPrimaryKey()) > 0) {
417
418 throw new RequiredStructureException(
419 RequiredStructureException.REFERENCED_TEMPLATE);
420 }
421 }
422
423
424
425 ddmStructurePersistence.remove(structure);
426
427
428
429 resourceLocalService.deleteResource(
430 structure.getCompanyId(), DDMStructure.class.getName(),
431 ResourceConstants.SCOPE_INDIVIDUAL, structure.getStructureId());
432 }
433
434
446 @Override
447 public void deleteStructure(long structureId)
448 throws PortalException, SystemException {
449
450 DDMStructure structure = ddmStructurePersistence.findByPrimaryKey(
451 structureId);
452
453 ddmStructureLocalService.deleteStructure(structure);
454 }
455
456
471 @Override
472 public void deleteStructure(
473 long groupId, long classNameId, String structureKey)
474 throws PortalException, SystemException {
475
476 structureKey = getStructureKey(structureKey);
477
478 DDMStructure structure = ddmStructurePersistence.findByG_C_S(
479 groupId, classNameId, structureKey);
480
481 ddmStructureLocalService.deleteStructure(structure);
482 }
483
484
497 @Override
498 public void deleteStructures(long groupId)
499 throws PortalException, SystemException {
500
501 List<DDMStructure> structures = ddmStructurePersistence.findByGroupId(
502 groupId);
503
504 deleteStructures(structures);
505 }
506
507 @Override
508 public void deleteStructures(long groupId, long classNameId)
509 throws PortalException, SystemException {
510
511 List<DDMStructure> structures = ddmStructurePersistence.findByG_C(
512 groupId, classNameId);
513
514 deleteStructures(structures);
515 }
516
517
525 @Override
526 public DDMStructure fetchStructure(long structureId)
527 throws SystemException {
528
529 return ddmStructurePersistence.fetchByPrimaryKey(structureId);
530 }
531
532
544 @Override
545 public DDMStructure fetchStructure(
546 long groupId, long classNameId, String structureKey)
547 throws SystemException {
548
549 structureKey = getStructureKey(structureKey);
550
551 return ddmStructurePersistence.fetchByG_C_S(
552 groupId, classNameId, structureKey);
553 }
554
555
576 @Override
577 public DDMStructure fetchStructure(
578 long groupId, long classNameId, String structureKey,
579 boolean includeGlobalStructures)
580 throws PortalException, SystemException {
581
582 structureKey = getStructureKey(structureKey);
583
584 DDMStructure structure = ddmStructurePersistence.fetchByG_C_S(
585 groupId, classNameId, structureKey);
586
587 if ((structure != null) || !includeGlobalStructures) {
588 return structure;
589 }
590
591 Group group = groupPersistence.findByPrimaryKey(groupId);
592
593 Group companyGroup = groupLocalService.getCompanyGroup(
594 group.getCompanyId());
595
596 return ddmStructurePersistence.fetchByG_C_S(
597 companyGroup.getGroupId(), classNameId, structureKey);
598 }
599
600
604 @Override
605 public List<DDMStructure> getClassStructures(long classNameId)
606 throws SystemException {
607
608 return ddmStructurePersistence.findByClassNameId(classNameId);
609 }
610
611
615 @Override
616 public List<DDMStructure> getClassStructures(
617 long classNameId, int start, int end)
618 throws SystemException {
619
620 return ddmStructurePersistence.findByClassNameId(
621 classNameId, start, end);
622 }
623
624
633 @Override
634 public List<DDMStructure> getClassStructures(
635 long companyId, long classNameId)
636 throws SystemException {
637
638 return ddmStructurePersistence.findByC_C(companyId, classNameId);
639 }
640
641
663 @Override
664 public List<DDMStructure> getClassStructures(
665 long companyId, long classNameId, int start, int end)
666 throws SystemException {
667
668 return ddmStructurePersistence.findByC_C(
669 companyId, classNameId, start, end);
670 }
671
672
684 @Override
685 public List<DDMStructure> getClassStructures(
686 long companyId, long classNameId,
687 OrderByComparator orderByComparator)
688 throws SystemException {
689
690 return ddmStructurePersistence.findByC_C(
691 companyId, classNameId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
692 orderByComparator);
693 }
694
695
699 @Override
700 public List<DDMStructure> getClassStructures(
701 long classNameId, OrderByComparator orderByComparator)
702 throws SystemException {
703
704 return ddmStructurePersistence.findByClassNameId(
705 classNameId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
706 orderByComparator);
707 }
708
709
717 @Override
718 public List<DDMStructure> getDLFileEntryTypeStructures(
719 long dlFileEntryTypeId)
720 throws SystemException {
721
722 return dlFileEntryTypePersistence.getDDMStructures(dlFileEntryTypeId);
723 }
724
725
733 @Override
734 public DDMStructure getStructure(long structureId)
735 throws PortalException, SystemException {
736
737 return ddmStructurePersistence.findByPrimaryKey(structureId);
738 }
739
740
752 @Override
753 public DDMStructure getStructure(
754 long groupId, long classNameId, String structureKey)
755 throws PortalException, SystemException {
756
757 structureKey = getStructureKey(structureKey);
758
759 return ddmStructurePersistence.findByG_C_S(
760 groupId, classNameId, structureKey);
761 }
762
763
783 @Override
784 public DDMStructure getStructure(
785 long groupId, long classNameId, String structureKey,
786 boolean includeGlobalStructures)
787 throws PortalException, SystemException {
788
789 structureKey = getStructureKey(structureKey);
790
791 DDMStructure structure = ddmStructurePersistence.fetchByG_C_S(
792 groupId, classNameId, structureKey);
793
794 if (structure != null) {
795 return structure;
796 }
797
798 if (!includeGlobalStructures) {
799 throw new NoSuchStructureException(
800 "No DDMStructure exists with the structure key " +
801 structureKey);
802 }
803
804 Group group = groupPersistence.findByPrimaryKey(groupId);
805
806 Group companyGroup = groupLocalService.getCompanyGroup(
807 group.getCompanyId());
808
809 return ddmStructurePersistence.findByG_C_S(
810 companyGroup.getGroupId(), classNameId, structureKey);
811 }
812
813
822 @Override
823 public List<DDMStructure> getStructure(
824 long groupId, String name, String description)
825 throws SystemException {
826
827 return ddmStructurePersistence.findByG_N_D(groupId, name, description);
828 }
829
830
833 @Override
834 public List<DDMStructure> getStructureEntries() throws SystemException {
835 return getStructures();
836 }
837
838
841 @Override
842 public List<DDMStructure> getStructureEntries(long groupId)
843 throws SystemException {
844
845 return getStructures(groupId);
846 }
847
848
852 @Override
853 public List<DDMStructure> getStructureEntries(
854 long groupId, int start, int end)
855 throws SystemException {
856
857 return getStructures(groupId, start, end);
858 }
859
860
866 @Override
867 public List<DDMStructure> getStructures() throws SystemException {
868 return ddmStructurePersistence.findAll();
869 }
870
871
878 @Override
879 public List<DDMStructure> getStructures(long groupId)
880 throws SystemException {
881
882 return ddmStructurePersistence.findByGroupId(groupId);
883 }
884
885
905 @Override
906 public List<DDMStructure> getStructures(long groupId, int start, int end)
907 throws SystemException {
908
909 return ddmStructurePersistence.findByGroupId(groupId, start, end);
910 }
911
912
921 @Override
922 public List<DDMStructure> getStructures(long groupId, long classNameId)
923 throws SystemException {
924
925 return ddmStructurePersistence.findByG_C(groupId, classNameId);
926 }
927
928
951 @Override
952 public List<DDMStructure> getStructures(
953 long groupId, long classNameId, int start, int end)
954 throws SystemException {
955
956 return ddmStructurePersistence.findByG_C(
957 groupId, classNameId, start, end);
958 }
959
960
985 @Override
986 public List<DDMStructure> getStructures(
987 long groupId, long classNameId, int start, int end,
988 OrderByComparator orderByComparator)
989 throws SystemException {
990
991 return ddmStructurePersistence.findByG_C(
992 groupId, classNameId, start, end, orderByComparator);
993 }
994
995 @Override
996 public List<DDMStructure> getStructures(
997 long groupId, String name, String description)
998 throws SystemException {
999
1000 return ddmStructurePersistence.findByG_N_D(groupId, name, description);
1001 }
1002
1003
1010 @Override
1011 public List<DDMStructure> getStructures(long[] groupIds)
1012 throws SystemException {
1013
1014 return ddmStructurePersistence.findByGroupId(groupIds);
1015 }
1016
1017
1027 @Override
1028 public List<DDMStructure> getStructures(long[] groupIds, long classNameId)
1029 throws SystemException {
1030
1031 return ddmStructurePersistence.findByG_C(groupIds, classNameId);
1032 }
1033
1034
1057 @Override
1058 public List<DDMStructure> getStructures(
1059 long[] groupIds, long classNameId, int start, int end)
1060 throws SystemException {
1061
1062 return ddmStructurePersistence.findByG_C(
1063 groupIds, classNameId, start, end);
1064 }
1065
1066
1073 @Override
1074 public int getStructuresCount(long groupId) throws SystemException {
1075 return ddmStructurePersistence.countByGroupId(groupId);
1076 }
1077
1078
1087 @Override
1088 public int getStructuresCount(long groupId, long classNameId)
1089 throws SystemException {
1090
1091 return ddmStructurePersistence.countByG_C(groupId, classNameId);
1092 }
1093
1094
1104 @Override
1105 public int getStructuresCount(long[] groupIds, long classNameId)
1106 throws SystemException {
1107
1108 return ddmStructurePersistence.countByG_C(groupIds, classNameId);
1109 }
1110
1111
1140 @Override
1141 public List<DDMStructure> search(
1142 long companyId, long[] groupIds, long[] classNameIds,
1143 String keywords, int start, int end,
1144 OrderByComparator orderByComparator)
1145 throws SystemException {
1146
1147 return ddmStructureFinder.findByKeywords(
1148 companyId, groupIds, classNameIds, keywords, start, end,
1149 orderByComparator);
1150 }
1151
1152
1187 @Override
1188 public List<DDMStructure> search(
1189 long companyId, long[] groupIds, long[] classNameIds, String name,
1190 String description, String storageType, int type,
1191 boolean andOperator, int start, int end,
1192 OrderByComparator orderByComparator)
1193 throws SystemException {
1194
1195 return ddmStructureFinder.findByC_G_C_N_D_S_T(
1196 companyId, groupIds, classNameIds, name, description, storageType,
1197 type, andOperator, start, end, orderByComparator);
1198 }
1199
1200
1213 @Override
1214 public int searchCount(
1215 long companyId, long[] groupIds, long[] classNameIds,
1216 String keywords)
1217 throws SystemException {
1218
1219 return ddmStructureFinder.countByKeywords(
1220 companyId, groupIds, classNameIds, keywords);
1221 }
1222
1223
1243 @Override
1244 public int searchCount(
1245 long companyId, long[] groupIds, long[] classNameIds, String name,
1246 String description, String storageType, int type,
1247 boolean andOperator)
1248 throws SystemException {
1249
1250 return ddmStructureFinder.countByC_G_C_N_D_S_T(
1251 companyId, groupIds, classNameIds, name, description, storageType,
1252 type, andOperator);
1253 }
1254
1255
1276 @Override
1277 public DDMStructure updateStructure(
1278 long groupId, long parentStructureId, long classNameId,
1279 String structureKey, Map<Locale, String> nameMap,
1280 Map<Locale, String> descriptionMap, String xsd,
1281 ServiceContext serviceContext)
1282 throws PortalException, SystemException {
1283
1284 structureKey = getStructureKey(structureKey);
1285
1286 DDMStructure structure = ddmStructurePersistence.findByG_C_S(
1287 groupId, classNameId, structureKey);
1288
1289 return doUpdateStructure(
1290 parentStructureId, nameMap, descriptionMap, xsd, serviceContext,
1291 structure);
1292 }
1293
1294
1311 @Override
1312 public DDMStructure updateStructure(
1313 long structureId, long parentStructureId,
1314 Map<Locale, String> nameMap, Map<Locale, String> descriptionMap,
1315 String xsd, ServiceContext serviceContext)
1316 throws PortalException, SystemException {
1317
1318 DDMStructure structure = ddmStructurePersistence.findByPrimaryKey(
1319 structureId);
1320
1321 return doUpdateStructure(
1322 parentStructureId, nameMap, descriptionMap, xsd, serviceContext,
1323 structure);
1324 }
1325
1326
1339 @Override
1340 public DDMStructure updateXSD(
1341 long structureId, String xsd, ServiceContext serviceContext)
1342 throws PortalException, SystemException {
1343
1344 DDMStructure structure = ddmStructurePersistence.findByPrimaryKey(
1345 structureId);
1346
1347 return doUpdateStructure(
1348 structure.getParentStructureId(), structure.getNameMap(),
1349 structure.getDescriptionMap(), xsd, serviceContext, structure);
1350 }
1351
1352
1366 @Override
1367 public void updateXSDFieldMetadata(
1368 long structureId, String fieldName, String metadataEntryName,
1369 String metadataEntryValue, ServiceContext serviceContext)
1370 throws PortalException, SystemException {
1371
1372 DDMStructure ddmStructure = fetchDDMStructure(structureId);
1373
1374 if (ddmStructure == null) {
1375 return;
1376 }
1377
1378 String xsd = ddmStructure.getXsd();
1379
1380 try {
1381 Document document = SAXReaderUtil.read(xsd);
1382
1383 Element rootElement = document.getRootElement();
1384
1385 List<Element> dynamicElementElements = rootElement.elements(
1386 "dynamic-element");
1387
1388 for (Element dynamicElementElement : dynamicElementElements) {
1389 String dynamicElementElementFieldName = GetterUtil.getString(
1390 dynamicElementElement.attributeValue("name"));
1391
1392 if (!dynamicElementElementFieldName.equals(fieldName)) {
1393 continue;
1394 }
1395
1396 List<Element> metadataElements = dynamicElementElement.elements(
1397 "meta-data");
1398
1399 for (Element metadataElement : metadataElements) {
1400 List<Element> metadataEntryElements =
1401 metadataElement.elements();
1402
1403 for (Element metadataEntryElement : metadataEntryElements) {
1404 String metadataEntryElementName = GetterUtil.getString(
1405 metadataEntryElement.attributeValue("name"));
1406
1407 if (metadataEntryElementName.equals(
1408 metadataEntryName)) {
1409
1410 metadataEntryElement.setText(metadataEntryValue);
1411 }
1412 }
1413 }
1414 }
1415
1416 updateXSD(structureId, document.asXML(), serviceContext);
1417 }
1418 catch (DocumentException de) {
1419 throw new SystemException(de);
1420 }
1421 }
1422
1423 protected void appendNewStructureRequiredFields(
1424 DDMStructure structure, Document templateDocument) {
1425
1426 String xsd = structure.getXsd();
1427
1428 Document structureDocument = null;
1429
1430 try {
1431 structureDocument = SAXReaderUtil.read(xsd);
1432 }
1433 catch (DocumentException de) {
1434 if (_log.isWarnEnabled()) {
1435 _log.warn(de, de);
1436 }
1437
1438 return;
1439 }
1440
1441 Element templateElement = templateDocument.getRootElement();
1442
1443 XPath structureXPath = SAXReaderUtil.createXPath(
1444 "
1445 "\"true\"]");
1446
1447 List<Node> nodes = structureXPath.selectNodes(structureDocument);
1448
1449 for (Node node : nodes) {
1450 Element element = (Element)node;
1451
1452 String name = element.attributeValue("name");
1453
1454 name = HtmlUtil.escapeXPathAttribute(name);
1455
1456 XPath templateXPath = SAXReaderUtil.createXPath(
1457 "
1458
1459 if (!templateXPath.booleanValueOf(templateDocument)) {
1460 templateElement.add(element.createCopy());
1461 }
1462 }
1463 }
1464
1465 protected Set<Long> deleteStructures(List<DDMStructure> structures)
1466 throws PortalException, SystemException {
1467
1468 Set<Long> deletedStructureIds = new HashSet<Long>();
1469
1470 for (DDMStructure structure : structures) {
1471 if (deletedStructureIds.contains(structure.getStructureId())) {
1472 continue;
1473 }
1474
1475 if (!GroupThreadLocal.isDeleteInProcess()) {
1476 List<DDMStructure> childDDMStructures =
1477 ddmStructurePersistence.findByParentStructureId(
1478 structure.getStructureId());
1479
1480 deletedStructureIds.addAll(
1481 deleteStructures(childDDMStructures));
1482 }
1483
1484 ddmStructureLocalService.deleteStructure(structure);
1485
1486 deletedStructureIds.add(structure.getStructureId());
1487 }
1488
1489 return deletedStructureIds;
1490 }
1491
1492 protected DDMStructure doUpdateStructure(
1493 long parentStructureId, Map<Locale, String> nameMap,
1494 Map<Locale, String> descriptionMap, String xsd,
1495 ServiceContext serviceContext, DDMStructure structure)
1496 throws PortalException, SystemException {
1497
1498 try {
1499 xsd = DDMXMLUtil.validateXML(xsd);
1500 xsd = DDMXMLUtil.formatXML(xsd);
1501 }
1502 catch (Exception e) {
1503 throw new StructureXsdException();
1504 }
1505
1506 String parentXsd = StringPool.BLANK;
1507
1508 DDMStructure parentStructure =
1509 ddmStructurePersistence.fetchByPrimaryKey(parentStructureId);
1510
1511 if (parentStructure != null) {
1512 parentXsd = parentStructure.getCompleteXsd();
1513 }
1514
1515 validate(nameMap, parentXsd, xsd);
1516
1517 structure.setModifiedDate(serviceContext.getModifiedDate(null));
1518 structure.setParentStructureId(parentStructureId);
1519 structure.setNameMap(nameMap);
1520 structure.setDescriptionMap(descriptionMap);
1521 structure.setXsd(xsd);
1522
1523 ddmStructurePersistence.update(structure);
1524
1525 syncStructureTemplatesFields(structure);
1526
1527 Indexer indexer = IndexerRegistryUtil.getIndexer(
1528 structure.getClassName());
1529
1530 if (indexer != null) {
1531 List<Long> ddmStructureIds = getChildrenStructureIds(
1532 structure.getGroupId(), structure.getStructureId());
1533
1534 indexer.reindexDDMStructures(ddmStructureIds);
1535 }
1536
1537 return structure;
1538 }
1539
1540 protected void getChildrenStructureIds(
1541 List<Long> structureIds, long groupId, long parentStructureId)
1542 throws PortalException, SystemException {
1543
1544 List<DDMStructure> structures = ddmStructurePersistence.findByG_P(
1545 groupId, parentStructureId);
1546
1547 for (DDMStructure structure : structures) {
1548 structureIds.add(structure.getStructureId());
1549
1550 getChildrenStructureIds(
1551 structureIds, structure.getGroupId(),
1552 structure.getStructureId());
1553 }
1554 }
1555
1556 protected List<Long> getChildrenStructureIds(long groupId, long structureId)
1557 throws PortalException, SystemException {
1558
1559 List<Long> structureIds = new ArrayList<Long>();
1560
1561 getChildrenStructureIds(structureIds, groupId, structureId);
1562
1563 structureIds.add(0, structureId);
1564
1565 return structureIds;
1566 }
1567
1568 protected Set<String> getElementNames(Document document)
1569 throws PortalException {
1570
1571 Set<String> elementNames = new HashSet<String>();
1572
1573 XPath xPathSelector = SAXReaderUtil.createXPath("
1574
1575 List<Node> nodes = xPathSelector.selectNodes(document);
1576
1577 for (Node node : nodes) {
1578 Element element = (Element)node;
1579
1580 String name = StringUtil.toLowerCase(
1581 element.attributeValue("name"));
1582
1583 elementNames.add(name);
1584 }
1585
1586 return elementNames;
1587 }
1588
1589 protected String getStructureKey(String structureKey) {
1590 if (structureKey != null) {
1591 structureKey = structureKey.trim();
1592
1593 return StringUtil.toUpperCase(structureKey);
1594 }
1595
1596 return StringPool.BLANK;
1597 }
1598
1599 protected void syncStructureTemplatesFields(DDMStructure structure)
1600 throws PortalException, SystemException {
1601
1602 long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
1603
1604 List<DDMTemplate> templates = ddmTemplateLocalService.getTemplates(
1605 structure.getGroupId(), classNameId, structure.getStructureId(),
1606 DDMTemplateConstants.TEMPLATE_TYPE_FORM);
1607
1608 for (DDMTemplate template : templates) {
1609 String script = template.getScript();
1610
1611 Document templateDocument = null;
1612
1613 try {
1614 templateDocument = SAXReaderUtil.read(script);
1615 }
1616 catch (DocumentException de) {
1617 if (_log.isWarnEnabled()) {
1618 _log.warn(de, de);
1619 }
1620
1621 continue;
1622 }
1623
1624 Element templateRootElement = templateDocument.getRootElement();
1625
1626 syncStructureTemplatesFields(template, templateRootElement);
1627
1628 appendNewStructureRequiredFields(structure, templateDocument);
1629
1630 try {
1631 script = DDMXMLUtil.formatXML(templateDocument.asXML());
1632 }
1633 catch (Exception e) {
1634 throw new StructureXsdException();
1635 }
1636
1637 template.setScript(script);
1638
1639 ddmTemplatePersistence.update(template);
1640 }
1641 }
1642
1643 protected void syncStructureTemplatesFields(
1644 DDMTemplate template, Element templateElement)
1645 throws PortalException, SystemException {
1646
1647 DDMStructure structure = DDMTemplateHelperUtil.fetchStructure(template);
1648
1649 List<Element> dynamicElementElements = templateElement.elements(
1650 "dynamic-element");
1651
1652 for (Element dynamicElementElement : dynamicElementElements) {
1653 String dataType = dynamicElementElement.attributeValue("dataType");
1654 String fieldName = dynamicElementElement.attributeValue("name");
1655
1656 if (Validator.isNull(dataType)) {
1657 continue;
1658 }
1659
1660 if (!structure.hasField(fieldName)) {
1661 templateElement.remove(dynamicElementElement);
1662
1663 continue;
1664 }
1665
1666 String mode = template.getMode();
1667
1668 if (mode.equals(DDMTemplateConstants.TEMPLATE_MODE_CREATE)) {
1669 boolean fieldRequired = structure.getFieldRequired(fieldName);
1670
1671 List<Element> metadataElements = dynamicElementElement.elements(
1672 "meta-data");
1673
1674 for (Element metadataElement : metadataElements) {
1675 for (Element metadataEntryElement :
1676 metadataElement.elements()) {
1677
1678 String attributeName =
1679 metadataEntryElement.attributeValue("name");
1680
1681 if (fieldRequired && attributeName.equals("required")) {
1682 metadataEntryElement.setText("true");
1683 }
1684 }
1685 }
1686 }
1687
1688 syncStructureTemplatesFields(template, dynamicElementElement);
1689 }
1690 }
1691
1692 protected void validate(Document document) throws PortalException {
1693 XPath xPathSelector = SAXReaderUtil.createXPath("
1694
1695 List<Node> nodes = xPathSelector.selectNodes(document);
1696
1697 Set<String> elementNames = new HashSet<String>();
1698
1699 for (Node node : nodes) {
1700 Element element = (Element)node;
1701
1702 String name = StringUtil.toLowerCase(
1703 element.attributeValue("name"));
1704
1705 if (name.startsWith(DDMStructureConstants.XSD_NAME_RESERVED)) {
1706 throw new StructureXsdException();
1707 }
1708
1709 if (elementNames.contains(name)) {
1710 throw new StructureDuplicateElementException();
1711 }
1712
1713 elementNames.add(name);
1714 }
1715 }
1716
1717 protected void validate(Document parentDocument, Document childDocument)
1718 throws PortalException {
1719
1720 Set<String> parentElementNames = getElementNames(parentDocument);
1721
1722 for (String childElementName : getElementNames(childDocument)) {
1723 if (parentElementNames.contains(childElementName)) {
1724 throw new StructureDuplicateElementException();
1725 }
1726 }
1727 }
1728
1729 protected void validate(
1730 long groupId, long parentStructureId, long classNameId,
1731 String structureKey, Map<Locale, String> nameMap, String xsd)
1732 throws PortalException, SystemException {
1733
1734 structureKey = getStructureKey(structureKey);
1735
1736 DDMStructure structure = ddmStructurePersistence.fetchByG_C_S(
1737 groupId, classNameId, structureKey);
1738
1739 if (structure != null) {
1740 StructureDuplicateStructureKeyException sdske =
1741 new StructureDuplicateStructureKeyException();
1742
1743 sdske.setStructureKey(structure.getStructureKey());
1744
1745 throw sdske;
1746 }
1747
1748 String parentXsd = StringPool.BLANK;
1749
1750 DDMStructure parentStructure =
1751 ddmStructurePersistence.fetchByPrimaryKey(parentStructureId);
1752
1753 if (parentStructure != null) {
1754 parentXsd = parentStructure.getCompleteXsd();
1755 }
1756
1757 validate(nameMap, parentXsd, xsd);
1758 }
1759
1760 protected void validate(
1761 Map<Locale, String> nameMap, Locale contentDefaultLocale)
1762 throws PortalException {
1763
1764 String name = nameMap.get(contentDefaultLocale);
1765
1766 if (Validator.isNull(name)) {
1767 throw new StructureNameException();
1768 }
1769
1770 Locale[] availableLocales = LanguageUtil.getAvailableLocales();
1771
1772 if (!ArrayUtil.contains(availableLocales, contentDefaultLocale)) {
1773 Long companyId = CompanyThreadLocal.getCompanyId();
1774
1775 LocaleException le = new LocaleException(
1776 LocaleException.TYPE_CONTENT,
1777 "The locale " + contentDefaultLocale +
1778 " is not available in company " + companyId);
1779
1780 le.setSourceAvailableLocales(new Locale[] {contentDefaultLocale});
1781 le.setTargetAvailableLocales(availableLocales);
1782
1783 throw le;
1784 }
1785 }
1786
1787 protected void validate(
1788 Map<Locale, String> nameMap, String parentXsd, String childXsd)
1789 throws PortalException {
1790
1791 try {
1792 Document document = SAXReaderUtil.read(childXsd);
1793
1794 Element rootElement = document.getRootElement();
1795
1796 Locale contentDefaultLocale = LocaleUtil.fromLanguageId(
1797 rootElement.attributeValue("default-locale"));
1798
1799 validate(nameMap, contentDefaultLocale);
1800
1801 validate(document);
1802
1803 if (Validator.isNotNull(parentXsd)) {
1804 Document parentDocument = SAXReaderUtil.read(parentXsd);
1805
1806 validate(parentDocument, document);
1807 }
1808 }
1809 catch (LocaleException le) {
1810 throw le;
1811 }
1812 catch (StructureDuplicateElementException sdee) {
1813 throw sdee;
1814 }
1815 catch (StructureNameException sne) {
1816 throw sne;
1817 }
1818 catch (StructureXsdException sxe) {
1819 throw sxe;
1820 }
1821 catch (Exception e) {
1822 throw new StructureXsdException();
1823 }
1824 }
1825
1826 private static Log _log = LogFactoryUtil.getLog(
1827 DDMStructureLocalServiceImpl.class);
1828
1829 }