protected File[] exportLayouts(long userGroupId, Map<String, String[]> parameterMap)
throws PortalException {
File[] files = new File[2];
UserGroup userGroup = userGroupPersistence.findByPrimaryKey(userGroupId);
User user = userLocalService.getUser(GetterUtil.getLong(PrincipalThreadLocal.getName()));
Group group = userGroup.getGroup();
if (userGroup.hasPrivateLayouts()) {
Map<String, Serializable> exportLayoutSettingsMap =
ExportImportConfigurationSettingsMapFactory.buildExportLayoutSettingsMap(
user,
group.getGroupId(),
true,
ExportImportHelperUtil.getAllLayoutIds(group.getGroupId(), true),
parameterMap);
ExportImportConfiguration exportImportConfiguration =
exportImportConfigurationLocalService.addDraftExportImportConfiguration(
user.getUserId(),
ExportImportConfigurationConstants.TYPE_EXPORT_LAYOUT,
exportLayoutSettingsMap);
files[0] = exportImportLocalService.exportLayoutsAsFile(exportImportConfiguration);
}
if (userGroup.hasPublicLayouts()) {
Map<String, Serializable> exportLayoutSettingsMap =
ExportImportConfigurationSettingsMapFactory.buildExportLayoutSettingsMap(
user,
group.getGroupId(),
false,
ExportImportHelperUtil.getAllLayoutIds(group.getGroupId(), false),
parameterMap);
ExportImportConfiguration exportImportConfiguration =
exportImportConfigurationLocalService.addDraftExportImportConfiguration(
user.getUserId(),
ExportImportConfigurationConstants.TYPE_EXPORT_LAYOUT,
exportLayoutSettingsMap);
files[1] = exportImportLocalService.exportLayoutsAsFile(exportImportConfiguration);
}
return files;
}
protected PortletDataContext getPortletDataContext(
ExportImportConfiguration exportImportConfiguration, File file) throws PortalException {
Map<String, Serializable> settingsMap = exportImportConfiguration.getSettingsMap();
Map<String, String[]> parameterMap = (Map<String, String[]>) settingsMap.get("parameterMap");
String portletId = MapUtil.getString(settingsMap, "portletId");
long targetPlid = MapUtil.getLong(settingsMap, "targetPlid");
long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
long userId = MapUtil.getLong(settingsMap, "userId");
Layout layout = _layoutLocalService.getLayout(targetPlid);
String userIdStrategyString =
MapUtil.getString(parameterMap, PortletDataHandlerKeys.USER_ID_STRATEGY);
UserIdStrategy userIdStrategy =
ExportImportHelperUtil.getUserIdStrategy(userId, userIdStrategyString);
ZipReader zipReader = ZipReaderFactoryUtil.getZipReader(file);
PortletDataContext portletDataContext =
PortletDataContextFactoryUtil.createImportPortletDataContext(
layout.getCompanyId(), targetGroupId, parameterMap, userIdStrategy, zipReader);
portletDataContext.setOldPlid(targetPlid);
portletDataContext.setPlid(targetPlid);
portletDataContext.setPortletId(portletId);
portletDataContext.setPrivateLayout(layout.isPrivateLayout());
return portletDataContext;
}
protected PortletDataContext getPortletDataContext(
ExportImportConfiguration exportImportConfiguration) throws PortalException {
Map<String, Serializable> settingsMap = exportImportConfiguration.getSettingsMap();
long sourcePlid = MapUtil.getLong(settingsMap, "sourcePlid");
long sourceGroupId = MapUtil.getLong(settingsMap, "sourceGroupId");
String portletId = MapUtil.getString(settingsMap, "portletId");
Map<String, String[]> parameterMap = (Map<String, String[]>) settingsMap.get("parameterMap");
DateRange dateRange = ExportImportDateUtil.getDateRange(exportImportConfiguration);
Layout layout = _layoutLocalService.getLayout(sourcePlid);
ZipWriter zipWriter = ExportImportHelperUtil.getPortletZipWriter(portletId);
PortletDataContext portletDataContext =
PortletDataContextFactoryUtil.createExportPortletDataContext(
layout.getCompanyId(),
sourceGroupId,
parameterMap,
dateRange.getStartDate(),
dateRange.getEndDate(),
zipWriter);
portletDataContext.setOldPlid(sourcePlid);
portletDataContext.setPlid(sourcePlid);
portletDataContext.setPortletId(portletId);
return portletDataContext;
}
protected PortletDataContext getPortletDataContext(
ExportImportConfiguration exportImportConfiguration) throws Exception {
Map<String, Serializable> settingsMap = exportImportConfiguration.getSettingsMap();
long sourceGroupId = MapUtil.getLong(settingsMap, "sourceGroupId");
boolean privateLayout = MapUtil.getBoolean(settingsMap, "privateLayout");
Map<String, String[]> parameterMap = (Map<String, String[]>) settingsMap.get("parameterMap");
DateRange dateRange = ExportImportDateUtil.getDateRange(exportImportConfiguration);
Group group = _groupLocalService.getGroup(sourceGroupId);
ZipWriter zipWriter = ExportImportHelperUtil.getLayoutSetZipWriter(sourceGroupId);
PortletDataContext portletDataContext =
PortletDataContextFactoryUtil.createExportPortletDataContext(
group.getCompanyId(),
sourceGroupId,
parameterMap,
dateRange.getStartDate(),
dateRange.getEndDate(),
zipWriter);
portletDataContext.setPrivateLayout(privateLayout);
return portletDataContext;
}
protected static ExportImportConfiguration buildDefaultRemotePublishingExportImportConfiguration(
User user,
long sourceGroupId,
boolean privateLayout,
String remoteAddress,
int remotePort,
String remotePathContext,
boolean secureConnection,
long remoteGroupId,
Map<String, String[]> parameterMap)
throws PortalException {
Map<String, Serializable> publishLayoutRemoteSettingsMap =
ExportImportConfigurationSettingsMapFactory.buildPublishLayoutRemoteSettingsMap(
user.getUserId(),
sourceGroupId,
privateLayout,
ExportImportHelperUtil.getAllLayoutIdsMap(sourceGroupId, privateLayout),
parameterMap,
remoteAddress,
remotePort,
remotePathContext,
secureConnection,
remoteGroupId,
privateLayout,
user.getLocale(),
user.getTimeZone());
return ExportImportConfigurationLocalServiceUtil.addDraftExportImportConfiguration(
user.getUserId(),
ExportImportConfigurationConstants.TYPE_PUBLISH_LAYOUT_REMOTE,
publishLayoutRemoteSettingsMap);
}
protected File exportLayoutsAsFile(
ExportImportConfiguration exportImportConfiguration,
Map<Long, Boolean> layoutIdMap,
long remoteGroupId,
HttpPrincipal httpPrincipal)
throws PortalException {
List<Layout> layouts = new ArrayList<>();
if (layoutIdMap != null) {
for (Map.Entry<Long, Boolean> entry : layoutIdMap.entrySet()) {
long plid = GetterUtil.getLong(String.valueOf(entry.getKey()));
boolean includeChildren = entry.getValue();
Layout layout = LayoutLocalServiceUtil.getLayout(plid);
if (!layouts.contains(layout)) {
layouts.add(layout);
}
List<Layout> parentLayouts =
getMissingRemoteParentLayouts(httpPrincipal, layout, remoteGroupId);
for (Layout parentLayout : parentLayouts) {
if (!layouts.contains(parentLayout)) {
layouts.add(parentLayout);
}
}
if (includeChildren) {
for (Layout childLayout : layout.getAllChildren()) {
if (!layouts.contains(childLayout)) {
layouts.add(childLayout);
}
}
}
}
}
long[] layoutIds = ExportImportHelperUtil.getLayoutIds(layouts);
Map<String, Serializable> settingsMap = exportImportConfiguration.getSettingsMap();
settingsMap.remove("layoutIdMap");
settingsMap.put("layoutIds", layoutIds);
return ExportImportLocalServiceUtil.exportLayoutsAsFile(exportImportConfiguration);
}
@Override
public long performCount() throws PortalException {
ManifestSummary manifestSummary = _portletDataContext.getManifestSummary();
StagedModelType stagedModelType = getStagedModelType();
long modelAdditionCount = super.performCount();
manifestSummary.addModelAdditionCount(stagedModelType.toString(), modelAdditionCount);
long modelDeletionCount =
ExportImportHelperUtil.getModelDeletionCount(_portletDataContext, stagedModelType);
manifestSummary.addModelDeletionCount(stagedModelType.toString(), modelDeletionCount);
return modelAdditionCount;
}
@Override
public MissingReferences validateFile(
ExportImportConfiguration exportImportConfiguration, File file) throws Exception {
ZipReader zipReader = null;
try {
ExportImportThreadLocal.setPortletValidationInProcess(true);
Map<String, Serializable> settingsMap = exportImportConfiguration.getSettingsMap();
String portletId = MapUtil.getString(settingsMap, "portletId");
long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
long targetPlid = MapUtil.getLong(settingsMap, "targetPlid");
Layout layout = _layoutLocalService.getLayout(targetPlid);
zipReader = ZipReaderFactoryUtil.getZipReader(file);
validateFile(layout.getCompanyId(), targetGroupId, portletId, zipReader);
PortletDataContext portletDataContext =
getPortletDataContext(exportImportConfiguration, file);
MissingReferences missingReferences =
ExportImportHelperUtil.validateMissingReferences(portletDataContext);
Map<String, MissingReference> dependencyMissingReferences =
missingReferences.getDependencyMissingReferences();
if (!dependencyMissingReferences.isEmpty()) {
throw new MissingReferenceException(missingReferences);
}
return missingReferences;
} finally {
ExportImportThreadLocal.setPortletValidationInProcess(false);
if (zipReader != null) {
zipReader.close();
}
}
}
public static ExportImportConfiguration buildDefaultLocalPublishingExportImportConfiguration(
User user,
long sourceGroupId,
long targetGroupId,
boolean privateLayout,
Map<String, String[]> parameterMap)
throws PortalException {
Map<String, Serializable> publishLayoutLocalSettingsMap =
ExportImportConfigurationSettingsMapFactory.buildPublishLayoutLocalSettingsMap(
user,
sourceGroupId,
targetGroupId,
privateLayout,
ExportImportHelperUtil.getAllLayoutIds(sourceGroupId, privateLayout),
parameterMap);
return ExportImportConfigurationLocalServiceUtil.addDraftExportImportConfiguration(
user.getUserId(),
ExportImportConfigurationConstants.TYPE_PUBLISH_LAYOUT_LOCAL,
publishLayoutLocalSettingsMap);
}
protected void doImportPortletInfo(PortletDataContext portletDataContext, long userId)
throws Exception {
Map<String, String[]> parameterMap = portletDataContext.getParameterMap();
boolean importPermissions =
MapUtil.getBoolean(parameterMap, PortletDataHandlerKeys.PERMISSIONS);
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ServiceContext serviceContext = ServiceContextThreadLocal.getServiceContext();
if (serviceContext == null) {
serviceContext = new ServiceContext();
serviceContext.setCompanyId(portletDataContext.getCompanyId());
serviceContext.setSignedIn(false);
serviceContext.setUserId(userId);
ServiceContextThreadLocal.pushServiceContext(serviceContext);
}
// LAR validation
validateFile(
portletDataContext.getCompanyId(),
portletDataContext.getGroupId(),
portletDataContext.getPortletId(),
portletDataContext.getZipReader());
// Source and target group id
Map<Long, Long> groupIds =
(Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(Group.class);
groupIds.put(portletDataContext.getSourceGroupId(), portletDataContext.getGroupId());
// Manifest
ManifestSummary manifestSummary = ExportImportHelperUtil.getManifestSummary(portletDataContext);
if (BackgroundTaskThreadLocal.hasBackgroundTask()) {
PortletDataHandlerStatusMessageSenderUtil.sendStatusMessage(
"portlet", portletDataContext.getPortletId(), manifestSummary);
}
portletDataContext.setManifestSummary(manifestSummary);
// Read expando tables, locks and permissions to make them
// available to the data handlers through the portlet data context
Element rootElement = portletDataContext.getImportDataRootElement();
Element portletElement = null;
try {
portletElement = rootElement.element("portlet");
Document portletDocument =
SAXReaderUtil.read(
portletDataContext.getZipEntryAsString(portletElement.attributeValue("path")));
portletElement = portletDocument.getRootElement();
} catch (DocumentException de) {
throw new SystemException(de);
}
LayoutCache layoutCache = new LayoutCache();
if (importPermissions) {
_permissionImporter.checkRoles(
layoutCache,
portletDataContext.getCompanyId(),
portletDataContext.getGroupId(),
userId,
portletElement);
_permissionImporter.readPortletDataPermissions(portletDataContext);
}
readExpandoTables(portletDataContext);
readLocks(portletDataContext);
Element portletDataElement = portletElement.element("portlet-data");
Map<String, Boolean> importPortletControlsMap =
ExportImportHelperUtil.getImportPortletControlsMap(
portletDataContext.getCompanyId(),
portletDataContext.getPortletId(),
parameterMap,
portletDataElement,
manifestSummary);
Layout layout = _layoutLocalService.getLayout(portletDataContext.getPlid());
try {
// Portlet preferences
importPortletPreferences(
portletDataContext,
layout.getCompanyId(),
portletDataContext.getGroupId(),
layout,
portletElement,
true,
importPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_ARCHIVED_SETUPS),
importPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_DATA),
importPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_SETUP),
importPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_USER_PREFERENCES));
// Portlet data
if (importPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_DATA)) {
if (_log.isDebugEnabled()) {
_log.debug("Importing portlet data");
}
importPortletData(portletDataContext, portletDataElement);
}
} finally {
resetPortletScope(portletDataContext, portletDataContext.getGroupId());
}
// Portlet permissions
if (importPermissions) {
if (_log.isDebugEnabled()) {
_log.debug("Importing portlet permissions");
}
_permissionImporter.importPortletPermissions(
layoutCache,
portletDataContext.getCompanyId(),
portletDataContext.getGroupId(),
userId,
layout,
portletElement,
portletDataContext.getPortletId());
if (userId > 0) {
Indexer<User> indexer = IndexerRegistryUtil.nullSafeGetIndexer(User.class);
User user = _userLocalService.fetchUser(userId);
indexer.reindex(user);
}
}
// Asset links
if (_log.isDebugEnabled()) {
_log.debug("Importing asset links");
}
importAssetLinks(portletDataContext);
// Deletion system events
_deletionSystemEventImporter.importDeletionSystemEvents(portletDataContext);
if (_log.isInfoEnabled()) {
_log.info("Importing portlet takes " + stopWatch.getTime() + " ms");
}
// Service portlet preferences
boolean importPortletSetup = importPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_SETUP);
if (importPortletSetup) {
try {
List<Element> serviceElements = rootElement.elements("service");
for (Element serviceElement : serviceElements) {
Document serviceDocument =
SAXReaderUtil.read(
portletDataContext.getZipEntryAsString(serviceElement.attributeValue("path")));
importServicePortletPreferences(portletDataContext, serviceDocument.getRootElement());
}
} catch (DocumentException de) {
throw new SystemException(de);
}
}
ZipReader zipReader = portletDataContext.getZipReader();
zipReader.close();
}
/**
* Returns an export layout settings map if the type is {@link
* ExportImportConfigurationConstants#TYPE_EXPORT_LAYOUT}; otherwise, returns either a local or
* remote publish layout settings map, depending on the staging type.
*
* @param portletRequest the portlet request
* @param groupId the primary key of the group
* @param type the export/import option type
* @return an export layout settings map if the type is an export layout; otherwise, returns
* either a local or remote publish layout settings map, depending on the staging type
*/
public static Map<String, Serializable> buildSettingsMap(
PortletRequest portletRequest, long groupId, int type) throws PortalException {
ThemeDisplay themeDisplay = (ThemeDisplay) portletRequest.getAttribute(WebKeys.THEME_DISPLAY);
boolean privateLayout = ParamUtil.getBoolean(portletRequest, "privateLayout");
Map<Long, Boolean> layoutIdMap = ExportImportHelperUtil.getLayoutIdMap(portletRequest);
if (type == ExportImportConfigurationConstants.TYPE_EXPORT_LAYOUT) {
long[] layoutIds = ExportImportHelperUtil.getLayoutIds(layoutIdMap);
return buildExportLayoutSettingsMap(
themeDisplay.getUserId(),
groupId,
privateLayout,
layoutIds,
portletRequest.getParameterMap(),
themeDisplay.getLocale(),
themeDisplay.getTimeZone());
}
Group stagingGroup = GroupLocalServiceUtil.getGroup(groupId);
Group liveGroup = stagingGroup.getLiveGroup();
Map<String, String[]> parameterMap =
ExportImportConfigurationParameterMapFactory.buildParameterMap(portletRequest);
if (liveGroup != null) {
long[] layoutIds = ExportImportHelperUtil.getLayoutIds(layoutIdMap, liveGroup.getGroupId());
return buildPublishLayoutLocalSettingsMap(
themeDisplay.getUserId(),
stagingGroup.getGroupId(),
liveGroup.getGroupId(),
privateLayout,
layoutIds,
parameterMap,
themeDisplay.getLocale(),
themeDisplay.getTimeZone());
}
UnicodeProperties groupTypeSettingsProperties = stagingGroup.getTypeSettingsProperties();
String remoteAddress =
ParamUtil.getString(
portletRequest,
"remoteAddress",
groupTypeSettingsProperties.getProperty("remoteAddress"));
remoteAddress = StagingUtil.stripProtocolFromRemoteAddress(remoteAddress);
int remotePort =
ParamUtil.getInteger(
portletRequest,
"remotePort",
GetterUtil.getInteger(groupTypeSettingsProperties.getProperty("remotePort")));
String remotePathContext =
ParamUtil.getString(
portletRequest,
"remotePathContext",
groupTypeSettingsProperties.getProperty("remotePathContext"));
boolean secureConnection =
ParamUtil.getBoolean(
portletRequest,
"secureConnection",
GetterUtil.getBoolean(groupTypeSettingsProperties.getProperty("secureConnection")));
long remoteGroupId =
ParamUtil.getLong(
portletRequest,
"remoteGroupId",
GetterUtil.getLong(groupTypeSettingsProperties.getProperty("remoteGroupId")));
boolean remotePrivateLayout = ParamUtil.getBoolean(portletRequest, "remotePrivateLayout");
StagingUtil.validateRemote(
groupId, remoteAddress, remotePort, remotePathContext, secureConnection, remoteGroupId);
return buildPublishLayoutRemoteSettingsMap(
themeDisplay.getUserId(),
groupId,
privateLayout,
layoutIdMap,
parameterMap,
remoteAddress,
remotePort,
remotePathContext,
secureConnection,
remoteGroupId,
remotePrivateLayout,
themeDisplay.getLocale(),
themeDisplay.getTimeZone());
}
protected File doExport(PortletDataContext portletDataContext) throws Exception {
boolean exportPermissions =
MapUtil.getBoolean(
portletDataContext.getParameterMap(), PortletDataHandlerKeys.PERMISSIONS);
if (_log.isDebugEnabled()) {
_log.debug("Export permissions " + exportPermissions);
}
StopWatch stopWatch = new StopWatch();
stopWatch.start();
Layout layout = _layoutLocalService.getLayout(portletDataContext.getPlid());
if (!layout.isTypeControlPanel() && !layout.isTypePanel() && !layout.isTypePortlet()) {
throw new LayoutImportException("Layout type " + layout.getType() + " is not valid");
}
ServiceContext serviceContext = ServiceContextThreadLocal.getServiceContext();
if (serviceContext == null) {
serviceContext = new ServiceContext();
serviceContext.setCompanyId(layout.getCompanyId());
serviceContext.setSignedIn(false);
long defaultUserId = _userLocalService.getDefaultUserId(layout.getCompanyId());
serviceContext.setUserId(defaultUserId);
ServiceContextThreadLocal.pushServiceContext(serviceContext);
}
long layoutSetBranchId =
MapUtil.getLong(portletDataContext.getParameterMap(), "layoutSetBranchId");
serviceContext.setAttribute("layoutSetBranchId", layoutSetBranchId);
long scopeGroupId = portletDataContext.getGroupId();
javax.portlet.PortletPreferences jxPortletPreferences =
PortletPreferencesFactoryUtil.getLayoutPortletSetup(
layout, portletDataContext.getPortletId());
String scopeType = GetterUtil.getString(jxPortletPreferences.getValue("lfrScopeType", null));
String scopeLayoutUuid =
GetterUtil.getString(jxPortletPreferences.getValue("lfrScopeLayoutUuid", null));
if (Validator.isNotNull(scopeType)) {
Group scopeGroup = null;
if (scopeType.equals("company")) {
scopeGroup = _groupLocalService.getCompanyGroup(layout.getCompanyId());
} else if (Validator.isNotNull(scopeLayoutUuid)) {
scopeGroup = layout.getScopeGroup();
}
if (scopeGroup != null) {
scopeGroupId = scopeGroup.getGroupId();
}
}
portletDataContext.setScopeType(scopeType);
portletDataContext.setScopeLayoutUuid(scopeLayoutUuid);
Document document = SAXReaderUtil.createDocument();
Element rootElement = document.addElement("root");
portletDataContext.setExportDataRootElement(rootElement);
Element headerElement = rootElement.addElement("header");
headerElement.addAttribute(
"available-locales",
StringUtil.merge(
LanguageUtil.getAvailableLocales(
PortalUtil.getSiteGroupId(portletDataContext.getScopeGroupId()))));
headerElement.addAttribute("build-number", String.valueOf(ReleaseInfo.getBuildNumber()));
headerElement.addAttribute("export-date", Time.getRFC822());
if (portletDataContext.hasDateRange()) {
headerElement.addAttribute("start-date", String.valueOf(portletDataContext.getStartDate()));
headerElement.addAttribute("end-date", String.valueOf(portletDataContext.getEndDate()));
}
headerElement.addAttribute("type", "portlet");
headerElement.addAttribute("company-id", String.valueOf(portletDataContext.getCompanyId()));
headerElement.addAttribute(
"company-group-id", String.valueOf(portletDataContext.getCompanyGroupId()));
headerElement.addAttribute("group-id", String.valueOf(scopeGroupId));
headerElement.addAttribute(
"user-personal-site-group-id",
String.valueOf(portletDataContext.getUserPersonalSiteGroupId()));
headerElement.addAttribute("private-layout", String.valueOf(layout.isPrivateLayout()));
headerElement.addAttribute("root-portlet-id", portletDataContext.getRootPortletId());
Element missingReferencesElement = rootElement.addElement("missing-references");
portletDataContext.setMissingReferencesElement(missingReferencesElement);
Map<String, Boolean> exportPortletControlsMap =
ExportImportHelperUtil.getExportPortletControlsMap(
layout.getCompanyId(),
portletDataContext.getPortletId(),
portletDataContext.getParameterMap());
exportPortlet(
portletDataContext,
layout,
rootElement,
exportPermissions,
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_ARCHIVED_SETUPS),
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_DATA),
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_SETUP),
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_USER_PREFERENCES));
exportService(
portletDataContext,
rootElement,
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_SETUP));
exportAssetLinks(portletDataContext);
exportExpandoTables(portletDataContext);
exportLocks(portletDataContext);
_deletionSystemEventExporter.exportDeletionSystemEvents(portletDataContext);
if (exportPermissions) {
_permissionExporter.exportPortletDataPermissions(portletDataContext);
}
ExportImportHelperUtil.writeManifestSummary(document, portletDataContext.getManifestSummary());
if (_log.isInfoEnabled()) {
_log.info("Exporting portlet took " + stopWatch.getTime() + " ms");
}
try {
portletDataContext.addZipEntry("/manifest.xml", document.formattedString());
} catch (IOException ioe) {
throw new SystemException(ioe);
}
ZipWriter zipWriter = portletDataContext.getZipWriter();
return zipWriter.getFile();
}
protected File doExport(PortletDataContext portletDataContext, long[] layoutIds)
throws Exception {
Map<String, String[]> parameterMap = portletDataContext.getParameterMap();
boolean ignoreLastPublishDate =
MapUtil.getBoolean(parameterMap, PortletDataHandlerKeys.IGNORE_LAST_PUBLISH_DATE);
boolean layoutSetPrototypeSettings =
MapUtil.getBoolean(parameterMap, PortletDataHandlerKeys.LAYOUT_SET_PROTOTYPE_SETTINGS);
boolean layoutSetSettings =
MapUtil.getBoolean(parameterMap, PortletDataHandlerKeys.LAYOUT_SET_SETTINGS);
boolean logo = MapUtil.getBoolean(parameterMap, PortletDataHandlerKeys.LOGO);
boolean permissions = MapUtil.getBoolean(parameterMap, PortletDataHandlerKeys.PERMISSIONS);
if (_log.isDebugEnabled()) {
_log.debug("Export permissions " + permissions);
}
LayoutSet layoutSet =
_layoutSetLocalService.getLayoutSet(
portletDataContext.getGroupId(), portletDataContext.isPrivateLayout());
long companyId = layoutSet.getCompanyId();
long defaultUserId = _userLocalService.getDefaultUserId(companyId);
ServiceContext serviceContext = ServiceContextThreadLocal.popServiceContext();
if (serviceContext == null) {
serviceContext = new ServiceContext();
}
serviceContext.setCompanyId(companyId);
serviceContext.setSignedIn(false);
serviceContext.setUserId(defaultUserId);
serviceContext.setAttribute("exporting", Boolean.TRUE);
long layoutSetBranchId = MapUtil.getLong(parameterMap, "layoutSetBranchId");
serviceContext.setAttribute("layoutSetBranchId", layoutSetBranchId);
ServiceContextThreadLocal.pushServiceContext(serviceContext);
if (ignoreLastPublishDate) {
portletDataContext.setEndDate(null);
portletDataContext.setStartDate(null);
}
StopWatch stopWatch = new StopWatch();
stopWatch.start();
Document document = SAXReaderUtil.createDocument();
Element rootElement = document.addElement("root");
portletDataContext.setExportDataRootElement(rootElement);
Element headerElement = rootElement.addElement("header");
headerElement.addAttribute(
"available-locales",
StringUtil.merge(LanguageUtil.getAvailableLocales(portletDataContext.getScopeGroupId())));
headerElement.addAttribute("build-number", String.valueOf(ReleaseInfo.getBuildNumber()));
headerElement.addAttribute("export-date", Time.getRFC822());
if (portletDataContext.hasDateRange()) {
headerElement.addAttribute("start-date", String.valueOf(portletDataContext.getStartDate()));
headerElement.addAttribute("end-date", String.valueOf(portletDataContext.getEndDate()));
}
headerElement.addAttribute("company-id", String.valueOf(portletDataContext.getCompanyId()));
headerElement.addAttribute(
"company-group-id", String.valueOf(portletDataContext.getCompanyGroupId()));
headerElement.addAttribute("group-id", String.valueOf(portletDataContext.getGroupId()));
headerElement.addAttribute(
"user-personal-site-group-id",
String.valueOf(portletDataContext.getUserPersonalSiteGroupId()));
headerElement.addAttribute(
"private-layout", String.valueOf(portletDataContext.isPrivateLayout()));
Group group = layoutSet.getGroup();
String type = "layout-set";
if (group.isLayoutPrototype()) {
type = "layout-prototype";
LayoutPrototype layoutPrototype =
_layoutPrototypeLocalService.getLayoutPrototype(group.getClassPK());
headerElement.addAttribute("type-uuid", layoutPrototype.getUuid());
layoutIds =
ExportImportHelperUtil.getAllLayoutIds(
portletDataContext.getGroupId(), portletDataContext.isPrivateLayout());
} else if (group.isLayoutSetPrototype()) {
type = "layout-set-prototype";
LayoutSetPrototype layoutSetPrototype =
_layoutSetPrototypeLocalService.getLayoutSetPrototype(group.getClassPK());
headerElement.addAttribute("type-uuid", layoutSetPrototype.getUuid());
}
headerElement.addAttribute("type", type);
LayoutSetBranch layoutSetBranch =
_layoutSetBranchLocalService.fetchLayoutSetBranch(layoutSetBranchId);
if (logo) {
Image image = null;
if (layoutSetBranch != null) {
image = _imageLocalService.getImage(layoutSetBranch.getLogoId());
} else {
image = _imageLocalService.getImage(layoutSet.getLogoId());
}
if ((image != null) && (image.getTextObj() != null)) {
String logoPath = ExportImportPathUtil.getRootPath(portletDataContext);
logoPath += "/logo";
headerElement.addAttribute("logo-path", logoPath);
portletDataContext.addZipEntry(logoPath, image.getTextObj());
}
}
String layoutSetPrototypeUuid = layoutSet.getLayoutSetPrototypeUuid();
if (layoutSetPrototypeSettings && Validator.isNotNull(layoutSetPrototypeUuid)) {
LayoutSetPrototype layoutSetPrototype =
_layoutSetPrototypeLocalService.getLayoutSetPrototypeByUuidAndCompanyId(
layoutSetPrototypeUuid, companyId);
headerElement.addAttribute("layout-set-prototype-uuid", layoutSetPrototypeUuid);
headerElement.addAttribute(
"layout-set-prototype-name", layoutSetPrototype.getName(LocaleUtil.getDefault()));
}
Element missingReferencesElement = rootElement.addElement("missing-references");
portletDataContext.setMissingReferencesElement(missingReferencesElement);
if (layoutSetBranch != null) {
_themeExporter.exportTheme(portletDataContext, layoutSetBranch);
} else {
_themeExporter.exportTheme(portletDataContext, layoutSet);
}
if (layoutSetSettings) {
Element settingsElement = headerElement.addElement("settings");
if (layoutSetBranch != null) {
settingsElement.addCDATA(layoutSetBranch.getSettings());
} else {
settingsElement.addCDATA(layoutSet.getSettings());
}
}
Map<String, Object[]> portletIds = new LinkedHashMap<>();
List<Layout> layouts =
_layoutLocalService.getLayouts(
portletDataContext.getGroupId(), portletDataContext.isPrivateLayout());
if (group.isStagingGroup()) {
group = group.getLiveGroup();
}
// Collect data portlets
for (Portlet portlet : ExportImportHelperUtil.getDataSiteLevelPortlets(companyId)) {
String portletId = portlet.getRootPortletId();
if (ExportImportThreadLocal.isStagingInProcess() && !group.isStagedPortlet(portletId)) {
continue;
}
// Calculate the amount of exported data
if (BackgroundTaskThreadLocal.hasBackgroundTask()) {
PortletDataHandler portletDataHandler = portlet.getPortletDataHandlerInstance();
portletDataHandler.prepareManifestSummary(portletDataContext);
}
// Add portlet ID to exportable portlets list
portletIds.put(
PortletPermissionUtil.getPrimaryKey(0, portletId),
new Object[] {
portletId,
LayoutConstants.DEFAULT_PLID,
portletDataContext.getGroupId(),
StringPool.BLANK,
StringPool.BLANK
});
if (!portlet.isScopeable()) {
continue;
}
// Scoped data
for (Layout layout : layouts) {
if (!ArrayUtil.contains(layoutIds, layout.getLayoutId())
|| !layout.isTypePortlet()
|| !layout.hasScopeGroup()) {
continue;
}
Group scopeGroup = layout.getScopeGroup();
portletIds.put(
PortletPermissionUtil.getPrimaryKey(layout.getPlid(), portlet.getPortletId()),
new Object[] {
portlet.getPortletId(),
layout.getPlid(),
scopeGroup.getGroupId(),
StringPool.BLANK,
layout.getUuid()
});
}
}
// Collect layout portlets
for (Layout layout : layouts) {
getLayoutPortlets(portletDataContext, layoutIds, portletIds, layout);
}
if (BackgroundTaskThreadLocal.hasBackgroundTask()) {
ManifestSummary manifestSummary = portletDataContext.getManifestSummary();
PortletDataHandlerStatusMessageSenderUtil.sendStatusMessage(
"layout", ArrayUtil.toStringArray(portletIds.keySet()), manifestSummary);
manifestSummary.resetCounters();
}
// Export actual data
portletDataContext.addDeletionSystemEventStagedModelTypes(new StagedModelType(Layout.class));
// Force to always have a layout group element
portletDataContext.getExportDataGroupElement(Layout.class);
for (Layout layout : layouts) {
exportLayout(portletDataContext, layoutIds, layout);
}
Element portletsElement = rootElement.addElement("portlets");
Element servicesElement = rootElement.addElement("services");
long previousScopeGroupId = portletDataContext.getScopeGroupId();
for (Map.Entry<String, Object[]> portletIdsEntry : portletIds.entrySet()) {
Object[] portletObjects = portletIdsEntry.getValue();
String portletId = null;
long plid = LayoutConstants.DEFAULT_PLID;
long scopeGroupId = 0;
String scopeType = StringPool.BLANK;
String scopeLayoutUuid = null;
if (portletObjects.length == 4) {
portletId = (String) portletIdsEntry.getValue()[0];
plid = (Long) portletIdsEntry.getValue()[1];
scopeGroupId = (Long) portletIdsEntry.getValue()[2];
scopeLayoutUuid = (String) portletIdsEntry.getValue()[3];
} else {
portletId = (String) portletIdsEntry.getValue()[0];
plid = (Long) portletIdsEntry.getValue()[1];
scopeGroupId = (Long) portletIdsEntry.getValue()[2];
scopeType = (String) portletIdsEntry.getValue()[3];
scopeLayoutUuid = (String) portletIdsEntry.getValue()[4];
}
Layout layout = _layoutLocalService.fetchLayout(plid);
if (layout == null) {
layout = new LayoutImpl();
layout.setCompanyId(companyId);
layout.setGroupId(portletDataContext.getGroupId());
}
portletDataContext.setPlid(plid);
portletDataContext.setOldPlid(plid);
portletDataContext.setPortletId(portletId);
portletDataContext.setScopeGroupId(scopeGroupId);
portletDataContext.setScopeType(scopeType);
portletDataContext.setScopeLayoutUuid(scopeLayoutUuid);
Map<String, Boolean> exportPortletControlsMap =
ExportImportHelperUtil.getExportPortletControlsMap(
companyId, portletId, parameterMap, type);
try {
_exportImportLifecycleManager.fireExportImportLifecycleEvent(
EVENT_PORTLET_EXPORT_STARTED,
getProcessFlag(),
PortletDataContextFactoryUtil.clonePortletDataContext(portletDataContext));
_portletExportController.exportPortlet(
portletDataContext,
layout,
portletsElement,
permissions,
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_ARCHIVED_SETUPS),
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_DATA),
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_SETUP),
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_USER_PREFERENCES));
_portletExportController.exportService(
portletDataContext,
servicesElement,
exportPortletControlsMap.get(PortletDataHandlerKeys.PORTLET_SETUP));
_exportImportLifecycleManager.fireExportImportLifecycleEvent(
EVENT_PORTLET_EXPORT_SUCCEEDED,
getProcessFlag(),
PortletDataContextFactoryUtil.clonePortletDataContext(portletDataContext));
} catch (Throwable t) {
_exportImportLifecycleManager.fireExportImportLifecycleEvent(
EVENT_PORTLET_EXPORT_FAILED,
getProcessFlag(),
PortletDataContextFactoryUtil.clonePortletDataContext(portletDataContext),
t);
throw t;
}
}
portletDataContext.setScopeGroupId(previousScopeGroupId);
_portletExportController.exportAssetLinks(portletDataContext);
_portletExportController.exportExpandoTables(portletDataContext);
_portletExportController.exportLocks(portletDataContext);
_deletionSystemEventExporter.exportDeletionSystemEvents(portletDataContext);
if (permissions) {
_permissionExporter.exportPortletDataPermissions(portletDataContext);
}
ExportImportHelperUtil.writeManifestSummary(document, portletDataContext.getManifestSummary());
if (_log.isInfoEnabled()) {
_log.info("Exporting layouts takes " + stopWatch.getTime() + " ms");
}
boolean updateLastPublishDate =
MapUtil.getBoolean(
portletDataContext.getParameterMap(), PortletDataHandlerKeys.UPDATE_LAST_PUBLISH_DATE);
if (ExportImportThreadLocal.isStagingInProcess() && updateLastPublishDate) {
ExportImportProcessCallbackRegistryUtil.registerCallback(
new UpdateLayoutSetLastPublishDateCallable(
portletDataContext.getDateRange(),
portletDataContext.getGroupId(),
portletDataContext.isPrivateLayout()));
}
portletDataContext.addZipEntry("/manifest.xml", document.formattedString());
ZipWriter zipWriter = portletDataContext.getZipWriter();
return zipWriter.getFile();
}