001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.exportimport.lar;
016    
017    import static com.liferay.portlet.exportimport.lifecycle.ExportImportLifecycleConstants.EVENT_PORTLET_IMPORT_FAILED;
018    import static com.liferay.portlet.exportimport.lifecycle.ExportImportLifecycleConstants.EVENT_PORTLET_IMPORT_STARTED;
019    import static com.liferay.portlet.exportimport.lifecycle.ExportImportLifecycleConstants.EVENT_PORTLET_IMPORT_SUCCEEDED;
020    import static com.liferay.portlet.exportimport.lifecycle.ExportImportLifecycleConstants.PROCESS_FLAG_PORTLET_IMPORT_IN_PROCESS;
021    import static com.liferay.portlet.exportimport.lifecycle.ExportImportLifecycleConstants.PROCESS_FLAG_PORTLET_STAGING_IN_PROCESS;
022    
023    import com.liferay.portal.LocaleException;
024    import com.liferay.portal.NoSuchPortletPreferencesException;
025    import com.liferay.portal.PortletIdException;
026    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskThreadLocal;
027    import com.liferay.portal.kernel.exception.PortalException;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.language.LanguageUtil;
030    import com.liferay.portal.kernel.lock.Lock;
031    import com.liferay.portal.kernel.log.Log;
032    import com.liferay.portal.kernel.log.LogFactoryUtil;
033    import com.liferay.portal.kernel.search.Indexer;
034    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
035    import com.liferay.portal.kernel.util.ArrayUtil;
036    import com.liferay.portal.kernel.util.GetterUtil;
037    import com.liferay.portal.kernel.util.LocaleUtil;
038    import com.liferay.portal.kernel.util.MapUtil;
039    import com.liferay.portal.kernel.util.ReleaseInfo;
040    import com.liferay.portal.kernel.util.StringBundler;
041    import com.liferay.portal.kernel.util.StringPool;
042    import com.liferay.portal.kernel.util.StringUtil;
043    import com.liferay.portal.kernel.util.Validator;
044    import com.liferay.portal.kernel.xml.Attribute;
045    import com.liferay.portal.kernel.xml.Document;
046    import com.liferay.portal.kernel.xml.DocumentException;
047    import com.liferay.portal.kernel.xml.Element;
048    import com.liferay.portal.kernel.xml.SAXReaderUtil;
049    import com.liferay.portal.kernel.zip.ZipReader;
050    import com.liferay.portal.kernel.zip.ZipReaderFactoryUtil;
051    import com.liferay.portal.model.Group;
052    import com.liferay.portal.model.Layout;
053    import com.liferay.portal.model.LayoutConstants;
054    import com.liferay.portal.model.Portlet;
055    import com.liferay.portal.model.PortletConstants;
056    import com.liferay.portal.model.PortletItem;
057    import com.liferay.portal.model.PortletPreferences;
058    import com.liferay.portal.model.User;
059    import com.liferay.portal.service.GroupLocalServiceUtil;
060    import com.liferay.portal.service.LayoutLocalServiceUtil;
061    import com.liferay.portal.service.PortletItemLocalServiceUtil;
062    import com.liferay.portal.service.PortletLocalServiceUtil;
063    import com.liferay.portal.service.PortletPreferencesLocalServiceUtil;
064    import com.liferay.portal.service.ServiceContext;
065    import com.liferay.portal.service.ServiceContextThreadLocal;
066    import com.liferay.portal.service.UserLocalServiceUtil;
067    import com.liferay.portal.service.persistence.PortletPreferencesUtil;
068    import com.liferay.portal.util.PortalUtil;
069    import com.liferay.portal.util.PortletKeys;
070    import com.liferay.portlet.PortletPreferencesFactoryUtil;
071    import com.liferay.portlet.PortletPreferencesImpl;
072    import com.liferay.portlet.asset.model.AssetEntry;
073    import com.liferay.portlet.asset.model.AssetLink;
074    import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
075    import com.liferay.portlet.asset.service.AssetLinkLocalServiceUtil;
076    import com.liferay.portlet.expando.NoSuchTableException;
077    import com.liferay.portlet.expando.model.ExpandoColumn;
078    import com.liferay.portlet.expando.model.ExpandoTable;
079    import com.liferay.portlet.expando.service.ExpandoColumnLocalServiceUtil;
080    import com.liferay.portlet.expando.service.ExpandoTableLocalServiceUtil;
081    import com.liferay.portlet.expando.util.ExpandoConverterUtil;
082    import com.liferay.portlet.exportimport.LARFileException;
083    import com.liferay.portlet.exportimport.LARTypeException;
084    import com.liferay.portlet.exportimport.LayoutImportException;
085    import com.liferay.portlet.exportimport.MissingReferenceException;
086    import com.liferay.portlet.exportimport.lifecycle.ExportImportLifecycleManager;
087    import com.liferay.portlet.exportimport.staging.MergeLayoutPrototypesThreadLocal;
088    
089    import java.io.File;
090    import java.io.Serializable;
091    
092    import java.util.Arrays;
093    import java.util.Enumeration;
094    import java.util.List;
095    import java.util.Locale;
096    import java.util.Map;
097    
098    import org.apache.commons.lang.time.StopWatch;
099    
100    /**
101     * @author Brian Wing Shun Chan
102     * @author Joel Kozikowski
103     * @author Charles May
104     * @author Raymond Aug??
105     * @author Jorge Ferrer
106     * @author Bruno Farache
107     * @author Zsigmond Rab
108     * @author Douglas Wong
109     * @author Mate Thurzo
110     */
111    public class PortletImporter {
112    
113            public static PortletImporter getInstance() {
114                    return _instance;
115            }
116    
117            public String importPortletData(
118                            PortletDataContext portletDataContext,
119                            PortletPreferences portletPreferences, Element portletDataElement)
120                    throws Exception {
121    
122                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
123                            portletDataContext.getCompanyId(),
124                            portletDataContext.getPortletId());
125    
126                    if (portlet == null) {
127                            if (_log.isDebugEnabled()) {
128                                    _log.debug(
129                                            "Do not import portlet data for " +
130                                                    portletDataContext.getPortletId() +
131                                                            " because the portlet does not exist");
132                            }
133    
134                            return null;
135                    }
136    
137                    PortletDataHandler portletDataHandler =
138                            portlet.getPortletDataHandlerInstance();
139    
140                    if ((portletDataHandler == null) ||
141                            portletDataHandler.isDataPortletInstanceLevel()) {
142    
143                            if (_log.isDebugEnabled()) {
144                                    StringBundler sb = new StringBundler(4);
145    
146                                    sb.append("Do not import portlet data for ");
147                                    sb.append(portletDataContext.getPortletId());
148                                    sb.append(" because the portlet does not have a ");
149                                    sb.append("PortletDataHandler");
150    
151                                    _log.debug(sb.toString());
152                            }
153    
154                            return null;
155                    }
156    
157                    if (_log.isDebugEnabled()) {
158                            _log.debug(
159                                    "Importing data for " + portletDataContext.getPortletId());
160                    }
161    
162                    PortletPreferencesImpl portletPreferencesImpl = null;
163    
164                    if (portletPreferences != null) {
165                            portletPreferencesImpl =
166                                    (PortletPreferencesImpl)
167                                            PortletPreferencesFactoryUtil.fromDefaultXML(
168                                                    portletPreferences.getPreferences());
169                    }
170    
171                    String portletData = portletDataContext.getZipEntryAsString(
172                            portletDataElement.attributeValue("path"));
173    
174                    if (Validator.isNull(portletData)) {
175                            return null;
176                    }
177    
178                    portletPreferencesImpl =
179                            (PortletPreferencesImpl)portletDataHandler.importData(
180                                    portletDataContext, portletDataContext.getPortletId(),
181                                    portletPreferencesImpl, portletData);
182    
183                    if (portletPreferencesImpl == null) {
184                            return null;
185                    }
186    
187                    return PortletPreferencesFactoryUtil.toXML(portletPreferencesImpl);
188            }
189    
190            public void importPortletDataDeletions(
191                            long userId, long plid, long groupId, String portletId,
192                            Map<String, String[]> parameterMap, File file)
193                    throws Exception {
194    
195                    ZipReader zipReader = null;
196    
197                    try {
198                            ExportImportThreadLocal.setPortletDataDeletionImportInProcess(true);
199    
200                            // LAR validation
201    
202                            Layout layout = LayoutLocalServiceUtil.getLayout(plid);
203    
204                            zipReader = ZipReaderFactoryUtil.getZipReader(file);
205    
206                            validateFile(layout.getCompanyId(), groupId, portletId, zipReader);
207    
208                            PortletDataContext portletDataContext = getPortletDataContext(
209                                    userId, plid, groupId, portletId, parameterMap, file);
210    
211                            boolean deletePortletData = MapUtil.getBoolean(
212                                    parameterMap, PortletDataHandlerKeys.DELETE_PORTLET_DATA);
213    
214                            // Portlet data deletion
215    
216                            if (deletePortletData) {
217                                    if (_log.isDebugEnabled()) {
218                                            _log.debug("Deleting portlet data");
219                                    }
220    
221                                    deletePortletData(portletDataContext);
222                            }
223    
224                            // Deletion system events
225    
226                            populateDeletionStagedModelTypes(portletDataContext);
227    
228                            _deletionSystemEventImporter.importDeletionSystemEvents(
229                                    portletDataContext);
230                    }
231                    finally {
232                            ExportImportThreadLocal.setPortletDataDeletionImportInProcess(
233                                    false);
234    
235                            if (zipReader != null) {
236                                    zipReader.close();
237                            }
238                    }
239            }
240    
241            public void importPortletInfo(
242                            long userId, long plid, long groupId, String portletId,
243                            Map<String, String[]> parameterMap, File file)
244                    throws Exception {
245    
246                    PortletDataContext portletDataContext = null;
247    
248                    try {
249                            ExportImportThreadLocal.setPortletImportInProcess(true);
250    
251                            portletDataContext = getPortletDataContext(
252                                    userId, plid, groupId, portletId, parameterMap, file);
253    
254                            ExportImportLifecycleManager.fireExportImportLifecycleEvent(
255                                    EVENT_PORTLET_IMPORT_STARTED, getProcessFlag(),
256                                    PortletDataContextFactoryUtil.clonePortletDataContext(
257                                            portletDataContext));
258    
259                            doImportPortletInfo(portletDataContext, userId);
260    
261                            ExportImportThreadLocal.setPortletImportInProcess(false);
262    
263                            ExportImportLifecycleManager.fireExportImportLifecycleEvent(
264                                    EVENT_PORTLET_IMPORT_SUCCEEDED, getProcessFlag(),
265                                    PortletDataContextFactoryUtil.clonePortletDataContext(
266                                            portletDataContext),
267                                    userId);
268                    }
269                    catch (Throwable t) {
270                            ExportImportThreadLocal.setPortletImportInProcess(false);
271    
272                            ExportImportLifecycleManager.fireExportImportLifecycleEvent(
273                                    EVENT_PORTLET_IMPORT_FAILED, getProcessFlag(),
274                                    PortletDataContextFactoryUtil.clonePortletDataContext(
275                                            portletDataContext),
276                                    t);
277    
278                            throw t;
279                    }
280            }
281    
282            public MissingReferences validateFile(
283                            long userId, long plid, long groupId, String portletId,
284                            Map<String, String[]> parameterMap, File file)
285                    throws Exception {
286    
287                    ZipReader zipReader = null;
288    
289                    try {
290                            ExportImportThreadLocal.setPortletValidationInProcess(true);
291    
292                            Layout layout = LayoutLocalServiceUtil.getLayout(plid);
293    
294                            zipReader = ZipReaderFactoryUtil.getZipReader(file);
295    
296                            validateFile(layout.getCompanyId(), groupId, portletId, zipReader);
297    
298                            PortletDataContext portletDataContext = getPortletDataContext(
299                                    userId, plid, groupId, portletId, parameterMap, file);
300    
301                            MissingReferences missingReferences =
302                                    ExportImportHelperUtil.validateMissingReferences(
303                                            portletDataContext);
304    
305                            Map<String, MissingReference> dependencyMissingReferences =
306                                    missingReferences.getDependencyMissingReferences();
307    
308                            if (!dependencyMissingReferences.isEmpty()) {
309                                    throw new MissingReferenceException(missingReferences);
310                            }
311    
312                            return missingReferences;
313                    }
314                    finally {
315                            ExportImportThreadLocal.setPortletValidationInProcess(false);
316    
317                            if (zipReader != null) {
318                                    zipReader.close();
319                            }
320                    }
321            }
322    
323            protected void deletePortletData(PortletDataContext portletDataContext)
324                    throws Exception {
325    
326                    long ownerId = PortletKeys.PREFS_OWNER_ID_DEFAULT;
327                    int ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
328    
329                    PortletPreferences portletPreferences =
330                            PortletPreferencesUtil.fetchByO_O_P_P(
331                                    ownerId, ownerType, portletDataContext.getPlid(),
332                                    portletDataContext.getPortletId());
333    
334                    if (portletPreferences == null) {
335                            portletPreferences =
336                                    new com.liferay.portal.model.impl.PortletPreferencesImpl();
337                    }
338    
339                    String xml = deletePortletData(portletDataContext, portletPreferences);
340    
341                    if (xml != null) {
342                            PortletPreferencesLocalServiceUtil.updatePreferences(
343                                    ownerId, ownerType, portletDataContext.getPlid(),
344                                    portletDataContext.getPortletId(), xml);
345                    }
346            }
347    
348            protected String deletePortletData(
349                            PortletDataContext portletDataContext,
350                            PortletPreferences portletPreferences)
351                    throws Exception {
352    
353                    Group group = GroupLocalServiceUtil.getGroup(
354                            portletDataContext.getGroupId());
355    
356                    if (!group.isStagedPortlet(portletDataContext.getPortletId())) {
357                            if (_log.isDebugEnabled()) {
358                                    _log.debug(
359                                            "Do not delete portlet data for " +
360                                                    portletDataContext.getPortletId() +
361                                                            " because the portlet is not staged");
362                            }
363    
364                            return null;
365                    }
366    
367                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
368                            portletDataContext.getCompanyId(),
369                            portletDataContext.getPortletId());
370    
371                    if (portlet == null) {
372                            if (_log.isDebugEnabled()) {
373                                    _log.debug(
374                                            "Do not delete portlet data for " +
375                                                    portletDataContext.getPortletId() +
376                                                            " because the portlet does not exist");
377                            }
378    
379                            return null;
380                    }
381    
382                    PortletDataHandler portletDataHandler =
383                            portlet.getPortletDataHandlerInstance();
384    
385                    if (portletDataHandler == null) {
386                            if (_log.isDebugEnabled()) {
387                                    StringBundler sb = new StringBundler(4);
388    
389                                    sb.append("Do not delete portlet data for ");
390                                    sb.append(portletDataContext.getPortletId());
391                                    sb.append(" because the portlet does not have a ");
392                                    sb.append("PortletDataHandler");
393    
394                                    _log.debug(sb.toString());
395                            }
396    
397                            return null;
398                    }
399    
400                    if (_log.isDebugEnabled()) {
401                            _log.debug(
402                                    "Deleting data for " + portletDataContext.getPortletId());
403                    }
404    
405                    PortletPreferencesImpl portletPreferencesImpl =
406                            (PortletPreferencesImpl)
407                                    PortletPreferencesFactoryUtil.fromDefaultXML(
408                                            portletPreferences.getPreferences());
409    
410                    try {
411                            portletPreferencesImpl =
412                                    (PortletPreferencesImpl)portletDataHandler.deleteData(
413                                            portletDataContext, portletDataContext.getPortletId(),
414                                            portletPreferencesImpl);
415                    }
416                    finally {
417                            portletDataContext.setGroupId(portletDataContext.getScopeGroupId());
418                    }
419    
420                    if (portletPreferencesImpl == null) {
421                            return null;
422                    }
423    
424                    return PortletPreferencesFactoryUtil.toXML(portletPreferencesImpl);
425            }
426    
427            protected void doImportPortletInfo(
428                            PortletDataContext portletDataContext, long userId)
429                    throws Exception {
430    
431                    Map<String, String[]> parameterMap =
432                            portletDataContext.getParameterMap();
433    
434                    boolean importPermissions = MapUtil.getBoolean(
435                            parameterMap, PortletDataHandlerKeys.PERMISSIONS);
436    
437                    StopWatch stopWatch = new StopWatch();
438    
439                    stopWatch.start();
440    
441                    ServiceContext serviceContext =
442                            ServiceContextThreadLocal.getServiceContext();
443    
444                    if (serviceContext == null) {
445                            serviceContext = new ServiceContext();
446    
447                            serviceContext.setCompanyId(portletDataContext.getCompanyId());
448                            serviceContext.setSignedIn(false);
449                            serviceContext.setUserId(userId);
450    
451                            ServiceContextThreadLocal.pushServiceContext(serviceContext);
452                    }
453    
454                    // LAR validation
455    
456                    validateFile(
457                            portletDataContext.getCompanyId(), portletDataContext.getGroupId(),
458                            portletDataContext.getPortletId(),
459                            portletDataContext.getZipReader());
460    
461                    // Source and target group id
462    
463                    Map<Long, Long> groupIds =
464                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
465                                    Group.class);
466    
467                    groupIds.put(
468                            portletDataContext.getSourceGroupId(),
469                            portletDataContext.getGroupId());
470    
471                    // Manifest
472    
473                    ManifestSummary manifestSummary =
474                            ExportImportHelperUtil.getManifestSummary(portletDataContext);
475    
476                    if (BackgroundTaskThreadLocal.hasBackgroundTask()) {
477                            PortletDataHandlerStatusMessageSenderUtil.sendStatusMessage(
478                                    "portlet", portletDataContext.getPortletId(), manifestSummary);
479                    }
480    
481                    portletDataContext.setManifestSummary(manifestSummary);
482    
483                    // Read expando tables, locks and permissions to make them
484                    // available to the data handlers through the portlet data context
485    
486                    Element rootElement = portletDataContext.getImportDataRootElement();
487    
488                    Element portletElement = null;
489    
490                    try {
491                            portletElement = rootElement.element("portlet");
492    
493                            Document portletDocument = SAXReaderUtil.read(
494                                    portletDataContext.getZipEntryAsString(
495                                            portletElement.attributeValue("path")));
496    
497                            portletElement = portletDocument.getRootElement();
498                    }
499                    catch (DocumentException de) {
500                            throw new SystemException(de);
501                    }
502    
503                    LayoutCache layoutCache = new LayoutCache();
504    
505                    if (importPermissions) {
506                            _permissionImporter.checkRoles(
507                                    layoutCache, portletDataContext.getCompanyId(),
508                                    portletDataContext.getGroupId(), userId, portletElement);
509    
510                            _permissionImporter.readPortletDataPermissions(portletDataContext);
511                    }
512    
513                    readExpandoTables(portletDataContext);
514                    readLocks(portletDataContext);
515    
516                    Element portletDataElement = portletElement.element("portlet-data");
517    
518                    Map<String, Boolean> importPortletControlsMap =
519                            ExportImportHelperUtil.getImportPortletControlsMap(
520                                    portletDataContext.getCompanyId(),
521                                    portletDataContext.getPortletId(), parameterMap,
522                                    portletDataElement, manifestSummary);
523    
524                    Layout layout = LayoutLocalServiceUtil.getLayout(
525                            portletDataContext.getPlid());
526    
527                    try {
528    
529                            // Portlet preferences
530    
531                            importPortletPreferences(
532                                    portletDataContext, layout.getCompanyId(),
533                                    portletDataContext.getGroupId(), layout, portletElement, true,
534                                    importPortletControlsMap.get(
535                                            PortletDataHandlerKeys.PORTLET_ARCHIVED_SETUPS),
536                                    importPortletControlsMap.get(
537                                            PortletDataHandlerKeys.PORTLET_DATA),
538                                    importPortletControlsMap.get(
539                                            PortletDataHandlerKeys.PORTLET_SETUP),
540                                    importPortletControlsMap.get(
541                                            PortletDataHandlerKeys.PORTLET_USER_PREFERENCES));
542    
543                            // Portlet data
544    
545                            if (importPortletControlsMap.get(
546                                            PortletDataHandlerKeys.PORTLET_DATA)) {
547    
548                                    if (_log.isDebugEnabled()) {
549                                            _log.debug("Importing portlet data");
550                                    }
551    
552                                    importPortletData(portletDataContext, portletDataElement);
553                            }
554                    }
555                    finally {
556                            resetPortletScope(
557                                    portletDataContext, portletDataContext.getGroupId());
558                    }
559    
560                    // Portlet permissions
561    
562                    if (importPermissions) {
563                            if (_log.isDebugEnabled()) {
564                                    _log.debug("Importing portlet permissions");
565                            }
566    
567                            _permissionImporter.importPortletPermissions(
568                                    layoutCache, portletDataContext.getCompanyId(),
569                                    portletDataContext.getGroupId(), userId, layout, portletElement,
570                                    portletDataContext.getPortletId());
571    
572                            if (userId > 0) {
573                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
574                                            User.class);
575    
576                                    indexer.reindex(userId);
577                            }
578                    }
579    
580                    // Asset links
581    
582                    if (_log.isDebugEnabled()) {
583                            _log.debug("Importing asset links");
584                    }
585    
586                    readAssetLinks(portletDataContext);
587    
588                    // Deletion system events
589    
590                    _deletionSystemEventImporter.importDeletionSystemEvents(
591                            portletDataContext);
592    
593                    if (_log.isInfoEnabled()) {
594                            _log.info("Importing portlet takes " + stopWatch.getTime() + " ms");
595                    }
596    
597                    // Service portlet preferences
598    
599                    boolean importPortletSetup = importPortletControlsMap.get(
600                            PortletDataHandlerKeys.PORTLET_SETUP);
601    
602                    if (importPortletSetup) {
603                            try {
604                                    List<Element> serviceElements = rootElement.elements("service");
605    
606                                    for (Element serviceElement : serviceElements) {
607                                            Document serviceDocument = SAXReaderUtil.read(
608                                                    portletDataContext.getZipEntryAsString(
609                                                            serviceElement.attributeValue("path")));
610    
611                                            importServicePortletPreferences(
612                                                    portletDataContext, serviceDocument.getRootElement());
613                                    }
614                            }
615                            catch (DocumentException de) {
616                                    throw new SystemException(de);
617                            }
618                    }
619    
620                    ZipReader zipReader = portletDataContext.getZipReader();
621    
622                    zipReader.close();
623            }
624    
625            protected PortletDataContext getPortletDataContext(
626                            long userId, long plid, long groupId, String portletId,
627                            Map<String, String[]> parameterMap, File file)
628                    throws PortalException {
629    
630                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
631    
632                    String userIdStrategyString = MapUtil.getString(
633                            parameterMap, PortletDataHandlerKeys.USER_ID_STRATEGY);
634    
635                    UserIdStrategy userIdStrategy =
636                            ExportImportHelperUtil.getUserIdStrategy(
637                                    userId, userIdStrategyString);
638    
639                    ZipReader zipReader = ZipReaderFactoryUtil.getZipReader(file);
640    
641                    PortletDataContext portletDataContext =
642                            PortletDataContextFactoryUtil.createImportPortletDataContext(
643                                    layout.getCompanyId(), groupId, parameterMap, userIdStrategy,
644                                    zipReader);
645    
646                    portletDataContext.setOldPlid(plid);
647                    portletDataContext.setPlid(plid);
648                    portletDataContext.setPortletId(portletId);
649                    portletDataContext.setPrivateLayout(layout.isPrivateLayout());
650    
651                    return portletDataContext;
652            }
653    
654            protected PortletPreferences getPortletPreferences(
655                            long companyId, long ownerId, int ownerType, long plid,
656                            String serviceName)
657                    throws PortalException {
658    
659                    PortletPreferences portletPreferences = null;
660    
661                    try {
662                            if ((ownerType == PortletKeys.PREFS_OWNER_TYPE_ARCHIVED) ||
663                                    (ownerType == PortletKeys.PREFS_OWNER_TYPE_COMPANY) ||
664                                    (ownerType == PortletKeys.PREFS_OWNER_TYPE_GROUP)) {
665    
666                                    portletPreferences =
667                                            PortletPreferencesLocalServiceUtil.getPortletPreferences(
668                                                    ownerId, ownerType, LayoutConstants.DEFAULT_PLID,
669                                                    serviceName);
670                            }
671                            else {
672                                    portletPreferences =
673                                            PortletPreferencesLocalServiceUtil.getPortletPreferences(
674                                                    ownerId, ownerType, plid, serviceName);
675                            }
676                    }
677                    catch (NoSuchPortletPreferencesException nsppe) {
678                            portletPreferences =
679                                    PortletPreferencesLocalServiceUtil.addPortletPreferences(
680                                            companyId, ownerId, ownerType, plid, serviceName, null,
681                                            null);
682                    }
683    
684                    return portletPreferences;
685            }
686    
687            protected int getProcessFlag() {
688                    if (ExportImportThreadLocal.isPortletStagingInProcess()) {
689                            return PROCESS_FLAG_PORTLET_STAGING_IN_PROCESS;
690                    }
691    
692                    return PROCESS_FLAG_PORTLET_IMPORT_IN_PROCESS;
693            }
694    
695            protected void importPortletData(
696                            PortletDataContext portletDataContext, Element portletDataElement)
697                    throws Exception {
698    
699                    long ownerId = PortletKeys.PREFS_OWNER_ID_DEFAULT;
700                    int ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
701    
702                    PortletPreferences portletPreferences =
703                            PortletPreferencesUtil.fetchByO_O_P_P(
704                                    ownerId, ownerType, portletDataContext.getPlid(),
705                                    portletDataContext.getPortletId());
706    
707                    if (portletPreferences == null) {
708                            portletPreferences =
709                                    new com.liferay.portal.model.impl.PortletPreferencesImpl();
710                    }
711    
712                    String xml = importPortletData(
713                            portletDataContext, portletPreferences, portletDataElement);
714    
715                    if (Validator.isNotNull(xml)) {
716                            PortletPreferencesLocalServiceUtil.updatePreferences(
717                                    ownerId, ownerType, portletDataContext.getPlid(),
718                                    portletDataContext.getPortletId(), xml);
719                    }
720            }
721    
722            protected void importPortletPreferences(
723                            PortletDataContext portletDataContext, long companyId, long groupId,
724                            Layout layout, Element parentElement, boolean preserveScopeLayoutId,
725                            boolean importPortletArchivedSetups, boolean importPortletData,
726                            boolean importPortletSetup, boolean importPortletUserPreferences)
727                    throws Exception {
728    
729                    long plid = LayoutConstants.DEFAULT_PLID;
730                    String scopeType = StringPool.BLANK;
731                    String scopeLayoutUuid = StringPool.BLANK;
732    
733                    if (layout != null) {
734                            plid = layout.getPlid();
735    
736                            if (preserveScopeLayoutId) {
737                                    javax.portlet.PortletPreferences jxPortletPreferences =
738                                            PortletPreferencesFactoryUtil.getLayoutPortletSetup(
739                                                    layout, portletDataContext.getPortletId());
740    
741                                    scopeType = GetterUtil.getString(
742                                            jxPortletPreferences.getValue("lfrScopeType", null));
743                                    scopeLayoutUuid = GetterUtil.getString(
744                                            jxPortletPreferences.getValue("lfrScopeLayoutUuid", null));
745    
746                                    portletDataContext.setScopeType(scopeType);
747                                    portletDataContext.setScopeLayoutUuid(scopeLayoutUuid);
748                            }
749                    }
750    
751                    List<Element> portletPreferencesElements = parentElement.elements(
752                            "portlet-preferences");
753    
754                    for (Element portletPreferencesElement : portletPreferencesElements) {
755                            String path = portletPreferencesElement.attributeValue("path");
756    
757                            if (portletDataContext.isPathNotProcessed(path)) {
758                                    String xml = null;
759    
760                                    Element element = null;
761    
762                                    try {
763                                            xml = portletDataContext.getZipEntryAsString(path);
764    
765                                            Document preferencesDocument = SAXReaderUtil.read(xml);
766    
767                                            element = preferencesDocument.getRootElement();
768                                    }
769                                    catch (DocumentException de) {
770                                            throw new SystemException(de);
771                                    }
772    
773                                    long ownerId = GetterUtil.getLong(
774                                            element.attributeValue("owner-id"));
775                                    int ownerType = GetterUtil.getInteger(
776                                            element.attributeValue("owner-type"));
777    
778                                    if ((ownerType == PortletKeys.PREFS_OWNER_TYPE_COMPANY) ||
779                                            !importPortletSetup) {
780    
781                                            continue;
782                                    }
783    
784                                    if ((ownerType == PortletKeys.PREFS_OWNER_TYPE_ARCHIVED) &&
785                                            !importPortletArchivedSetups) {
786    
787                                            continue;
788                                    }
789    
790                                    if ((ownerType == PortletKeys.PREFS_OWNER_TYPE_USER) &&
791                                            (ownerId != PortletKeys.PREFS_OWNER_ID_DEFAULT) &&
792                                            !importPortletUserPreferences) {
793    
794                                            continue;
795                                    }
796    
797                                    long curPlid = plid;
798                                    String curPortletId = portletDataContext.getPortletId();
799    
800                                    if (ownerType == PortletKeys.PREFS_OWNER_TYPE_GROUP) {
801                                            curPlid = PortletKeys.PREFS_PLID_SHARED;
802                                            curPortletId = portletDataContext.getRootPortletId();
803                                            ownerId = portletDataContext.getScopeGroupId();
804                                    }
805    
806                                    if (ownerType == PortletKeys.PREFS_OWNER_TYPE_ARCHIVED) {
807                                            String userUuid = element.attributeValue(
808                                                    "archive-user-uuid");
809    
810                                            long userId = portletDataContext.getUserId(userUuid);
811    
812                                            String name = element.attributeValue("archive-name");
813    
814                                            curPortletId = portletDataContext.getRootPortletId();
815    
816                                            PortletItem portletItem =
817                                                    PortletItemLocalServiceUtil.updatePortletItem(
818                                                            userId, groupId, name, curPortletId,
819                                                            PortletPreferences.class.getName());
820    
821                                            curPlid = LayoutConstants.DEFAULT_PLID;
822                                            ownerId = portletItem.getPortletItemId();
823                                    }
824    
825                                    if (ownerType == PortletKeys.PREFS_OWNER_TYPE_USER) {
826                                            String userUuid = element.attributeValue("user-uuid");
827    
828                                            ownerId = portletDataContext.getUserId(userUuid);
829                                    }
830    
831                                    boolean defaultUser = GetterUtil.getBoolean(
832                                            element.attributeValue("default-user"));
833    
834                                    if (defaultUser) {
835                                            ownerId = UserLocalServiceUtil.getDefaultUserId(companyId);
836                                    }
837    
838                                    javax.portlet.PortletPreferences jxPortletPreferences =
839                                            PortletPreferencesFactoryUtil.fromXML(
840                                                    companyId, ownerId, ownerType, curPlid, curPortletId,
841                                                    xml);
842    
843                                    Element importDataRootElement =
844                                            portletDataContext.getImportDataRootElement();
845    
846                                    try {
847                                            Element preferenceDataElement =
848                                                    portletPreferencesElement.element("preference-data");
849    
850                                            if (preferenceDataElement != null) {
851                                                    portletDataContext.setImportDataRootElement(
852                                                            preferenceDataElement);
853                                            }
854    
855                                            Portlet portlet = PortletLocalServiceUtil.getPortletById(
856                                                    portletDataContext.getCompanyId(), curPortletId);
857    
858                                            PortletDataHandler portletDataHandler =
859                                                    portlet.getPortletDataHandlerInstance();
860    
861                                            jxPortletPreferences =
862                                                    portletDataHandler.processImportPortletPreferences(
863                                                            portletDataContext, curPortletId,
864                                                            jxPortletPreferences);
865                                    }
866                                    finally {
867                                            portletDataContext.setImportDataRootElement(
868                                                    importDataRootElement);
869                                    }
870    
871                                    updatePortletPreferences(
872                                            portletDataContext, ownerId, ownerType, curPlid,
873                                            curPortletId,
874                                            PortletPreferencesFactoryUtil.toXML(jxPortletPreferences),
875                                            importPortletData);
876                            }
877                    }
878    
879                    if (preserveScopeLayoutId && (layout != null)) {
880                            javax.portlet.PortletPreferences jxPortletPreferences =
881                                    PortletPreferencesFactoryUtil.getLayoutPortletSetup(
882                                            layout, portletDataContext.getPortletId());
883    
884                            try {
885                                    jxPortletPreferences.setValue("lfrScopeType", scopeType);
886                                    jxPortletPreferences.setValue(
887                                            "lfrScopeLayoutUuid", scopeLayoutUuid);
888    
889                                    jxPortletPreferences.store();
890                            }
891                            finally {
892                                    portletDataContext.setScopeType(scopeType);
893                                    portletDataContext.setScopeLayoutUuid(scopeLayoutUuid);
894                            }
895                    }
896            }
897    
898            protected void importServicePortletPreferences(
899                            PortletDataContext portletDataContext, Element serviceElement)
900                    throws PortalException {
901    
902                    long ownerId = GetterUtil.getLong(
903                            serviceElement.attributeValue("owner-id"));
904                    int ownerType = GetterUtil.getInteger(
905                            serviceElement.attributeValue("owner-type"));
906                    String serviceName = serviceElement.attributeValue("service-name");
907    
908                    PortletPreferences portletPreferences = getPortletPreferences(
909                            portletDataContext.getCompanyId(), ownerId, ownerType,
910                            LayoutConstants.DEFAULT_PLID, serviceName);
911    
912                    for (Attribute attribute : serviceElement.attributes()) {
913                            serviceElement.remove(attribute);
914                    }
915    
916                    String xml = serviceElement.asXML();
917    
918                    portletPreferences.setPreferences(xml);
919    
920                    PortletPreferencesLocalServiceUtil.updatePortletPreferences(
921                            portletPreferences);
922            }
923    
924            protected void populateDeletionStagedModelTypes(
925                            PortletDataContext portletDataContext)
926                    throws Exception {
927    
928                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
929                            portletDataContext.getCompanyId(),
930                            portletDataContext.getPortletId());
931    
932                    if ((portlet == null) || !portlet.isActive() ||
933                            portlet.isUndeployedPortlet()) {
934    
935                            return;
936                    }
937    
938                    PortletDataHandler portletDataHandler =
939                            portlet.getPortletDataHandlerInstance();
940    
941                    if (portletDataHandler == null) {
942                            return;
943                    }
944    
945                    portletDataContext.addDeletionSystemEventStagedModelTypes(
946                            portletDataHandler.getDeletionSystemEventStagedModelTypes());
947            }
948    
949            protected void readAssetLinks(PortletDataContext portletDataContext)
950                    throws Exception {
951    
952                    String xml = portletDataContext.getZipEntryAsString(
953                            ExportImportPathUtil.getSourceRootPath(portletDataContext) +
954                                    "/links.xml");
955    
956                    if (xml == null) {
957                            return;
958                    }
959    
960                    Document document = SAXReaderUtil.read(xml);
961    
962                    Element rootElement = document.getRootElement();
963    
964                    List<Element> assetLinkGroupElements = rootElement.elements(
965                            "asset-link-group");
966    
967                    for (Element assetLinkGroupElement : assetLinkGroupElements) {
968                            String sourceUuid = assetLinkGroupElement.attributeValue(
969                                    "source-uuid");
970    
971                            AssetEntry sourceAssetEntry = AssetEntryLocalServiceUtil.fetchEntry(
972                                    portletDataContext.getScopeGroupId(), sourceUuid);
973    
974                            if (sourceAssetEntry == null) {
975                                    sourceAssetEntry = AssetEntryLocalServiceUtil.fetchEntry(
976                                            portletDataContext.getCompanyGroupId(), sourceUuid);
977                            }
978    
979                            if (sourceAssetEntry == null) {
980                                    if (_log.isWarnEnabled()) {
981                                            _log.warn(
982                                                    "Unable to find asset entry with uuid " + sourceUuid);
983                                    }
984    
985                                    continue;
986                            }
987    
988                            List<Element> assetLinksElements = assetLinkGroupElement.elements(
989                                    "asset-link");
990    
991                            for (Element assetLinkElement : assetLinksElements) {
992                                    String path = assetLinkElement.attributeValue("path");
993    
994                                    if (!portletDataContext.isPathNotProcessed(path)) {
995                                            continue;
996                                    }
997    
998                                    String targetUuid = assetLinkElement.attributeValue(
999                                            "target-uuid");
1000    
1001                                    AssetEntry targetAssetEntry =
1002                                            AssetEntryLocalServiceUtil.fetchEntry(
1003                                                    portletDataContext.getScopeGroupId(), targetUuid);
1004    
1005                                    if (targetAssetEntry == null) {
1006                                            targetAssetEntry = AssetEntryLocalServiceUtil.fetchEntry(
1007                                                    portletDataContext.getCompanyGroupId(), targetUuid);
1008                                    }
1009    
1010                                    if (targetAssetEntry == null) {
1011                                            if (_log.isWarnEnabled()) {
1012                                                    _log.warn(
1013                                                            "Unable to find asset entry with uuid " +
1014                                                                    targetUuid);
1015                                            }
1016    
1017                                            continue;
1018                                    }
1019    
1020                                    AssetLink assetLink =
1021                                            (AssetLink)portletDataContext.getZipEntryAsObject(path);
1022    
1023                                    long userId = portletDataContext.getUserId(
1024                                            assetLink.getUserUuid());
1025    
1026                                    AssetLinkLocalServiceUtil.updateLink(
1027                                            userId, sourceAssetEntry.getEntryId(),
1028                                            targetAssetEntry.getEntryId(), assetLink.getType(),
1029                                            assetLink.getWeight());
1030                            }
1031                    }
1032            }
1033    
1034            protected void readExpandoTables(PortletDataContext portletDataContext)
1035                    throws Exception {
1036    
1037                    String xml = portletDataContext.getZipEntryAsString(
1038                            ExportImportPathUtil.getSourceRootPath(portletDataContext) +
1039                                    "/expando-tables.xml");
1040    
1041                    if (xml == null) {
1042                            return;
1043                    }
1044    
1045                    Document document = SAXReaderUtil.read(xml);
1046    
1047                    Element rootElement = document.getRootElement();
1048    
1049                    List<Element> expandoTableElements = rootElement.elements(
1050                            "expando-table");
1051    
1052                    for (Element expandoTableElement : expandoTableElements) {
1053                            String className = expandoTableElement.attributeValue("class-name");
1054    
1055                            ExpandoTable expandoTable = null;
1056    
1057                            try {
1058                                    expandoTable = ExpandoTableLocalServiceUtil.getDefaultTable(
1059                                            portletDataContext.getCompanyId(), className);
1060                            }
1061                            catch (NoSuchTableException nste) {
1062                                    expandoTable = ExpandoTableLocalServiceUtil.addDefaultTable(
1063                                            portletDataContext.getCompanyId(), className);
1064                            }
1065    
1066                            List<Element> expandoColumnElements = expandoTableElement.elements(
1067                                    "expando-column");
1068    
1069                            for (Element expandoColumnElement : expandoColumnElements) {
1070                                    long columnId = GetterUtil.getLong(
1071                                            expandoColumnElement.attributeValue("column-id"));
1072                                    String name = expandoColumnElement.attributeValue("name");
1073                                    int type = GetterUtil.getInteger(
1074                                            expandoColumnElement.attributeValue("type"));
1075                                    String defaultData = expandoColumnElement.elementText(
1076                                            "default-data");
1077                                    String typeSettings = expandoColumnElement.elementText(
1078                                            "type-settings");
1079    
1080                                    Serializable defaultDataObject =
1081                                            ExpandoConverterUtil.getAttributeFromString(
1082                                                    type, defaultData);
1083    
1084                                    ExpandoColumn expandoColumn =
1085                                            ExpandoColumnLocalServiceUtil.getColumn(
1086                                                    expandoTable.getTableId(), name);
1087    
1088                                    if (expandoColumn != null) {
1089                                            ExpandoColumnLocalServiceUtil.updateColumn(
1090                                                    expandoColumn.getColumnId(), name, type,
1091                                                    defaultDataObject);
1092                                    }
1093                                    else {
1094                                            expandoColumn = ExpandoColumnLocalServiceUtil.addColumn(
1095                                                    expandoTable.getTableId(), name, type,
1096                                                    defaultDataObject);
1097                                    }
1098    
1099                                    ExpandoColumnLocalServiceUtil.updateTypeSettings(
1100                                            expandoColumn.getColumnId(), typeSettings);
1101    
1102                                    portletDataContext.importPermissions(
1103                                            ExpandoColumn.class, columnId, expandoColumn.getColumnId());
1104                            }
1105                    }
1106            }
1107    
1108            protected void readLocks(PortletDataContext portletDataContext)
1109                    throws Exception {
1110    
1111                    String xml = portletDataContext.getZipEntryAsString(
1112                            ExportImportPathUtil.getSourceRootPath(portletDataContext) +
1113                                    "/locks.xml");
1114    
1115                    if (xml == null) {
1116                            return;
1117                    }
1118    
1119                    Document document = SAXReaderUtil.read(xml);
1120    
1121                    Element rootElement = document.getRootElement();
1122    
1123                    List<Element> assetElements = rootElement.elements("asset");
1124    
1125                    for (Element assetElement : assetElements) {
1126                            String path = assetElement.attributeValue("path");
1127                            String className = assetElement.attributeValue("class-name");
1128                            String key = assetElement.attributeValue("key");
1129    
1130                            Lock lock = (Lock)portletDataContext.getZipEntryAsObject(path);
1131    
1132                            if (lock != null) {
1133                                    portletDataContext.addLocks(className, key, lock);
1134                            }
1135                    }
1136            }
1137    
1138            protected void resetPortletScope(
1139                    PortletDataContext portletDataContext, long groupId) {
1140    
1141                    portletDataContext.setScopeGroupId(groupId);
1142                    portletDataContext.setScopeLayoutUuid(StringPool.BLANK);
1143                    portletDataContext.setScopeType(StringPool.BLANK);
1144            }
1145    
1146            protected void updatePortletPreferences(
1147                            PortletDataContext portletDataContext, long ownerId, int ownerType,
1148                            long plid, String portletId, String xml, boolean importData)
1149                    throws Exception {
1150    
1151                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
1152                            portletDataContext.getCompanyId(), portletId);
1153    
1154                    if (portlet == null) {
1155                            if (_log.isDebugEnabled()) {
1156                                    _log.debug(
1157                                            "Do not update portlet preferences for " + portletId +
1158                                                    " because the portlet does not exist");
1159                            }
1160    
1161                            return;
1162                    }
1163    
1164                    PortletDataHandler portletDataHandler =
1165                            portlet.getPortletDataHandlerInstance();
1166    
1167                    if (importData || !MergeLayoutPrototypesThreadLocal.isInProgress()) {
1168                            PortletPreferencesLocalServiceUtil.updatePreferences(
1169                                    ownerId, ownerType, plid, portletId, xml);
1170    
1171                            return;
1172                    }
1173    
1174                    // Portlet preferences to be updated only when importing data
1175    
1176                    String[] dataPortletPreferences =
1177                            portletDataHandler.getDataPortletPreferences();
1178    
1179                    // Current portlet preferences
1180    
1181                    javax.portlet.PortletPreferences portletPreferences =
1182                            PortletPreferencesLocalServiceUtil.getPreferences(
1183                                    portletDataContext.getCompanyId(), ownerId, ownerType, plid,
1184                                    portletId);
1185    
1186                    // New portlet preferences
1187    
1188                    javax.portlet.PortletPreferences jxPortletPreferences =
1189                            PortletPreferencesFactoryUtil.fromXML(
1190                                    portletDataContext.getCompanyId(), ownerId, ownerType, plid,
1191                                    portletId, xml);
1192    
1193                    Enumeration<String> enu = jxPortletPreferences.getNames();
1194    
1195                    while (enu.hasMoreElements()) {
1196                            String name = enu.nextElement();
1197    
1198                            String scopeLayoutUuid = portletDataContext.getScopeLayoutUuid();
1199                            String scopeType = portletDataContext.getScopeType();
1200    
1201                            if (!ArrayUtil.contains(dataPortletPreferences, name) ||
1202                                    (Validator.isNull(scopeLayoutUuid) &&
1203                                     scopeType.equals("company"))) {
1204    
1205                                    String[] values = jxPortletPreferences.getValues(name, null);
1206    
1207                                    portletPreferences.setValues(name, values);
1208                            }
1209                    }
1210    
1211                    PortletPreferencesLocalServiceUtil.updatePreferences(
1212                            ownerId, ownerType, plid, portletId, portletPreferences);
1213            }
1214    
1215            protected void validateFile(
1216                            long companyId, long groupId, String portletId, ZipReader zipReader)
1217                    throws Exception {
1218    
1219                    // XML
1220    
1221                    String xml = zipReader.getEntryAsString("/manifest.xml");
1222    
1223                    if (xml == null) {
1224                            throw new LARFileException("manifest.xml not found in the LAR");
1225                    }
1226    
1227                    Element rootElement = null;
1228    
1229                    try {
1230                            Document document = SAXReaderUtil.read(xml);
1231    
1232                            rootElement = document.getRootElement();
1233                    }
1234                    catch (Exception e) {
1235                            throw new LARFileException(e);
1236                    }
1237    
1238                    // Build compatibility
1239    
1240                    int buildNumber = ReleaseInfo.getBuildNumber();
1241    
1242                    Element headerElement = rootElement.element("header");
1243    
1244                    int importBuildNumber = GetterUtil.getInteger(
1245                            headerElement.attributeValue("build-number"));
1246    
1247                    if (buildNumber != importBuildNumber) {
1248                            throw new LayoutImportException(
1249                                    "LAR build number " + importBuildNumber + " does not match " +
1250                                            "portal build number " + buildNumber);
1251                    }
1252    
1253                    // Type
1254    
1255                    String larType = headerElement.attributeValue("type");
1256    
1257                    if (!larType.equals("portlet")) {
1258                            throw new LARTypeException(larType);
1259                    }
1260    
1261                    // Portlet compatibility
1262    
1263                    String rootPortletId = headerElement.attributeValue("root-portlet-id");
1264    
1265                    if (!PortletConstants.getRootPortletId(portletId).equals(
1266                                    rootPortletId)) {
1267    
1268                            throw new PortletIdException("Invalid portlet id " + rootPortletId);
1269                    }
1270    
1271                    // Available locales
1272    
1273                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
1274                            companyId, portletId);
1275    
1276                    PortletDataHandler portletDataHandler =
1277                            portlet.getPortletDataHandlerInstance();
1278    
1279                    if (portletDataHandler.isDataLocalized()) {
1280                            List<Locale> sourceAvailableLocales = Arrays.asList(
1281                                    LocaleUtil.fromLanguageIds(
1282                                            StringUtil.split(
1283                                                    headerElement.attributeValue("available-locales"))));
1284    
1285                            for (Locale sourceAvailableLocale : sourceAvailableLocales) {
1286                                    if (!LanguageUtil.isAvailableLocale(
1287                                                    PortalUtil.getSiteGroupId(groupId),
1288                                                    sourceAvailableLocale)) {
1289    
1290                                            LocaleException le = new LocaleException(
1291                                                    LocaleException.TYPE_EXPORT_IMPORT,
1292                                                    "Locale " + sourceAvailableLocale + " is not " +
1293                                                            "available in company " + companyId);
1294    
1295                                            le.setSourceAvailableLocales(sourceAvailableLocales);
1296                                            le.setTargetAvailableLocales(
1297                                                    LanguageUtil.getAvailableLocales(
1298                                                            PortalUtil.getSiteGroupId(groupId)));
1299    
1300                                            throw le;
1301                                    }
1302                            }
1303                    }
1304            }
1305    
1306            private PortletImporter() {
1307            }
1308    
1309            private static final Log _log = LogFactoryUtil.getLog(
1310                    PortletImporter.class);
1311    
1312            private static final PortletImporter _instance = new PortletImporter();
1313    
1314            private final DeletionSystemEventImporter _deletionSystemEventImporter =
1315                    DeletionSystemEventImporter.getInstance();
1316            private final PermissionImporter _permissionImporter =
1317                    PermissionImporter.getInstance();
1318    
1319    }