protected void doExportStagedModel(
PortletDataContext portletDataContext, CalendarResource calendarResource) throws Exception {
Element calendarResourceElement = portletDataContext.getExportDataElement(calendarResource);
for (Calendar calendar : calendarResource.getCalendars()) {
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext, calendarResource, calendar, PortletDataContext.REFERENCE_TYPE_STRONG);
}
if (calendarResource.getClassNameId() == PortalUtil.getClassNameId(User.class)) {
User user = UserLocalServiceUtil.getUser(calendarResource.getClassPK());
portletDataContext.addReferenceElement(
calendarResource,
calendarResourceElement,
user,
User.class,
PortletDataContext.REFERENCE_TYPE_DEPENDENCY_DISPOSABLE,
true);
}
portletDataContext.addClassedModel(
calendarResourceElement,
ExportImportPathUtil.getModelPath(calendarResource),
calendarResource);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, DDLRecord record)
throws Exception {
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext,
record,
record.getRecordSet(),
PortletDataContext.REFERENCE_TYPE_STRONG);
DDLRecordVersion recordVersion = record.getRecordVersion();
Fields fields = StorageEngineUtil.getFields(recordVersion.getDDMStorageId());
String fieldsPath = ExportImportPathUtil.getModelPath(record, "fields.xml");
portletDataContext.addZipEntry(fieldsPath, fields);
Element recordElement = portletDataContext.getExportDataElement(record);
recordElement.addAttribute("fields-path", fieldsPath);
portletDataContext.addClassedModel(
recordElement, ExportImportPathUtil.getModelPath(record), record);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, MBMessage message)
throws Exception {
if ((message.getStatus() != WorkflowConstants.STATUS_APPROVED)
|| (message.getCategoryId() == MBCategoryConstants.DISCUSSION_CATEGORY_ID)) {
return;
}
StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, message.getCategory());
Element messageElement = portletDataContext.getExportDataStagedModelElement(message);
message.setPriority(message.getPriority());
MBThread thread = message.getThread();
messageElement.addAttribute("question", String.valueOf(thread.isQuestion()));
boolean hasAttachmentsFileEntries = message.getAttachmentsFileEntriesCount() > 0;
messageElement.addAttribute(
"hasAttachmentsFileEntries", String.valueOf(hasAttachmentsFileEntries));
if (portletDataContext.getBooleanParameter(MBPortletDataHandler.NAMESPACE, "attachments")
&& hasAttachmentsFileEntries) {
for (FileEntry fileEntry : message.getAttachmentsFileEntries()) {
String name = fileEntry.getTitle();
String binPath = ExportImportPathUtil.getModelPath(message, name);
Element attachmentElement = messageElement.addElement("attachment");
attachmentElement.addAttribute("name", name);
attachmentElement.addAttribute("bin-path", binPath);
portletDataContext.addZipEntry(binPath, fileEntry.getContentStream());
}
long folderId = message.getAttachmentsFolderId();
if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
message.setAttachmentsFolderId(folderId);
}
}
portletDataContext.addClassedModel(
messageElement,
ExportImportPathUtil.getModelPath(message),
message,
MBPortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, MBThreadFlag threadFlag)
throws Exception {
MBThread thread = MBThreadLocalServiceUtil.getThread(threadFlag.getThreadId());
MBMessage rootMessage = MBMessageLocalServiceUtil.getMessage(thread.getRootMessageId());
if ((rootMessage.getStatus() != WorkflowConstants.STATUS_APPROVED)
|| (rootMessage.getCategoryId() == MBCategoryConstants.DISCUSSION_CATEGORY_ID)) {
return;
}
StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, rootMessage);
Element threadFlagElement = portletDataContext.getExportDataElement(threadFlag);
threadFlagElement.addAttribute("root-message-id", String.valueOf(rootMessage.getMessageId()));
portletDataContext.addClassedModel(
threadFlagElement,
ExportImportPathUtil.getModelPath(threadFlag),
threadFlag,
MBPortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, DDLRecordSet recordSet)
throws Exception {
DDMStructure ddmStructure = recordSet.getDDMStructure();
StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, ddmStructure);
List<DDMTemplate> ddmTemplates = ddmStructure.getTemplates();
Element recordSetElement = portletDataContext.getExportDataElement(recordSet);
for (DDMTemplate ddmTemplate : ddmTemplates) {
StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, ddmTemplate);
portletDataContext.addReferenceElement(
recordSet,
recordSetElement,
ddmTemplate,
PortletDataContext.REFERENCE_TYPE_STRONG,
false);
}
portletDataContext.addClassedModel(
recordSetElement,
ExportImportPathUtil.getModelPath(recordSet),
recordSet,
DDLPortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, Repository repository)
throws Exception {
Element repositoryElement = portletDataContext.getExportDataElement(repository);
Folder folder = DLAppLocalServiceUtil.getFolder(repository.getDlFolderId());
if (folder.getModel() instanceof DLFolder) {
DLFolder dlFolder = (DLFolder) folder.getModel();
repositoryElement.addAttribute("hidden", String.valueOf(dlFolder.isHidden()));
}
portletDataContext.addClassedModel(
repositoryElement, ExportImportPathUtil.getModelPath(repository), repository);
List<RepositoryEntry> repositoryEntries =
RepositoryEntryLocalServiceUtil.getRepositoryEntries(repository.getRepositoryId());
for (RepositoryEntry repositoryEntry : repositoryEntries) {
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext, repository, repositoryEntry, PortletDataContext.REFERENCE_TYPE_CHILD);
}
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, DLFileEntryType fileEntryType) throws Exception {
Element fileEntryTypeElement = portletDataContext.getExportDataElement(fileEntryType);
List<DDMStructure> ddmStructures = fileEntryType.getDDMStructures();
for (DDMStructure ddmStructure : ddmStructures) {
Element referenceElement =
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext,
fileEntryType,
ddmStructure,
PortletDataContext.REFERENCE_TYPE_STRONG);
referenceElement.addAttribute(
"structure-id", StringUtil.valueOf(ddmStructure.getStructureId()));
}
long defaultUserId = UserLocalServiceUtil.getDefaultUserId(fileEntryType.getCompanyId());
if (defaultUserId == fileEntryType.getUserId()) {
fileEntryTypeElement.addAttribute("preloaded", "true");
}
portletDataContext.addClassedModel(
fileEntryTypeElement, ExportImportPathUtil.getModelPath(fileEntryType), fileEntryType);
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, DLFileEntryType fileEntryType) throws Exception {
Element fileEntryTypeElement = portletDataContext.getExportDataElement(fileEntryType);
List<DDMStructure> ddmStructures = fileEntryType.getDDMStructures();
for (DDMStructure ddmStructure : ddmStructures) {
StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, ddmStructure);
Element referenceElement =
portletDataContext.addReferenceElement(
fileEntryType,
fileEntryTypeElement,
ddmStructure,
PortletDataContext.REFERENCE_TYPE_STRONG,
false);
referenceElement.addAttribute(
"structure-id", StringUtil.valueOf(ddmStructure.getStructureId()));
}
portletDataContext.addClassedModel(
fileEntryTypeElement,
ExportImportPathUtil.getModelPath(fileEntryType),
fileEntryType,
DLPortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, Role role)
throws Exception {
String permissionsPath = ExportImportPathUtil.getModelPath(role, "permissions.xml");
List<Permission> permissions =
PermissionConverterUtil.convertPermissions(role, _permissionConversionFilter);
String xml = portletDataContext.toXML(permissions);
portletDataContext.addZipEntry(permissionsPath, xml);
Element roleElement = portletDataContext.getExportDataElement(role);
portletDataContext.addClassedModel(roleElement, ExportImportPathUtil.getModelPath(role), role);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, WikiNode node)
throws Exception {
Element nodeElement = portletDataContext.getExportDataElement(node);
portletDataContext.addClassedModel(nodeElement, ExportImportPathUtil.getModelPath(node), node);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, MDRRuleGroup ruleGroup)
throws Exception {
Element ruleGroupElement = portletDataContext.getExportDataElement(ruleGroup);
portletDataContext.addClassedModel(
ruleGroupElement, ExportImportPathUtil.getModelPath(ruleGroup), ruleGroup);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, Address address)
throws Exception {
Element addressElement = portletDataContext.getExportDataElement(address);
portletDataContext.addClassedModel(
addressElement, ExportImportPathUtil.getModelPath(address), address);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, PollsVote vote)
throws Exception {
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext, vote, vote.getChoice(), PortletDataContext.REFERENCE_TYPE_STRONG);
Element voteElement = portletDataContext.getExportDataElement(vote);
portletDataContext.addClassedModel(voteElement, ExportImportPathUtil.getModelPath(vote), vote);
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, RepositoryEntry repositoryEntry) throws Exception {
Element repositoryEntryElement = portletDataContext.getExportDataElement(repositoryEntry);
portletDataContext.addClassedModel(
repositoryEntryElement,
ExportImportPathUtil.getModelPath(repositoryEntry),
repositoryEntry);
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, LayoutFriendlyURL layoutFriendlyURL) throws Exception {
Element layoutFriendlyURLElement = portletDataContext.getExportDataElement(layoutFriendlyURL);
portletDataContext.addClassedModel(
layoutFriendlyURLElement,
ExportImportPathUtil.getModelPath(layoutFriendlyURL),
layoutFriendlyURL);
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, PasswordPolicy passwordPolicy) throws Exception {
Element passwordPolicyElement =
portletDataContext.getExportDataStagedModelElement(passwordPolicy);
portletDataContext.addClassedModel(
passwordPolicyElement,
ExportImportPathUtil.getModelPath(passwordPolicy),
passwordPolicy,
PasswordPolicyPortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, LayoutPrototype layoutPrototype) throws Exception {
Element layoutPrototypeElement = portletDataContext.getExportDataElement(layoutPrototype);
exportLayouts(portletDataContext, layoutPrototype, layoutPrototypeElement);
portletDataContext.addClassedModel(
layoutPrototypeElement,
ExportImportPathUtil.getModelPath(layoutPrototype),
layoutPrototype,
LayoutPrototypePortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, BookmarksFolder folder)
throws Exception {
if (folder.getParentFolderId() != BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
exportStagedModel(portletDataContext, folder.getParentFolder());
}
Element folderElement = portletDataContext.getExportDataElement(folder);
portletDataContext.addClassedModel(
folderElement,
ExportImportPathUtil.getModelPath(folder),
folder,
BookmarksPortletDataHandler.NAMESPACE);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, JournalFolder folder)
throws Exception {
if (folder.getParentFolderId() != JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext,
folder,
folder.getParentFolder(),
PortletDataContext.REFERENCE_TYPE_PARENT);
}
Element folderElement = portletDataContext.getExportDataElement(folder);
portletDataContext.addClassedModel(
folderElement, ExportImportPathUtil.getModelPath(folder), folder);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, AssetCategory category)
throws Exception {
if (category.getParentCategoryId() != AssetCategoryConstants.DEFAULT_PARENT_CATEGORY_ID) {
AssetCategory parentCategory =
AssetCategoryLocalServiceUtil.fetchAssetCategory(category.getParentCategoryId());
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext, category, parentCategory, PortletDataContext.REFERENCE_TYPE_PARENT);
} else {
AssetVocabulary vocabulary =
AssetVocabularyLocalServiceUtil.fetchAssetVocabulary(category.getVocabularyId());
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext, category, vocabulary, PortletDataContext.REFERENCE_TYPE_PARENT);
}
Element categoryElement = portletDataContext.getExportDataElement(category);
category.setUserUuid(category.getUserUuid());
List<AssetCategoryProperty> categoryProperties =
AssetCategoryPropertyLocalServiceUtil.getCategoryProperties(category.getCategoryId());
for (AssetCategoryProperty categoryProperty : categoryProperties) {
Element propertyElement = categoryElement.addElement("property");
propertyElement.addAttribute("userUuid", categoryProperty.getUserUuid());
propertyElement.addAttribute("key", categoryProperty.getKey());
propertyElement.addAttribute("value", categoryProperty.getValue());
}
String categoryPath = ExportImportPathUtil.getModelPath(category);
categoryElement.addAttribute("path", categoryPath);
portletDataContext.addPermissions(AssetCategory.class, category.getCategoryId());
portletDataContext.addZipEntry(categoryPath, category);
}
@Override
protected void doExportStagedModel(
PortletDataContext portletDataContext, WSRPConsumerPortlet wsrpConsumerPortlet)
throws Exception {
WSRPConsumer wsrpConsumer =
WSRPConsumerLocalServiceUtil.getWSRPConsumer(wsrpConsumerPortlet.getWsrpConsumerId());
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext,
wsrpConsumerPortlet,
wsrpConsumer,
PortletDataContext.REFERENCE_TYPE_STRONG);
Element wsrpConsumerPortletElement =
portletDataContext.getExportDataElement(wsrpConsumerPortlet);
portletDataContext.addClassedModel(
wsrpConsumerPortletElement,
ExportImportPathUtil.getModelPath(wsrpConsumerPortlet),
wsrpConsumerPortlet);
}
@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, MBThreadFlag threadFlag)
throws Exception {
Map<Long, Long> threadIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBThread.class);
long threadId = MapUtil.getLong(threadIds, threadFlag.getThreadId(), threadFlag.getThreadId());
if (threadId == threadFlag.getThreadId()) {
Element element = portletDataContext.getImportDataStagedModelElement(threadFlag);
long rootMessageId = GetterUtil.getLong(element.attributeValue("root-message-id"));
String rootMessagePath =
ExportImportPathUtil.getModelPath(
portletDataContext, MBMessage.class.getName(), rootMessageId);
MBMessage rootMessage = (MBMessage) portletDataContext.getZipEntryAsObject(rootMessagePath);
StagedModelDataHandlerUtil.importStagedModel(portletDataContext, rootMessage);
threadId = MapUtil.getLong(threadIds, threadFlag.getThreadId(), threadFlag.getThreadId());
}
MBThread thread = MBThreadLocalServiceUtil.fetchThread(threadId);
if (thread == null) {
return;
}
long userId = portletDataContext.getUserId(threadFlag.getUserUuid());
ServiceContext serviceContext =
portletDataContext.createServiceContext(threadFlag, MBPortletDataHandler.NAMESPACE);
MBThreadFlagLocalServiceUtil.addThreadFlag(userId, thread, serviceContext);
}
@Override
protected void doExportStagedModel(PortletDataContext portletDataContext, DDMStructure structure)
throws Exception {
Element structureElement = portletDataContext.getExportDataElement(structure);
if (structure.getParentStructureId() != DDMStructureConstants.DEFAULT_PARENT_STRUCTURE_ID) {
DDMStructure parentStructure =
DDMStructureLocalServiceUtil.getStructure(structure.getParentStructureId());
StagedModelDataHandlerUtil.exportReferenceStagedModel(
portletDataContext, structure, parentStructure, PortletDataContext.REFERENCE_TYPE_PARENT);
}
long defaultUserId = UserLocalServiceUtil.getDefaultUserId(structure.getCompanyId());
if (defaultUserId == structure.getUserId()) {
structureElement.addAttribute("preloaded", "true");
}
portletDataContext.addClassedModel(
structureElement, ExportImportPathUtil.getModelPath(structure), structure);
}
@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, MBMessage message)
throws Exception {
long userId = portletDataContext.getUserId(message.getUserUuid());
String userName = message.getUserName();
Map<Long, Long> categoryIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBCategory.class);
long parentCategoryId =
MapUtil.getLong(categoryIds, message.getCategoryId(), message.getCategoryId());
Map<Long, Long> threadIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBThread.class);
long threadId = MapUtil.getLong(threadIds, message.getThreadId(), 0);
Map<Long, Long> messageIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBMessage.class);
long parentMessageId =
MapUtil.getLong(messageIds, message.getParentMessageId(), message.getParentMessageId());
Element element = portletDataContext.getImportDataStagedModelElement(message);
List<ObjectValuePair<String, InputStream>> inputStreamOVPs =
getAttachments(portletDataContext, element, message);
try {
ServiceContext serviceContext =
portletDataContext.createServiceContext(message, MBPortletDataHandler.NAMESPACE);
if (message.getStatus() != WorkflowConstants.STATUS_APPROVED) {
serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
}
if ((parentCategoryId != MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID)
&& (parentCategoryId != MBCategoryConstants.DISCUSSION_CATEGORY_ID)
&& (parentCategoryId == message.getCategoryId())) {
String categoryPath =
ExportImportPathUtil.getModelPath(
portletDataContext, MBCategory.class.getName(), parentCategoryId);
MBCategory category = (MBCategory) portletDataContext.getZipEntryAsObject(categoryPath);
StagedModelDataHandlerUtil.importStagedModel(portletDataContext, category);
parentCategoryId =
MapUtil.getLong(categoryIds, message.getCategoryId(), message.getCategoryId());
}
MBMessage importedMessage = null;
if (portletDataContext.isDataStrategyMirror()) {
MBMessage existingMessage =
MBMessageUtil.fetchByUUID_G(message.getUuid(), portletDataContext.getScopeGroupId());
if (existingMessage == null) {
serviceContext.setUuid(message.getUuid());
importedMessage =
MBMessageLocalServiceUtil.addMessage(
userId,
userName,
portletDataContext.getScopeGroupId(),
parentCategoryId,
threadId,
parentMessageId,
message.getSubject(),
message.getBody(),
message.getFormat(),
inputStreamOVPs,
message.getAnonymous(),
message.getPriority(),
message.getAllowPingbacks(),
serviceContext);
} else {
importedMessage =
MBMessageLocalServiceUtil.updateMessage(
userId,
existingMessage.getMessageId(),
message.getSubject(),
message.getBody(),
inputStreamOVPs,
new ArrayList<String>(),
message.getPriority(),
message.getAllowPingbacks(),
serviceContext);
}
} else {
importedMessage =
MBMessageLocalServiceUtil.addMessage(
userId,
userName,
portletDataContext.getScopeGroupId(),
parentCategoryId,
threadId,
parentMessageId,
message.getSubject(),
message.getBody(),
message.getFormat(),
inputStreamOVPs,
message.getAnonymous(),
message.getPriority(),
message.getAllowPingbacks(),
serviceContext);
}
importedMessage.setAnswer(message.getAnswer());
if (importedMessage.isRoot()) {
MBThreadLocalServiceUtil.updateQuestion(
importedMessage.getThreadId(),
GetterUtil.getBoolean(element.attributeValue("question")));
}
threadIds.put(message.getThreadId(), importedMessage.getThreadId());
portletDataContext.importClassedModel(
message, importedMessage, MBPortletDataHandler.NAMESPACE);
} finally {
for (ObjectValuePair<String, InputStream> inputStreamOVP : inputStreamOVPs) {
InputStream inputStream = inputStreamOVP.getValue();
StreamUtil.cleanUp(inputStream);
}
}
}
@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, BookmarksFolder folder)
throws Exception {
long userId = portletDataContext.getUserId(folder.getUserUuid());
Map<Long, Long> folderIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(BookmarksFolder.class);
long parentFolderId =
MapUtil.getLong(folderIds, folder.getParentFolderId(), folder.getParentFolderId());
if ((parentFolderId != BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID)
&& (parentFolderId == folder.getParentFolderId())) {
String parentFolderPath =
ExportImportPathUtil.getModelPath(
portletDataContext, BookmarksFolder.class.getName(), parentFolderId);
BookmarksFolder parentFolder =
(BookmarksFolder) portletDataContext.getZipEntryAsObject(parentFolderPath);
importStagedModel(portletDataContext, parentFolder);
parentFolderId =
MapUtil.getLong(folderIds, folder.getParentFolderId(), folder.getParentFolderId());
}
ServiceContext serviceContext =
portletDataContext.createServiceContext(folder, BookmarksPortletDataHandler.NAMESPACE);
BookmarksFolder importedFolder = null;
if (portletDataContext.isDataStrategyMirror()) {
BookmarksFolder existingFolder =
BookmarksFolderUtil.fetchByUUID_G(folder.getUuid(), portletDataContext.getScopeGroupId());
if (existingFolder == null) {
serviceContext.setUuid(folder.getUuid());
importedFolder =
BookmarksFolderLocalServiceUtil.addFolder(
userId, parentFolderId, folder.getName(), folder.getDescription(), serviceContext);
} else {
importedFolder =
BookmarksFolderLocalServiceUtil.updateFolder(
userId,
existingFolder.getFolderId(),
parentFolderId,
folder.getName(),
folder.getDescription(),
false,
serviceContext);
}
} else {
importedFolder =
BookmarksFolderLocalServiceUtil.addFolder(
userId, parentFolderId, folder.getName(), folder.getDescription(), serviceContext);
}
portletDataContext.importClassedModel(
folder, importedFolder, BookmarksPortletDataHandler.NAMESPACE);
}
@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, Role role)
throws Exception {
long userId = portletDataContext.getUserId(role.getUserUuid());
ServiceContext serviceContext = portletDataContext.createServiceContext(role);
Role existingRole =
RoleLocalServiceUtil.fetchRoleByUuidAndCompanyId(
role.getUuid(), portletDataContext.getCompanyId());
if (existingRole == null) {
existingRole =
RoleLocalServiceUtil.fetchRole(portletDataContext.getCompanyId(), role.getName());
}
Role importedRole = null;
if (existingRole == null) {
serviceContext.setUuid(role.getUuid());
importedRole =
RoleLocalServiceUtil.addRole(
userId,
null,
0,
role.getName(),
role.getTitleMap(),
role.getDescriptionMap(),
role.getType(),
role.getSubtype(),
serviceContext);
} else {
importedRole =
RoleLocalServiceUtil.updateRole(
existingRole.getRoleId(),
role.getName(),
role.getTitleMap(),
role.getDescriptionMap(),
role.getSubtype(),
serviceContext);
deleteRolePermissions(portletDataContext, importedRole);
}
String permissionsPath = ExportImportPathUtil.getModelPath(role, "permissions.xml");
List<Permission> permissions =
(List<Permission>) portletDataContext.getZipEntryAsObject(permissionsPath);
for (Permission permission : permissions) {
if (ResourceBlockLocalServiceUtil.isSupported(permission.getName())) {
importResourceBlock(portletDataContext, importedRole, permission);
} else {
importResourcePermissions(portletDataContext, importedRole, permission);
}
}
portletDataContext.importClassedModel(role, importedRole);
}
@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, DDLRecordSet recordSet)
throws Exception {
long userId = portletDataContext.getUserId(recordSet.getUserUuid());
Map<Long, Long> ddmStructureIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(DDMStructure.class);
String structurePath =
ExportImportPathUtil.getModelPath(
portletDataContext, DDMStructure.class.getName(), recordSet.getDDMStructureId());
DDMStructure ddmStructure =
(DDMStructure) portletDataContext.getZipEntryAsObject(structurePath);
StagedModelDataHandlerUtil.importStagedModel(portletDataContext, ddmStructure);
long ddmStructureId =
MapUtil.getLong(
ddmStructureIds, recordSet.getDDMStructureId(), recordSet.getDDMStructureId());
List<Element> ddmTemplateElements =
portletDataContext.getReferenceDataElements(recordSet, DDMTemplate.class);
for (Element ddmTemplateElement : ddmTemplateElements) {
StagedModelDataHandlerUtil.importStagedModel(portletDataContext, ddmTemplateElement);
}
ServiceContext serviceContext =
portletDataContext.createServiceContext(recordSet, DDLPortletDataHandler.NAMESPACE);
DDLRecordSet importedRecordSet = null;
if (portletDataContext.isDataStrategyMirror()) {
DDLRecordSet existingRecordSet =
DDLRecordSetUtil.fetchByUUID_G(recordSet.getUuid(), portletDataContext.getScopeGroupId());
if (existingRecordSet == null) {
serviceContext.setUuid(recordSet.getUuid());
importedRecordSet =
DDLRecordSetLocalServiceUtil.addRecordSet(
userId,
portletDataContext.getScopeGroupId(),
ddmStructureId,
recordSet.getRecordSetKey(),
recordSet.getNameMap(),
recordSet.getDescriptionMap(),
recordSet.getMinDisplayRows(),
recordSet.getScope(),
serviceContext);
} else {
importedRecordSet =
DDLRecordSetLocalServiceUtil.updateRecordSet(
existingRecordSet.getRecordSetId(), ddmStructureId,
recordSet.getNameMap(), recordSet.getDescriptionMap(),
recordSet.getMinDisplayRows(), serviceContext);
}
} else {
importedRecordSet =
DDLRecordSetLocalServiceUtil.addRecordSet(
userId,
portletDataContext.getScopeGroupId(),
ddmStructureId,
recordSet.getRecordSetKey(),
recordSet.getNameMap(),
recordSet.getDescriptionMap(),
recordSet.getMinDisplayRows(),
recordSet.getScope(),
serviceContext);
}
portletDataContext.importClassedModel(
recordSet, importedRecordSet, DDLPortletDataHandler.NAMESPACE);
}
