001
014
015 package com.liferay.portlet.messageboards.lar;
016
017 import com.liferay.portal.kernel.lar.BasePortletDataHandler;
018 import com.liferay.portal.kernel.lar.PortletDataContext;
019 import com.liferay.portal.kernel.lar.PortletDataHandlerBoolean;
020 import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
021 import com.liferay.portal.kernel.log.Log;
022 import com.liferay.portal.kernel.log.LogFactoryUtil;
023 import com.liferay.portal.kernel.util.CharPool;
024 import com.liferay.portal.kernel.util.GetterUtil;
025 import com.liferay.portal.kernel.util.MapUtil;
026 import com.liferay.portal.kernel.util.ObjectValuePair;
027 import com.liferay.portal.kernel.util.StreamUtil;
028 import com.liferay.portal.kernel.util.StringBundler;
029 import com.liferay.portal.kernel.util.StringPool;
030 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
031 import com.liferay.portal.kernel.workflow.WorkflowConstants;
032 import com.liferay.portal.kernel.xml.Document;
033 import com.liferay.portal.kernel.xml.Element;
034 import com.liferay.portal.kernel.xml.SAXReaderUtil;
035 import com.liferay.portal.model.CompanyConstants;
036 import com.liferay.portal.model.User;
037 import com.liferay.portal.service.ServiceContext;
038 import com.liferay.portal.service.persistence.UserUtil;
039 import com.liferay.portal.util.PortletKeys;
040 import com.liferay.portal.util.PropsValues;
041 import com.liferay.portlet.documentlibrary.store.DLStoreUtil;
042 import com.liferay.portlet.messageboards.model.MBBan;
043 import com.liferay.portlet.messageboards.model.MBCategory;
044 import com.liferay.portlet.messageboards.model.MBCategoryConstants;
045 import com.liferay.portlet.messageboards.model.MBMessage;
046 import com.liferay.portlet.messageboards.model.MBThread;
047 import com.liferay.portlet.messageboards.model.MBThreadFlag;
048 import com.liferay.portlet.messageboards.service.MBBanLocalServiceUtil;
049 import com.liferay.portlet.messageboards.service.MBCategoryLocalServiceUtil;
050 import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
051 import com.liferay.portlet.messageboards.service.MBStatsUserLocalServiceUtil;
052 import com.liferay.portlet.messageboards.service.MBThreadFlagLocalServiceUtil;
053 import com.liferay.portlet.messageboards.service.MBThreadLocalServiceUtil;
054 import com.liferay.portlet.messageboards.service.persistence.MBBanUtil;
055 import com.liferay.portlet.messageboards.service.persistence.MBCategoryUtil;
056 import com.liferay.portlet.messageboards.service.persistence.MBMessageUtil;
057 import com.liferay.portlet.messageboards.service.persistence.MBThreadFlagUtil;
058 import com.liferay.portlet.messageboards.service.persistence.MBThreadUtil;
059
060 import java.io.InputStream;
061
062 import java.util.ArrayList;
063 import java.util.Collections;
064 import java.util.Iterator;
065 import java.util.List;
066 import java.util.Map;
067
068 import javax.portlet.PortletPreferences;
069
070
074 public class MBPortletDataHandlerImpl extends BasePortletDataHandler {
075
076 @Override
077 public PortletDataHandlerControl[] getExportControls() {
078 return new PortletDataHandlerControl[] {
079 _categoriesAndMessages, _threadFlags, _userBans
080 };
081 }
082
083 @Override
084 public PortletDataHandlerControl[] getExportMetadataControls() {
085 return new PortletDataHandlerControl[] {
086 new PortletDataHandlerBoolean(
087 _NAMESPACE, "message-board-messages", true, _metadataControls)
088 };
089 }
090
091 @Override
092 public PortletDataHandlerControl[] getImportControls() {
093 return new PortletDataHandlerControl[] {
094 _categoriesAndMessages, _threadFlags, _userBans
095 };
096 }
097
098 @Override
099 public PortletDataHandlerControl[] getImportMetadataControls() {
100 return new PortletDataHandlerControl[] {
101 new PortletDataHandlerBoolean(
102 _NAMESPACE, "message-board-messages", true, _metadataControls)
103 };
104 }
105
106 @Override
107 public boolean isAlwaysExportable() {
108 return _ALWAYS_EXPORTABLE;
109 }
110
111 @Override
112 public boolean isPublishToLiveByDefault() {
113 return PropsValues.MESSAGE_BOARDS_PUBLISH_TO_LIVE_BY_DEFAULT;
114 }
115
116 @Override
117 protected PortletPreferences doDeleteData(
118 PortletDataContext portletDataContext, String portletId,
119 PortletPreferences portletPreferences)
120 throws Exception {
121
122 if (!portletDataContext.addPrimaryKey(
123 MBPortletDataHandlerImpl.class, "deleteData")) {
124
125 MBBanLocalServiceUtil.deleteBansByGroupId(
126 portletDataContext.getScopeGroupId());
127
128 MBCategoryLocalServiceUtil.deleteCategories(
129 portletDataContext.getScopeGroupId());
130
131 MBStatsUserLocalServiceUtil.deleteStatsUsersByGroupId(
132 portletDataContext.getScopeGroupId());
133
134 MBThreadLocalServiceUtil.deleteThreads(
135 portletDataContext.getScopeGroupId(),
136 MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID);
137 }
138
139 return null;
140 }
141
142 @Override
143 protected String doExportData(
144 PortletDataContext portletDataContext, String portletId,
145 PortletPreferences portletPreferences)
146 throws Exception {
147
148 portletDataContext.addPermissions(
149 "com.liferay.portlet.messageboards",
150 portletDataContext.getScopeGroupId());
151
152 Document document = SAXReaderUtil.createDocument();
153
154 Element rootElement = document.addElement("message-boards-data");
155
156 rootElement.addAttribute(
157 "group-id", String.valueOf(portletDataContext.getScopeGroupId()));
158
159 Element categoriesElement = rootElement.addElement("categories");
160 Element messagesElement = rootElement.addElement("messages");
161 Element threadFlagsElement = rootElement.addElement("thread-flags");
162 Element userBansElement = rootElement.addElement("user-bans");
163
164 List<MBCategory> categories = MBCategoryUtil.findByGroupId(
165 portletDataContext.getScopeGroupId());
166
167 for (MBCategory category : categories) {
168 exportCategory(
169 portletDataContext, categoriesElement, messagesElement,
170 threadFlagsElement, category);
171 }
172
173 List<MBMessage> messages = MBMessageUtil.findByG_C(
174 portletDataContext.getScopeGroupId(),
175 MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID);
176
177 for (MBMessage message : messages) {
178 exportMessage(
179 portletDataContext, categoriesElement, messagesElement,
180 threadFlagsElement, message);
181 }
182
183 if (portletDataContext.getBooleanParameter(_NAMESPACE, "user-bans")) {
184 List<MBBan> bans = MBBanUtil.findByGroupId(
185 portletDataContext.getScopeGroupId());
186
187 for (MBBan ban : bans) {
188 exportBan(portletDataContext, userBansElement, ban);
189 }
190 }
191
192 return document.formattedString();
193 }
194
195 @Override
196 protected PortletPreferences doImportData(
197 PortletDataContext portletDataContext, String portletId,
198 PortletPreferences portletPreferences, String data)
199 throws Exception {
200
201 portletDataContext.importPermissions(
202 "com.liferay.portlet.messageboards",
203 portletDataContext.getSourceGroupId(),
204 portletDataContext.getScopeGroupId());
205
206 Document document = SAXReaderUtil.read(data);
207
208 Element rootElement = document.getRootElement();
209
210 Element categoriesElement = rootElement.element("categories");
211
212 for (Element categoryElement : categoriesElement.elements("category")) {
213 String path = categoryElement.attributeValue("path");
214
215 if (!portletDataContext.isPathNotProcessed(path)) {
216 continue;
217 }
218
219 MBCategory category =
220 (MBCategory)portletDataContext.getZipEntryAsObject(path);
221
222 importCategory(portletDataContext, path, category);
223 }
224
225 Element messagesElement = rootElement.element("messages");
226
227 for (Element messageElement : messagesElement.elements("message")) {
228 String path = messageElement.attributeValue("path");
229
230 if (!portletDataContext.isPathNotProcessed(path)) {
231 continue;
232 }
233
234 MBMessage message =
235 (MBMessage)portletDataContext.getZipEntryAsObject(path);
236
237 importMessage(portletDataContext, messageElement, message);
238 }
239
240 if (portletDataContext.getBooleanParameter(
241 _NAMESPACE, "thread-flags")) {
242
243 Element threadFlagsElement = rootElement.element("thread-flags");
244
245 for (Element threadFlagElement :
246 threadFlagsElement.elements("thread-flag")) {
247
248 String path = threadFlagElement.attributeValue("path");
249
250 if (!portletDataContext.isPathNotProcessed(path)) {
251 continue;
252 }
253
254 MBThreadFlag threadFlag =
255 (MBThreadFlag)portletDataContext.getZipEntryAsObject(path);
256
257 importThreadFlag(
258 portletDataContext, threadFlagElement, threadFlag);
259 }
260 }
261
262 if (portletDataContext.getBooleanParameter(_NAMESPACE, "user-bans")) {
263 Element userBansElement = rootElement.element("user-bans");
264
265 for (Element userBanElement :
266 userBansElement.elements("user-ban")) {
267
268 String path = userBanElement.attributeValue("path");
269
270 if (!portletDataContext.isPathNotProcessed(path)) {
271 continue;
272 }
273
274 MBBan ban = (MBBan)portletDataContext.getZipEntryAsObject(path);
275
276 importBan(portletDataContext, userBanElement, ban);
277 }
278 }
279
280 return null;
281 }
282
283 protected void exportBan(
284 PortletDataContext portletDataContext, Element userBansElement,
285 MBBan ban)
286 throws Exception {
287
288 if (!portletDataContext.isWithinDateRange(ban.getModifiedDate())) {
289 return;
290 }
291
292 String path = getUserBanPath(portletDataContext, ban);
293
294 if (!portletDataContext.isPathNotProcessed(path)) {
295 return;
296 }
297
298 Element userBanElement = userBansElement.addElement("user-ban");
299
300 ban.setBanUserUuid(ban.getBanUserUuid());
301
302 portletDataContext.addClassedModel(
303 userBanElement, path, ban, _NAMESPACE);
304 }
305
306 protected void exportCategory(
307 PortletDataContext portletDataContext, Element categoriesElement,
308 Element messagesElement, Element threadFlagsElement,
309 MBCategory category)
310 throws Exception {
311
312 if (portletDataContext.isWithinDateRange(category.getModifiedDate())) {
313 exportParentCategory(
314 portletDataContext, categoriesElement,
315 category.getParentCategoryId());
316
317 String path = getCategoryPath(portletDataContext, category);
318
319 if (portletDataContext.isPathNotProcessed(path)) {
320 Element categoryElement = categoriesElement.addElement(
321 "category");
322
323 portletDataContext.addClassedModel(
324 categoryElement, path, category, _NAMESPACE);
325 }
326 }
327
328 List<MBMessage> messages = MBMessageUtil.findByG_C(
329 category.getGroupId(), category.getCategoryId());
330
331 for (MBMessage message : messages) {
332 exportMessage(
333 portletDataContext, categoriesElement, messagesElement,
334 threadFlagsElement, message);
335 }
336 }
337
338 protected void exportMessage(
339 PortletDataContext portletDataContext, Element categoriesElement,
340 Element messagesElement, Element threadFlagsElement,
341 MBMessage message)
342 throws Exception {
343
344 if (!portletDataContext.isWithinDateRange(message.getModifiedDate())) {
345 return;
346 }
347
348 if (message.getStatus() != WorkflowConstants.STATUS_APPROVED) {
349 return;
350 }
351
352 exportParentCategory(
353 portletDataContext, categoriesElement, message.getCategoryId());
354
355 String path = getMessagePath(portletDataContext, message);
356
357 if (!portletDataContext.isPathNotProcessed(path)) {
358 return;
359 }
360
361 Element messageElement = messagesElement.addElement("message");
362
363 message.setPriority(message.getPriority());
364
365 MBThread thread = message.getThread();
366
367 messageElement.addAttribute(
368 "question", String.valueOf(thread.isQuestion()));
369
370 if (portletDataContext.getBooleanParameter(_NAMESPACE, "attachments") &&
371 message.isAttachments()) {
372
373 for (String attachment : message.getAttachmentsFiles()) {
374 int pos = attachment.lastIndexOf(CharPool.FORWARD_SLASH);
375
376 String name = attachment.substring(pos + 1);
377 String binPath = getMessageAttachementBinPath(
378 portletDataContext, message, name);
379
380 Element attachmentElement = messageElement.addElement(
381 "attachment");
382
383 attachmentElement.addAttribute("name", name);
384 attachmentElement.addAttribute("bin-path", binPath);
385
386 byte[] bytes = DLStoreUtil.getFileAsBytes(
387 portletDataContext.getCompanyId(), CompanyConstants.SYSTEM,
388 attachment);
389
390 portletDataContext.addZipEntry(binPath, bytes);
391 }
392
393 message.setAttachmentsDir(message.getAttachmentsDir());
394 }
395
396 if (portletDataContext.getBooleanParameter(
397 _NAMESPACE, "thread-flags")) {
398
399 List<MBThreadFlag> threadFlags = MBThreadFlagUtil.findByThreadId(
400 message.getThreadId());
401
402 for (MBThreadFlag threadFlag : threadFlags) {
403 exportThreadFlag(
404 portletDataContext, threadFlagsElement, threadFlag);
405 }
406 }
407
408 portletDataContext.addClassedModel(
409 messageElement, path, message, _NAMESPACE);
410 }
411
412 protected void exportParentCategory(
413 PortletDataContext portletDataContext, Element categoriesElement,
414 long categoryId)
415 throws Exception {
416
417 if (!portletDataContext.hasDateRange() ||
418 (categoryId == MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID) ||
419 (categoryId == MBCategoryConstants.DISCUSSION_CATEGORY_ID)) {
420
421 return;
422 }
423
424 MBCategory category = MBCategoryUtil.findByPrimaryKey(categoryId);
425
426 exportParentCategory(
427 portletDataContext, categoriesElement,
428 category.getParentCategoryId());
429
430 String path = getCategoryPath(portletDataContext, category);
431
432 if (portletDataContext.isPathNotProcessed(path)) {
433 Element categoryElement = categoriesElement.addElement("category");
434
435 portletDataContext.addClassedModel(
436 categoryElement, path, category, _NAMESPACE);
437 }
438 }
439
440 protected void exportThreadFlag(
441 PortletDataContext portletDataContext, Element threadFlagsElement,
442 MBThreadFlag threadFlag)
443 throws Exception {
444
445 String path = getThreadFlagPath(portletDataContext, threadFlag);
446
447 if (!portletDataContext.isPathNotProcessed(path)) {
448 return;
449 }
450
451 Element threadFlagElement = threadFlagsElement.addElement(
452 "thread-flag");
453
454 MBThread thread = MBThreadLocalServiceUtil.getThread(
455 threadFlag.getThreadId());
456
457 MBMessage rootMessage = MBMessageLocalServiceUtil.getMessage(
458 thread.getRootMessageId());
459
460 threadFlagElement.addAttribute(
461 "root-message-uuid", rootMessage.getUuid());
462
463 portletDataContext.addClassedModel(
464 threadFlagElement, path, threadFlag, _NAMESPACE);
465 }
466
467 protected List<ObjectValuePair<String, InputStream>> getAttachments(
468 PortletDataContext portletDataContext, Element messageElement,
469 MBMessage message) {
470
471 if (!message.isAttachments() &&
472 portletDataContext.getBooleanParameter(_NAMESPACE, "attachments")) {
473
474 return Collections.emptyList();
475 }
476
477 List<ObjectValuePair<String, InputStream>> inputStreamOVPs =
478 new ArrayList<ObjectValuePair<String, InputStream>>();
479
480 List<Element> attachmentElements = messageElement.elements(
481 "attachment");
482
483 for (Element attachmentElement : attachmentElements) {
484 String name = attachmentElement.attributeValue("name");
485 String binPath = attachmentElement.attributeValue("bin-path");
486
487 InputStream inputStream =
488 portletDataContext.getZipEntryAsInputStream(binPath);
489
490 if (inputStream == null) {
491 continue;
492 }
493
494 ObjectValuePair<String, InputStream> inputStreamOVP =
495 new ObjectValuePair<String, InputStream>(name, inputStream);
496
497 inputStreamOVPs.add(inputStreamOVP);
498 }
499
500 if (inputStreamOVPs.isEmpty()) {
501 _log.error(
502 "Could not find attachments for message " +
503 message.getMessageId());
504 }
505
506 return inputStreamOVPs;
507 }
508
509 protected long getCategoryId(
510 PortletDataContext portletDataContext, MBMessage message,
511 Map<Long, Long> categoryPKs, long categoryId)
512 throws Exception {
513
514 if ((categoryId != MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID) &&
515 (categoryId != MBCategoryConstants.DISCUSSION_CATEGORY_ID) &&
516 (categoryId == message.getCategoryId())) {
517
518 String path = getImportCategoryPath(portletDataContext, categoryId);
519
520 MBCategory category =
521 (MBCategory)portletDataContext.getZipEntryAsObject(path);
522
523 importCategory(portletDataContext, path, category);
524
525 categoryId = MapUtil.getLong(
526 categoryPKs, message.getCategoryId(), message.getCategoryId());
527 }
528
529 return categoryId;
530 }
531
532 protected String getCategoryPath(
533 PortletDataContext portletDataContext, MBCategory category) {
534
535 StringBundler sb = new StringBundler(4);
536
537 sb.append(
538 portletDataContext.getPortletPath(PortletKeys.MESSAGE_BOARDS));
539 sb.append("/categories/");
540 sb.append(category.getCategoryId());
541 sb.append(".xml");
542
543 return sb.toString();
544 }
545
546 protected String getImportCategoryPath(
547 PortletDataContext portletDataContext, long categoryId) {
548
549 StringBundler sb = new StringBundler(4);
550
551 sb.append(
552 portletDataContext.getSourcePortletPath(
553 PortletKeys.MESSAGE_BOARDS));
554 sb.append("/categories/");
555 sb.append(categoryId);
556 sb.append(".xml");
557
558 return sb.toString();
559 }
560
561 protected String getMessageAttachementBinPath(
562 PortletDataContext portletDataContext, MBMessage message,
563 String attachment) {
564
565 StringBundler sb = new StringBundler(5);
566
567 sb.append(
568 portletDataContext.getPortletPath(PortletKeys.MESSAGE_BOARDS));
569 sb.append("/bin/");
570 sb.append(message.getMessageId());
571 sb.append(StringPool.SLASH);
572 sb.append(PortalUUIDUtil.generate());
573
574 return sb.toString();
575 }
576
577 protected String getMessagePath(
578 PortletDataContext portletDataContext, MBMessage message) {
579
580 StringBundler sb = new StringBundler(4);
581
582 sb.append(
583 portletDataContext.getPortletPath(PortletKeys.MESSAGE_BOARDS));
584 sb.append("/messages/");
585 sb.append(message.getMessageId());
586 sb.append(".xml");
587
588 return sb.toString();
589 }
590
591 protected String getThreadFlagPath(
592 PortletDataContext portletDataContext, MBThreadFlag threadFlag) {
593
594 StringBundler sb = new StringBundler(4);
595
596 sb.append(
597 portletDataContext.getPortletPath(PortletKeys.MESSAGE_BOARDS));
598 sb.append("/thread-flags/");
599 sb.append(threadFlag.getThreadFlagId());
600 sb.append(".xml");
601
602 return sb.toString();
603 }
604
605 protected String getUserBanPath(
606 PortletDataContext portletDataContext, MBBan ban) {
607
608 StringBundler sb = new StringBundler(4);
609
610 sb.append(
611 portletDataContext.getPortletPath(PortletKeys.MESSAGE_BOARDS));
612 sb.append("/user-bans/");
613 sb.append(ban.getBanId());
614 sb.append(".xml");
615
616 return sb.toString();
617 }
618
619 protected void importBan(
620 PortletDataContext portletDataContext, Element userBanElement,
621 MBBan ban)
622 throws Exception {
623
624 long userId = portletDataContext.getUserId(ban.getUserUuid());
625
626 ServiceContext serviceContext = portletDataContext.createServiceContext(
627 userBanElement, ban, _NAMESPACE);
628
629 List<User> users = UserUtil.findByUuid_C(
630 ban.getBanUserUuid(), portletDataContext.getCompanyId());
631
632 Iterator<User> itr = users.iterator();
633
634 if (itr.hasNext()) {
635 User user = itr.next();
636
637 MBBanLocalServiceUtil.addBan(
638 userId, user.getUserId(), serviceContext);
639 }
640 else {
641 _log.error(
642 "Could not find banned user with uuid " + ban.getBanUserUuid());
643 }
644 }
645
646 protected void importCategory(
647 PortletDataContext portletDataContext, String categoryPath,
648 MBCategory category)
649 throws Exception {
650
651 long userId = portletDataContext.getUserId(category.getUserUuid());
652
653 Map<Long, Long> categoryIds =
654 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
655 MBCategory.class);
656
657 long parentCategoryId = MapUtil.getLong(
658 categoryIds, category.getParentCategoryId(),
659 category.getParentCategoryId());
660
661 String emailAddress = null;
662 String inProtocol = null;
663 String inServerName = null;
664 int inServerPort = 0;
665 boolean inUseSSL = false;
666 String inUserName = null;
667 String inPassword = null;
668 int inReadInterval = 0;
669 String outEmailAddress = null;
670 boolean outCustom = false;
671 String outServerName = null;
672 int outServerPort = 0;
673 boolean outUseSSL = false;
674 String outUserName = null;
675 String outPassword = null;
676 boolean allowAnonymous = false;
677 boolean mailingListActive = false;
678
679 ServiceContext serviceContext = portletDataContext.createServiceContext(
680 categoryPath, category, _NAMESPACE);
681
682 if ((parentCategoryId !=
683 MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID) &&
684 (parentCategoryId != MBCategoryConstants.DISCUSSION_CATEGORY_ID) &&
685 (parentCategoryId == category.getParentCategoryId())) {
686
687 String path = getImportCategoryPath(
688 portletDataContext, parentCategoryId);
689
690 MBCategory parentCategory =
691 (MBCategory)portletDataContext.getZipEntryAsObject(path);
692
693 importCategory(portletDataContext, path, parentCategory);
694
695 parentCategoryId = MapUtil.getLong(
696 categoryIds, category.getParentCategoryId(),
697 category.getParentCategoryId());
698 }
699
700 MBCategory importedCategory = null;
701
702 if (portletDataContext.isDataStrategyMirror()) {
703 MBCategory existingCategory = MBCategoryUtil.fetchByUUID_G(
704 category.getUuid(), portletDataContext.getScopeGroupId());
705
706 if (existingCategory == null) {
707 serviceContext.setUuid(category.getUuid());
708
709 importedCategory = MBCategoryLocalServiceUtil.addCategory(
710 userId, parentCategoryId, category.getName(),
711 category.getDescription(), category.getDisplayStyle(),
712 emailAddress, inProtocol, inServerName, inServerPort,
713 inUseSSL, inUserName, inPassword, inReadInterval,
714 outEmailAddress, outCustom, outServerName, outServerPort,
715 outUseSSL, outUserName, outPassword, allowAnonymous,
716 mailingListActive, serviceContext);
717 }
718 else {
719 importedCategory = MBCategoryLocalServiceUtil.updateCategory(
720 existingCategory.getCategoryId(), parentCategoryId,
721 category.getName(), category.getDescription(),
722 category.getDisplayStyle(), emailAddress, inProtocol,
723 inServerName, inServerPort, inUseSSL, inUserName,
724 inPassword, inReadInterval, outEmailAddress, outCustom,
725 outServerName, outServerPort, outUseSSL, outUserName,
726 outPassword, allowAnonymous, mailingListActive, false,
727 serviceContext);
728 }
729 }
730 else {
731 importedCategory = MBCategoryLocalServiceUtil.addCategory(
732 userId, parentCategoryId, category.getName(),
733 category.getDescription(), category.getDisplayStyle(),
734 emailAddress, inProtocol, inServerName, inServerPort, inUseSSL,
735 inUserName, inPassword, inReadInterval, outEmailAddress,
736 outCustom, outServerName, outServerPort, outUseSSL, outUserName,
737 outPassword, allowAnonymous, mailingListActive, serviceContext);
738 }
739
740 portletDataContext.importClassedModel(
741 category, importedCategory, _NAMESPACE);
742 }
743
744 protected void importMessage(
745 PortletDataContext portletDataContext, Element messageElement,
746 MBMessage message)
747 throws Exception {
748
749 long userId = portletDataContext.getUserId(message.getUserUuid());
750 String userName = message.getUserName();
751
752 Map<Long, Long> categoryIds =
753 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
754 MBCategory.class);
755
756 long categoryId = MapUtil.getLong(
757 categoryIds, message.getCategoryId(), message.getCategoryId());
758
759 Map<Long, Long> threadIds =
760 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
761 MBThread.class);
762
763 long threadId = MapUtil.getLong(threadIds, message.getThreadId(), 0);
764
765 Map<Long, Long> messageIds =
766 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
767 MBMessage.class);
768
769 long parentMessageId = MapUtil.getLong(
770 messageIds, message.getParentMessageId(),
771 message.getParentMessageId());
772
773 List<String> existingFiles = new ArrayList<String>();
774
775 List<ObjectValuePair<String, InputStream>> inputStreamOVPs =
776 getAttachments(portletDataContext, messageElement, message);
777
778 try {
779 ServiceContext serviceContext =
780 portletDataContext.createServiceContext(
781 messageElement, message, _NAMESPACE);
782
783 if (message.getStatus() != WorkflowConstants.STATUS_APPROVED) {
784 serviceContext.setWorkflowAction(
785 WorkflowConstants.ACTION_SAVE_DRAFT);
786 }
787
788 categoryId = getCategoryId(
789 portletDataContext, message, categoryIds, categoryId);
790
791 MBMessage importedMessage = null;
792
793 if (portletDataContext.isDataStrategyMirror()) {
794 MBMessage existingMessage = MBMessageUtil.fetchByUUID_G(
795 message.getUuid(), portletDataContext.getScopeGroupId());
796
797 if (existingMessage == null) {
798 serviceContext.setUuid(message.getUuid());
799
800 importedMessage = MBMessageLocalServiceUtil.addMessage(
801 userId, userName, portletDataContext.getScopeGroupId(),
802 categoryId, threadId, parentMessageId,
803 message.getSubject(), message.getBody(),
804 message.getFormat(), inputStreamOVPs,
805 message.getAnonymous(), message.getPriority(),
806 message.getAllowPingbacks(), serviceContext);
807 }
808 else {
809 importedMessage = MBMessageLocalServiceUtil.updateMessage(
810 userId, existingMessage.getMessageId(),
811 message.getSubject(), message.getBody(),
812 inputStreamOVPs, existingFiles, message.getPriority(),
813 message.getAllowPingbacks(), serviceContext);
814 }
815 }
816 else {
817 importedMessage = MBMessageLocalServiceUtil.addMessage(
818 userId, userName, portletDataContext.getScopeGroupId(),
819 categoryId, threadId, parentMessageId, message.getSubject(),
820 message.getBody(), message.getFormat(), inputStreamOVPs,
821 message.getAnonymous(), message.getPriority(),
822 message.getAllowPingbacks(), serviceContext);
823 }
824
825 importedMessage.setAnswer(message.getAnswer());
826
827 if (importedMessage.isRoot()) {
828 MBThreadLocalServiceUtil.updateQuestion(
829 importedMessage.getThreadId(),
830 GetterUtil.getBoolean(
831 messageElement.attributeValue("question")));
832 }
833
834 threadIds.put(message.getThreadId(), importedMessage.getThreadId());
835
836 portletDataContext.importClassedModel(
837 message, importedMessage, _NAMESPACE);
838 }
839 finally {
840 for (ObjectValuePair<String, InputStream> inputStreamOVP :
841 inputStreamOVPs) {
842
843 InputStream inputStream = inputStreamOVP.getValue();
844
845 StreamUtil.cleanUp(inputStream);
846 }
847 }
848 }
849
850 protected void importThreadFlag(
851 PortletDataContext portletDataContext, Element threadFlagElement,
852 MBThreadFlag threadFlag)
853 throws Exception {
854
855 long userId = portletDataContext.getUserId(threadFlag.getUserUuid());
856
857 Map<Long, Long> messageIds =
858 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
859 MBMessage.class);
860
861 long threadId = MapUtil.getLong(
862 messageIds, threadFlag.getThreadId(), threadFlag.getThreadId());
863
864 MBThread thread = MBThreadUtil.fetchByPrimaryKey(threadId);
865
866 if (thread == null) {
867 String rootMessageUuid = threadFlagElement.attributeValue(
868 "root-message-uuid");
869
870 MBMessage rootMessage = MBMessageUtil.fetchByUUID_G(
871 rootMessageUuid, portletDataContext.getScopeGroupId());
872
873 if (rootMessage != null) {
874 thread = rootMessage.getThread();
875 }
876 }
877
878 if (thread == null) {
879 return;
880 }
881
882 MBThreadFlagLocalServiceUtil.addThreadFlag(userId, thread);
883 }
884
885 private static final boolean _ALWAYS_EXPORTABLE = true;
886
887 private static final String _NAMESPACE = "message_board";
888
889 private static Log _log = LogFactoryUtil.getLog(
890 MBPortletDataHandlerImpl.class);
891
892 private static PortletDataHandlerBoolean _categoriesAndMessages =
893 new PortletDataHandlerBoolean(
894 _NAMESPACE, "categories-and-messages", true, true);
895
896 private static PortletDataHandlerControl[] _metadataControls =
897 new PortletDataHandlerControl[] {
898 new PortletDataHandlerBoolean(_NAMESPACE, "attachments"),
899 new PortletDataHandlerBoolean(_NAMESPACE, "ratings"),
900 new PortletDataHandlerBoolean(_NAMESPACE, "tags")
901 };
902
903 private static PortletDataHandlerBoolean _threadFlags =
904 new PortletDataHandlerBoolean(_NAMESPACE, "thread-flags");
905
906 private static PortletDataHandlerBoolean _userBans =
907 new PortletDataHandlerBoolean(_NAMESPACE, "user-bans");
908
909 }