001    /**
002     * Copyright (c) 2000-2012 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.mobiledevicerules.lar;
016    
017    import com.liferay.portal.kernel.lar.BasePortletDataHandler;
018    import com.liferay.portal.kernel.lar.PortletDataContext;
019    import com.liferay.portal.kernel.lar.PortletDataHandlerBoolean;
020    import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
021    import com.liferay.portal.kernel.log.Log;
022    import com.liferay.portal.kernel.log.LogFactoryUtil;
023    import com.liferay.portal.kernel.util.GetterUtil;
024    import com.liferay.portal.kernel.util.StringBundler;
025    import com.liferay.portal.kernel.util.UnicodeProperties;
026    import com.liferay.portal.kernel.util.Validator;
027    import com.liferay.portal.kernel.xml.Document;
028    import com.liferay.portal.kernel.xml.Element;
029    import com.liferay.portal.kernel.xml.SAXReaderUtil;
030    import com.liferay.portal.mobile.device.rulegroup.action.impl.SiteRedirectActionHandler;
031    import com.liferay.portal.model.Layout;
032    import com.liferay.portal.model.LayoutSet;
033    import com.liferay.portal.service.LayoutLocalServiceUtil;
034    import com.liferay.portal.service.LayoutSetLocalServiceUtil;
035    import com.liferay.portal.service.ServiceContext;
036    import com.liferay.portal.util.PortletKeys;
037    import com.liferay.portlet.mobiledevicerules.model.MDRAction;
038    import com.liferay.portlet.mobiledevicerules.model.MDRRule;
039    import com.liferay.portlet.mobiledevicerules.model.MDRRuleGroup;
040    import com.liferay.portlet.mobiledevicerules.model.MDRRuleGroupInstance;
041    import com.liferay.portlet.mobiledevicerules.service.MDRActionLocalServiceUtil;
042    import com.liferay.portlet.mobiledevicerules.service.MDRRuleGroupInstanceLocalServiceUtil;
043    import com.liferay.portlet.mobiledevicerules.service.MDRRuleGroupLocalServiceUtil;
044    import com.liferay.portlet.mobiledevicerules.service.MDRRuleLocalServiceUtil;
045    import com.liferay.portlet.mobiledevicerules.service.persistence.MDRActionUtil;
046    import com.liferay.portlet.mobiledevicerules.service.persistence.MDRRuleGroupInstanceUtil;
047    import com.liferay.portlet.mobiledevicerules.service.persistence.MDRRuleGroupUtil;
048    import com.liferay.portlet.mobiledevicerules.service.persistence.MDRRuleUtil;
049    
050    import java.util.List;
051    import java.util.Map;
052    
053    import javax.portlet.PortletPreferences;
054    
055    /**
056     * @author Michael C. Han
057     * @author Brian Wing Shun Chan
058     */
059    public class MDRPortletDataHandler extends BasePortletDataHandler {
060    
061            public static final String NAMESPACE = "mobile_device_rules";
062    
063            public MDRPortletDataHandler() {
064                    setAlwaysExportable(true);
065                    setAlwaysStaged(true);
066                    setExportControls(
067                            new PortletDataHandlerBoolean(NAMESPACE, "rule-groups", true, true),
068                            new PortletDataHandlerBoolean(
069                                    NAMESPACE, "rule-group-instances", true, true));
070                    setImportControls(new PortletDataHandlerControl[0]);
071                    setPublishToLiveByDefault(true);
072            }
073    
074            @Override
075            protected PortletPreferences doDeleteData(
076                            PortletDataContext portletDataContext, String portletId,
077                            PortletPreferences portletPreferences)
078                    throws Exception {
079    
080                    if (portletDataContext.addPrimaryKey(
081                                    MDRPortletDataHandler.class, "deleteData")) {
082    
083                            return portletPreferences;
084                    }
085    
086                    MDRRuleGroupInstanceLocalServiceUtil.deleteGroupRuleGroupInstances(
087                            portletDataContext.getScopeGroupId());
088    
089                    MDRRuleGroupLocalServiceUtil.deleteRuleGroups(
090                            portletDataContext.getGroupId());
091    
092                    return portletPreferences;
093            }
094    
095            @Override
096            protected String doExportData(
097                            PortletDataContext portletDataContext, String portletId,
098                            PortletPreferences portletPreferences)
099                    throws Exception {
100    
101                    portletDataContext.addPermissions(
102                            "com.liferay.portlet.mobiledevicerules",
103                            portletDataContext.getScopeGroupId());
104    
105                    Element rootElement = addExportRootElement();
106    
107                    Element ruleGroupsElement = rootElement.addElement("rule-groups");
108    
109                    List<MDRRuleGroup> ruleGroups = MDRRuleGroupUtil.findByGroupId(
110                            portletDataContext.getGroupId());
111    
112                    for (MDRRuleGroup ruleGroup : ruleGroups) {
113                            exportRuleGroup(portletDataContext, ruleGroupsElement, ruleGroup);
114                    }
115    
116                    Element ruleGroupInstancesElement = rootElement.addElement(
117                            "rule-group-instances");
118    
119                    List<MDRRuleGroupInstance> ruleGroupInstances =
120                            MDRRuleGroupInstanceUtil.findByGroupId(
121                                    portletDataContext.getScopeGroupId());
122    
123                    for (MDRRuleGroupInstance ruleGroupInstance : ruleGroupInstances) {
124                            exportRuleGroupInstance(
125                                    portletDataContext, ruleGroupInstancesElement,
126                                    ruleGroupInstance);
127                    }
128    
129                    return rootElement.formattedString();
130            }
131    
132            @Override
133            protected PortletPreferences doImportData(
134                            PortletDataContext portletDataContext, String portletId,
135                            PortletPreferences portletPreferences, String data)
136                    throws Exception {
137    
138                    portletDataContext.importPermissions(
139                            "com.liferay.portlet.mobiledevicerules",
140                            portletDataContext.getSourceGroupId(),
141                            portletDataContext.getScopeGroupId());
142    
143                    Document document = SAXReaderUtil.read(data);
144    
145                    Element rootElement = document.getRootElement();
146    
147                    Element ruleGroupsElement = rootElement.element("rule-groups");
148    
149                    List<Element> ruleGroupElements = ruleGroupsElement.elements(
150                            "rule-group");
151    
152                    for (Element ruleGroupElement : ruleGroupElements) {
153                            String path = ruleGroupElement.attributeValue("path");
154    
155                            if (!portletDataContext.isPathNotProcessed(path)) {
156                                    continue;
157                            }
158    
159                            MDRRuleGroup ruleGroup =
160                                    (MDRRuleGroup)portletDataContext.getZipEntryAsObject(path);
161    
162                            importRuleGroup(portletDataContext, ruleGroupElement, ruleGroup);
163                    }
164    
165                    Element ruleGroupInstancesElement = rootElement.element(
166                            "rule-group-instances");
167    
168                    List<Element> ruleGroupInstanceElements =
169                            ruleGroupInstancesElement.elements("rule-group-instance");
170    
171                    for (Element ruleGroupInstanceElement : ruleGroupInstanceElements) {
172                            String path = ruleGroupInstanceElement.attributeValue("path");
173    
174                            if (!portletDataContext.isPathNotProcessed(path)) {
175                                    continue;
176                            }
177    
178                            MDRRuleGroupInstance ruleGroupInstance =
179                                    (MDRRuleGroupInstance)portletDataContext.getZipEntryAsObject(
180                                            path);
181    
182                            importRuleGroupInstance(
183                                    portletDataContext, ruleGroupInstanceElement,
184                                    ruleGroupInstance);
185                    }
186    
187                    return null;
188            }
189    
190            protected void exportAction(
191                            PortletDataContext portletDataContext, Element actionsElement,
192                            MDRAction action)
193                    throws Exception {
194    
195                    String path = getActionPath(portletDataContext, action);
196    
197                    if (!portletDataContext.isPathNotProcessed(path)) {
198                            return;
199                    }
200    
201                    Element actionElement = actionsElement.addElement("action");
202    
203                    String type = action.getType();
204    
205                    if (type.equals(SiteRedirectActionHandler.class.getName())) {
206                            UnicodeProperties typeSettingsProperties =
207                                    action.getTypeSettingsProperties();
208    
209                            long targetPlid = GetterUtil.getLong(
210                                    typeSettingsProperties.getProperty("plid"));
211    
212                            try {
213                                    Layout targetLayout = LayoutLocalServiceUtil.getLayout(
214                                            targetPlid);
215    
216                                    actionElement.addAttribute(
217                                            "layout-uuid", targetLayout.getUuid());
218                            }
219                            catch (Exception e) {
220                                    if (_log.isWarnEnabled()) {
221                                            _log.warn(
222                                                    "Unable to set the layout uuid of the target " +
223                                                            targetPlid +
224                                                                    ". Site redirect may not match after import.",
225                                                    e);
226                                    }
227                            }
228                    }
229    
230                    portletDataContext.addClassedModel(
231                            actionElement, path, action, NAMESPACE);
232            }
233    
234            protected void exportRule(
235                            PortletDataContext portletDataContext, Element rulesElement,
236                            MDRRule rule)
237                    throws Exception {
238    
239                    String path = getRulePath(portletDataContext, rule);
240    
241                    if (!portletDataContext.isPathNotProcessed(path)) {
242                            return;
243                    }
244    
245                    Element ruleElement = rulesElement.addElement("rule");
246    
247                    portletDataContext.addClassedModel(ruleElement, path, rule, NAMESPACE);
248            }
249    
250            protected void exportRuleGroup(
251                            PortletDataContext portletDataContext, Element ruleGroupsElement,
252                            MDRRuleGroup ruleGroup)
253                    throws Exception {
254    
255                    if (!portletDataContext.isWithinDateRange(
256                                    ruleGroup.getModifiedDate())) {
257    
258                            return;
259                    }
260    
261                    String path = getRuleGroupPath(portletDataContext, ruleGroup);
262    
263                    if (!portletDataContext.isPathNotProcessed(path)) {
264                            return;
265                    }
266    
267                    Element ruleGroupElement = ruleGroupsElement.addElement("rule-group");
268    
269                    portletDataContext.addClassedModel(
270                            ruleGroupElement, path, ruleGroup, NAMESPACE);
271    
272                    Element mdrRulesElement = ruleGroupElement.addElement("rules");
273    
274                    List<MDRRule> rules = ruleGroup.getRules();
275    
276                    for (MDRRule rule : rules) {
277                            exportRule(portletDataContext, mdrRulesElement, rule);
278                    }
279            }
280    
281            protected void exportRuleGroupInstance(
282                            PortletDataContext portletDataContext,
283                            Element ruleGroupInstancesElement,
284                            MDRRuleGroupInstance ruleGroupInstance)
285                    throws Exception {
286    
287                    if (!portletDataContext.isWithinDateRange(
288                                    ruleGroupInstance.getModifiedDate())) {
289    
290                            return;
291                    }
292    
293                    String path = getRuleGroupInstancePath(
294                            portletDataContext, ruleGroupInstance);
295    
296                    if (!portletDataContext.isPathNotProcessed(path)) {
297                            return;
298                    }
299    
300                    Element ruleGroupInstanceElement = ruleGroupInstancesElement.addElement(
301                            "rule-group-instance");
302    
303                    MDRRuleGroup ruleGroup = ruleGroupInstance.getRuleGroup();
304    
305                    String className = ruleGroupInstance.getClassName();
306    
307                    if (className.equals(Layout.class.getName())) {
308                            Layout layout = LayoutLocalServiceUtil.getLayout(
309                                    ruleGroupInstance.getClassPK());
310    
311                            ruleGroupInstanceElement.addAttribute(
312                                    "layout-uuid", layout.getUuid());
313                    }
314    
315                    String ruleGroupUuid = ruleGroup.getUuid();
316    
317                    ruleGroupInstanceElement.addAttribute("rule-group-uuid", ruleGroupUuid);
318    
319                    portletDataContext.addClassedModel(
320                            ruleGroupInstanceElement, path, ruleGroupInstance, NAMESPACE);
321    
322                    Element actionsElement = ruleGroupInstanceElement.addElement("actions");
323    
324                    List<MDRAction> actions = ruleGroupInstance.getActions();
325    
326                    for (MDRAction action : actions) {
327                            exportAction(portletDataContext, actionsElement, action);
328                    }
329            }
330    
331            protected String getActionPath(
332                    PortletDataContext portletDataContext, MDRAction action) {
333    
334                    StringBundler sb = new StringBundler(4);
335    
336                    sb.append(
337                            portletDataContext.getPortletPath(
338                                    PortletKeys.MOBILE_DEVICE_SITE_ADMIN));
339                    sb.append("/actions/");
340                    sb.append(action.getActionId());
341                    sb.append(".xml");
342    
343                    return sb.toString();
344            }
345    
346            protected String getRuleGroupInstancePath(
347                    PortletDataContext portletDataContext,
348                    MDRRuleGroupInstance ruleGroupInstance) {
349    
350                    StringBundler sb = new StringBundler(4);
351    
352                    sb.append(
353                            portletDataContext.getPortletPath(
354                                    PortletKeys.MOBILE_DEVICE_SITE_ADMIN));
355                    sb.append("/rule-group-instances/");
356                    sb.append(ruleGroupInstance.getRuleGroupInstanceId());
357                    sb.append(".xml");
358    
359                    return sb.toString();
360            }
361    
362            protected String getRuleGroupPath(
363                    PortletDataContext portletDataContext, MDRRuleGroup ruleGroup) {
364    
365                    StringBundler sb = new StringBundler(4);
366    
367                    sb.append(
368                            portletDataContext.getPortletPath(
369                                    PortletKeys.MOBILE_DEVICE_SITE_ADMIN));
370                    sb.append("/rule-groups/");
371                    sb.append(ruleGroup.getRuleGroupId());
372                    sb.append(".xml");
373    
374                    return sb.toString();
375            }
376    
377            protected String getRulePath(
378                    PortletDataContext portletDataContext, MDRRule rule) {
379    
380                    StringBundler sb = new StringBundler(4);
381    
382                    sb.append(
383                            portletDataContext.getPortletPath(
384                                    PortletKeys.MOBILE_DEVICE_SITE_ADMIN));
385                    sb.append("/rules/");
386                    sb.append(rule.getRuleId());
387                    sb.append(".xml");
388    
389                    return sb.toString();
390            }
391    
392            protected void importAction(
393                            PortletDataContext portletDataContext, Element actionElement,
394                            MDRRuleGroupInstance ruleGroupInstance, MDRAction action)
395                    throws Exception {
396    
397                    long userId = portletDataContext.getUserId(action.getUserUuid());
398    
399                    ServiceContext serviceContext = portletDataContext.createServiceContext(
400                            actionElement, action, NAMESPACE);
401    
402                    serviceContext.setUserId(userId);
403    
404                    validateTargetLayoutPlid(actionElement, action);
405    
406                    MDRAction importedAction = null;
407    
408                    if (portletDataContext.isDataStrategyMirror()) {
409                            MDRAction existingAction = MDRActionUtil.fetchByUUID_G(
410                                    action.getUuid(), portletDataContext.getScopeGroupId());
411    
412                            if (existingAction == null) {
413                                    serviceContext.setUuid(action.getUuid());
414    
415                                    importedAction = MDRActionLocalServiceUtil.addAction(
416                                            ruleGroupInstance.getRuleGroupInstanceId(),
417                                            action.getNameMap(), action.getDescriptionMap(),
418                                            action.getType(), action.getTypeSettingsProperties(),
419                                            serviceContext);
420                            }
421                            else {
422                                    importedAction = MDRActionLocalServiceUtil.updateAction(
423                                            existingAction.getActionId(), action.getNameMap(),
424                                            action.getDescriptionMap(), action.getType(),
425                                            action.getTypeSettingsProperties(), serviceContext);
426                            }
427                    }
428                    else {
429                            importedAction = MDRActionLocalServiceUtil.addAction(
430                                    ruleGroupInstance.getRuleGroupInstanceId(), action.getNameMap(),
431                                    action.getDescriptionMap(), action.getType(),
432                                    action.getTypeSettingsProperties(), serviceContext);
433                    }
434    
435                    portletDataContext.importClassedModel(
436                            action, importedAction, NAMESPACE);
437            }
438    
439            protected void importRule(
440                            PortletDataContext portletDataContext, Element ruleElement,
441                            MDRRuleGroup ruleGroup, MDRRule rule)
442                    throws Exception {
443    
444                    long userId = portletDataContext.getUserId(rule.getUserUuid());
445    
446                    ServiceContext serviceContext = portletDataContext.createServiceContext(
447                            ruleElement, rule, NAMESPACE);
448    
449                    serviceContext.setUserId(userId);
450    
451                    MDRRule importedRule = null;
452    
453                    if (portletDataContext.isDataStrategyMirror()) {
454                            MDRRule existingRule = MDRRuleUtil.fetchByUUID_G(
455                                    rule.getUuid(), portletDataContext.getScopeGroupId());
456    
457                            if (existingRule == null) {
458                                    serviceContext.setUuid(rule.getUuid());
459    
460                                    importedRule = MDRRuleLocalServiceUtil.addRule(
461                                            ruleGroup.getRuleGroupId(), rule.getNameMap(),
462                                            rule.getDescriptionMap(), rule.getType(),
463                                            rule.getTypeSettingsProperties(), serviceContext);
464                            }
465                            else {
466                                    importedRule = MDRRuleLocalServiceUtil.updateRule(
467                                            existingRule.getRuleId(), rule.getNameMap(),
468                                            rule.getDescriptionMap(), rule.getType(),
469                                            rule.getTypeSettingsProperties(), serviceContext);
470                            }
471                    }
472                    else {
473                            importedRule = MDRRuleLocalServiceUtil.addRule(
474                                    ruleGroup.getRuleGroupId(), rule.getNameMap(),
475                                    rule.getDescriptionMap(), rule.getType(),
476                                    rule.getTypeSettingsProperties(), serviceContext);
477                    }
478    
479                    portletDataContext.importClassedModel(rule, importedRule, NAMESPACE);
480            }
481    
482            protected void importRuleGroup(
483                            PortletDataContext portletDataContext, Element ruleGroupElement,
484                            MDRRuleGroup ruleGroup)
485                    throws Exception {
486    
487                    long userId = portletDataContext.getUserId(ruleGroup.getUserUuid());
488    
489                    ServiceContext serviceContext = portletDataContext.createServiceContext(
490                            ruleGroupElement, ruleGroup, NAMESPACE);
491    
492                    serviceContext.setUserId(userId);
493    
494                    MDRRuleGroup importedRuleGroup = null;
495    
496                    if (portletDataContext.isDataStrategyMirror()) {
497                            MDRRuleGroup existingRuleGroup = MDRRuleGroupUtil.fetchByUUID_G(
498                                    ruleGroup.getUuid(), portletDataContext.getScopeGroupId());
499    
500                            if (existingRuleGroup == null) {
501                                    serviceContext.setUuid(ruleGroup.getUuid());
502    
503                                    importedRuleGroup = MDRRuleGroupLocalServiceUtil.addRuleGroup(
504                                            portletDataContext.getScopeGroupId(),
505                                            ruleGroup.getNameMap(), ruleGroup.getDescriptionMap(),
506                                            serviceContext);
507                            }
508                            else {
509                                    importedRuleGroup =
510                                            MDRRuleGroupLocalServiceUtil.updateRuleGroup(
511                                                    existingRuleGroup.getRuleGroupId(),
512                                                    ruleGroup.getNameMap(), ruleGroup.getDescriptionMap(),
513                                                    serviceContext);
514                            }
515                    }
516                    else {
517                            importedRuleGroup = MDRRuleGroupLocalServiceUtil.addRuleGroup(
518                                    portletDataContext.getScopeGroupId(), ruleGroup.getNameMap(),
519                                    ruleGroup.getDescriptionMap(), serviceContext);
520                    }
521    
522                    portletDataContext.importClassedModel(
523                            ruleGroup, importedRuleGroup, NAMESPACE);
524    
525                    Element rulesElement = ruleGroupElement.element("rules");
526    
527                    List<Element> ruleElements = rulesElement.elements("rule");
528    
529                    for (Element ruleElement : ruleElements) {
530                            String path = ruleElement.attributeValue("path");
531    
532                            if (!portletDataContext.isPathNotProcessed(path)) {
533                                    continue;
534                            }
535    
536                            MDRRule rule = (MDRRule)portletDataContext.getZipEntryAsObject(
537                                    path);
538    
539                            importRule(
540                                    portletDataContext, ruleElement, importedRuleGroup, rule);
541                    }
542            }
543    
544            protected void importRuleGroupInstance(
545                            PortletDataContext portletDataContext,
546                            Element ruleGroupInstanceElement,
547                            MDRRuleGroupInstance ruleGroupInstance)
548                    throws Exception {
549    
550                    long userId = portletDataContext.getUserId(
551                            ruleGroupInstance.getUserUuid());
552    
553                    Map<Long, Long> ruleGroupIds =
554                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
555                                    MDRRuleGroup.class);
556    
557                    Long ruleGroupId = ruleGroupIds.get(ruleGroupInstance.getRuleGroupId());
558    
559                    if (ruleGroupId == null) {
560                            try {
561                                    String ruleGroupUuid = ruleGroupInstanceElement.attributeValue(
562                                            "rule-group-uuid");
563    
564                                    MDRRuleGroup ruleGroup = MDRRuleGroupUtil.fetchByUUID_G(
565                                            ruleGroupUuid, portletDataContext.getScopeGroupId());
566    
567                                    ruleGroupId = ruleGroup.getRuleGroupId();
568                            }
569                            catch (Exception e) {
570                                    if (_log.isErrorEnabled()) {
571                                            _log.warn(
572                                                    "Unable to import rule group instance " +
573                                                            ruleGroupInstance,
574                                                    e);
575                                    }
576    
577                                    return;
578                            }
579                    }
580    
581                    long classPK = 0;
582    
583                    String layoutUuid = ruleGroupInstanceElement.attributeValue(
584                            "layout-uuid");
585    
586                    try {
587                            if (Validator.isNotNull(layoutUuid)) {
588                                    Layout layout =
589                                            LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
590                                                    layoutUuid, portletDataContext.getScopeGroupId(),
591                                                    portletDataContext.isPrivateLayout());
592    
593                                    classPK = layout.getPrimaryKey();
594                            }
595                            else {
596                                    LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
597                                            portletDataContext.getScopeGroupId(),
598                                            portletDataContext.isPrivateLayout());
599    
600                                    classPK = layoutSet.getLayoutSetId();
601                            }
602                    }
603                    catch (Exception e) {
604                            if (_log.isWarnEnabled()) {
605                                    StringBundler sb = new StringBundler(5);
606    
607                                    sb.append("Layout ");
608                                    sb.append(layoutUuid);
609                                    sb.append(" is missing for rule group instance ");
610                                    sb.append(ruleGroupInstance.getRuleGroupInstanceId());
611                                    sb.append(", skipping this rule group instance.");
612    
613                                    _log.warn(sb.toString());
614                            }
615    
616                            return;
617                    }
618    
619                    ServiceContext serviceContext = portletDataContext.createServiceContext(
620                            ruleGroupInstanceElement, ruleGroupInstance, NAMESPACE);
621    
622                    serviceContext.setUserId(userId);
623    
624                    MDRRuleGroupInstance importedRuleGroupInstance = null;
625    
626                    if (portletDataContext.isDataStrategyMirror()) {
627                            MDRRuleGroupInstance existingMDRRuleGroupInstance =
628                                    MDRRuleGroupInstanceUtil.fetchByUUID_G(
629                                            ruleGroupInstance.getUuid(),
630                                            portletDataContext.getScopeGroupId());
631    
632                            if (existingMDRRuleGroupInstance == null) {
633                                    serviceContext.setUuid(ruleGroupInstance.getUuid());
634    
635                                    importedRuleGroupInstance =
636                                            MDRRuleGroupInstanceLocalServiceUtil.addRuleGroupInstance(
637                                                    portletDataContext.getScopeGroupId(),
638                                                    ruleGroupInstance.getClassName(), classPK, ruleGroupId,
639                                                    ruleGroupInstance.getPriority(), serviceContext);
640                            }
641                            else {
642                                    importedRuleGroupInstance =
643                                            MDRRuleGroupInstanceLocalServiceUtil.
644                                                    updateRuleGroupInstance(
645                                                            existingMDRRuleGroupInstance.
646                                                                    getRuleGroupInstanceId(),
647                                                            ruleGroupInstance.getPriority());
648                            }
649                    }
650                    else {
651                            importedRuleGroupInstance =
652                                    MDRRuleGroupInstanceLocalServiceUtil.addRuleGroupInstance(
653                                            portletDataContext.getScopeGroupId(),
654                                            ruleGroupInstance.getClassName(), classPK, ruleGroupId,
655                                            ruleGroupInstance.getPriority(), serviceContext);
656                    }
657    
658                    portletDataContext.importClassedModel(
659                            ruleGroupInstance, importedRuleGroupInstance, NAMESPACE);
660    
661                    Element actionsElement = ruleGroupInstanceElement.element("actions");
662    
663                    List<Element> actionElements = actionsElement.elements("action");
664    
665                    for (Element actionElement : actionElements) {
666                            String path = actionElement.attributeValue("path");
667    
668                            if (!portletDataContext.isPathNotProcessed(path)) {
669                                    continue;
670                            }
671    
672                            MDRAction action =
673                                    (MDRAction)portletDataContext.getZipEntryAsObject(path);
674    
675                            importAction(
676                                    portletDataContext, actionElement, importedRuleGroupInstance,
677                                    action);
678                    }
679            }
680    
681            protected void validateTargetLayoutPlid(
682                    Element actionElement, MDRAction action) {
683    
684                    String type = action.getType();
685    
686                    if (!type.equals(SiteRedirectActionHandler.class.getName())) {
687                            return;
688                    }
689    
690                    String targetLayoutUuid = actionElement.attributeValue("layout-uuid");
691    
692                    if (Validator.isNull(targetLayoutUuid)) {
693                            return;
694                    }
695    
696                    UnicodeProperties typeSettingsProperties =
697                            action.getTypeSettingsProperties();
698    
699                    long targetGroupId = GetterUtil.getLong(
700                            typeSettingsProperties.getProperty("groupId"));
701                    boolean privateLayout = GetterUtil.getBoolean(
702                            actionElement.attributeValue("private-layout"));
703    
704                    try {
705                            Layout targetLayout =
706                                    LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
707                                            targetLayoutUuid, targetGroupId, privateLayout);
708    
709                            typeSettingsProperties.setProperty(
710                                    "plid", String.valueOf(targetLayout.getPlid()));
711                    }
712                    catch (Exception e) {
713                            if (_log.isWarnEnabled()) {
714                                    _log.warn(
715                                            "Unable to find target layout with uuid " +
716                                                    targetLayoutUuid + " in group " + targetGroupId +
717                                                            ". Site redirect may not match target layout.",
718                                            e);
719                            }
720                    }
721            }
722    
723            private static Log _log = LogFactoryUtil.getLog(
724                    MDRPortletDataHandler.class);
725    
726    }