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 aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.spring.orm.LastSessionRecorderHelperUtil;
021    import com.liferay.portal.kernel.util.GetterUtil;
022    import com.liferay.portal.kernel.util.StringPool;
023    import com.liferay.portal.kernel.util.Validator;
024    import com.liferay.portal.kernel.xml.Attribute;
025    import com.liferay.portal.kernel.xml.Element;
026    import com.liferay.portal.model.Portlet;
027    import com.liferay.portal.model.StagedModel;
028    import com.liferay.portal.model.TypedModel;
029    import com.liferay.portal.service.PortletLocalServiceUtil;
030    import com.liferay.portal.util.PortalUtil;
031    
032    import java.util.Collections;
033    import java.util.List;
034    import java.util.Map;
035    
036    /**
037     * @author Brian Wing Shun Chan
038     * @author Mate Thurzo
039     */
040    @ProviderType
041    public class StagedModelDataHandlerUtil {
042    
043            public static void deleteStagedModel(
044                            PortletDataContext portletDataContext, Element deletionElement)
045                    throws PortalException {
046    
047                    String className = deletionElement.attributeValue("class-name");
048                    String extraData = deletionElement.attributeValue("extra-data");
049                    String uuid = deletionElement.attributeValue("uuid");
050    
051                    StagedModelDataHandler<?> stagedModelDataHandler =
052                            StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
053                                    className);
054    
055                    if (stagedModelDataHandler != null) {
056                            stagedModelDataHandler.deleteStagedModel(
057                                    uuid, portletDataContext.getScopeGroupId(), className,
058                                    extraData);
059                    }
060            }
061    
062            public static <T extends StagedModel> Element exportReferenceStagedModel(
063                            PortletDataContext portletDataContext, String referrerPortletId,
064                            T stagedModel)
065                    throws PortletDataException {
066    
067                    Portlet referrerPortlet = PortletLocalServiceUtil.getPortletById(
068                            referrerPortletId);
069    
070                    if (!ExportImportHelperUtil.isReferenceWithinExportScope(
071                                    portletDataContext, stagedModel)) {
072    
073                            return portletDataContext.addReferenceElement(
074                                    referrerPortlet, portletDataContext.getExportDataRootElement(),
075                                    stagedModel, PortletDataContext.REFERENCE_TYPE_DEPENDENCY,
076                                    true);
077                    }
078    
079                    exportStagedModel(portletDataContext, stagedModel);
080    
081                    return portletDataContext.addReferenceElement(
082                            referrerPortlet, portletDataContext.getExportDataRootElement(),
083                            stagedModel, PortletDataContext.REFERENCE_TYPE_DEPENDENCY, false);
084            }
085    
086            /**
087             * @deprecated As of 7.0.0, replaced by {@link
088             *             #exportReferenceStagedModel(PortletDataContext, StagedModel,
089             *             StagedModel, String)}
090             */
091            @Deprecated
092            public static <T extends StagedModel, U extends StagedModel> Element
093                            exportReferenceStagedModel(
094                                    PortletDataContext portletDataContext, T referrerStagedModel,
095                                    Class<?> referrerStagedModelClass, U stagedModel,
096                                    Class<?> stagedModelClass, String referenceType)
097                    throws PortletDataException {
098    
099                    return exportReferenceStagedModel(
100                            portletDataContext, referrerStagedModel, stagedModel,
101                            referenceType);
102            }
103    
104            /**
105             * @deprecated As of 7.0.0, replaced by {@link
106             *             #exportReferenceStagedModel(PortletDataContext, StagedModel,
107             *             StagedModel, String)}
108             */
109            @Deprecated
110            public static <T extends StagedModel, U extends StagedModel> Element
111                            exportReferenceStagedModel(
112                                    PortletDataContext portletDataContext, T referrerStagedModel,
113                                    Element referrerStagedModelElement, U stagedModel,
114                                    Class<?> stagedModelClass, String referenceType)
115                    throws PortletDataException {
116    
117                    return exportReferenceStagedModel(
118                            portletDataContext, referrerStagedModel, stagedModel,
119                            referenceType);
120            }
121    
122            public static <T extends StagedModel, U extends StagedModel> Element
123                            exportReferenceStagedModel(
124                                    PortletDataContext portletDataContext, T referrerStagedModel,
125                                    U stagedModel, String referenceType)
126                    throws PortletDataException {
127    
128                    Element referrerStagedModelElement =
129                            portletDataContext.getExportDataElement(referrerStagedModel);
130    
131                    if (!ExportImportHelperUtil.isReferenceWithinExportScope(
132                                    portletDataContext, stagedModel)) {
133    
134                            return portletDataContext.addReferenceElement(
135                                    referrerStagedModel, referrerStagedModelElement, stagedModel,
136                                    PortletDataContext.REFERENCE_TYPE_DEPENDENCY, true);
137                    }
138    
139                    exportStagedModel(portletDataContext, stagedModel);
140    
141                    return portletDataContext.addReferenceElement(
142                            referrerStagedModel, referrerStagedModelElement, stagedModel,
143                            referenceType, false);
144            }
145    
146            public static <T extends StagedModel> void exportStagedModel(
147                            PortletDataContext portletDataContext, T stagedModel)
148                    throws PortletDataException {
149    
150                    StagedModelDataHandler<T> stagedModelDataHandler =
151                            _getStagedModelDataHandler(stagedModel);
152    
153                    if (stagedModelDataHandler == null) {
154                            return;
155                    }
156    
157                    stagedModelDataHandler.exportStagedModel(
158                            portletDataContext, stagedModel);
159            }
160    
161            public static <T extends StagedModel> String getDisplayName(T stagedModel) {
162                    StagedModelDataHandler<T> stagedModelDataHandler =
163                            _getStagedModelDataHandler(stagedModel);
164    
165                    if (stagedModelDataHandler == null) {
166                            return StringPool.BLANK;
167                    }
168    
169                    return stagedModelDataHandler.getDisplayName(stagedModel);
170            }
171    
172            public static Map<String, String> getReferenceAttributes(
173                    PortletDataContext portletDataContext, StagedModel stagedModel) {
174    
175                    StagedModelDataHandler<StagedModel> stagedModelDataHandler =
176                            _getStagedModelDataHandler(stagedModel);
177    
178                    if (stagedModelDataHandler == null) {
179                            return Collections.emptyMap();
180                    }
181    
182                    return stagedModelDataHandler.getReferenceAttributes(
183                            portletDataContext, stagedModel);
184            }
185    
186            public static <T extends StagedModel> void importReferenceStagedModel(
187                            PortletDataContext portletDataContext, T referrerStagedModel,
188                            Class<?> stagedModelClass, long classPK)
189                    throws PortletDataException {
190    
191                    importReferenceStagedModel(
192                            portletDataContext, referrerStagedModel, stagedModelClass.getName(),
193                            classPK);
194            }
195    
196            public static <T extends StagedModel> void importReferenceStagedModel(
197                            PortletDataContext portletDataContext, T referrerStagedModel,
198                            String stagedModelClassName, long classPK)
199                    throws PortletDataException {
200    
201                    Element referenceElement = portletDataContext.getReferenceElement(
202                            referrerStagedModel, stagedModelClassName, classPK);
203    
204                    if (referenceElement == null) {
205                            return;
206                    }
207    
208                    boolean missing = GetterUtil.getBoolean(
209                            referenceElement.attributeValue("missing"));
210    
211                    StagedModelDataHandler<?> stagedModelDataHandler =
212                            StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
213                                    stagedModelClassName);
214    
215                    if (stagedModelDataHandler == null) {
216                            return;
217                    }
218    
219                    if (missing) {
220                            stagedModelDataHandler.importMissingReference(
221                                    portletDataContext, referenceElement);
222    
223                            return;
224                    }
225    
226                    importStagedModel(portletDataContext, referenceElement);
227            }
228    
229            public static void importReferenceStagedModels(
230                            PortletDataContext portletDataContext, Class<?> stagedModelClass)
231                    throws PortletDataException {
232    
233                    Element importDataRootElement =
234                            portletDataContext.getImportDataRootElement();
235    
236                    Element referencesElement = importDataRootElement.element("references");
237    
238                    if (referencesElement == null) {
239                            return;
240                    }
241    
242                    List<Element> referenceElements = referencesElement.elements();
243    
244                    for (Element referenceElement : referenceElements) {
245                            String className = referenceElement.attributeValue("class-name");
246                            String stagedModelClassName = stagedModelClass.getName();
247    
248                            if (!stagedModelClassName.equals(className)) {
249                                    continue;
250                            }
251    
252                            boolean missing = GetterUtil.getBoolean(
253                                    referenceElement.attributeValue("missing"));
254    
255                            StagedModelDataHandler<?> stagedModelDataHandler =
256                                    StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
257                                            stagedModelClassName);
258    
259                            if (stagedModelDataHandler == null) {
260                                    continue;
261                            }
262    
263                            if (missing) {
264                                    stagedModelDataHandler.importMissingReference(
265                                            portletDataContext, referenceElement);
266    
267                                    continue;
268                            }
269    
270                            importStagedModel(portletDataContext, referenceElement);
271                    }
272            }
273    
274            public static <T extends StagedModel> void importReferenceStagedModels(
275                            PortletDataContext portletDataContext, T referrerStagedModel,
276                            Class<?> stagedModelClass)
277                    throws PortletDataException {
278    
279                    List<Element> referenceElements =
280                            portletDataContext.getReferenceElements(
281                                    referrerStagedModel, stagedModelClass);
282    
283                    for (Element referenceElement : referenceElements) {
284                            long classPK = GetterUtil.getLong(
285                                    referenceElement.attributeValue("class-pk"));
286    
287                            importReferenceStagedModel(
288                                    portletDataContext, referrerStagedModel, stagedModelClass,
289                                    classPK);
290                    }
291            }
292    
293            public static void importStagedModel(
294                            PortletDataContext portletDataContext, Element element)
295                    throws PortletDataException {
296    
297                    StagedModel stagedModel = _getStagedModel(portletDataContext, element);
298    
299                    importStagedModel(portletDataContext, stagedModel);
300            }
301    
302            public static <T extends StagedModel> void importStagedModel(
303                            PortletDataContext portletDataContext, T stagedModel)
304                    throws PortletDataException {
305    
306                    StagedModelDataHandler<T> stagedModelDataHandler =
307                            _getStagedModelDataHandler(stagedModel);
308    
309                    if (stagedModelDataHandler == null) {
310                            return;
311                    }
312    
313                    stagedModelDataHandler.importStagedModel(
314                            portletDataContext, stagedModel);
315    
316                    LastSessionRecorderHelperUtil.syncLastSessionState();
317            }
318    
319            private static StagedModel _getReferenceStagedModel(
320                    PortletDataContext portletDataContext, Element element) {
321    
322                    long groupId = GetterUtil.getLong(element.attributeValue("group-id"));
323                    String className = element.attributeValue("class-name");
324                    long classPK = GetterUtil.getLong(element.attributeValue("class-pk"));
325    
326                    String path = ExportImportPathUtil.getModelPath(
327                            groupId, className, classPK);
328    
329                    StagedModel stagedModel =
330                            (StagedModel)portletDataContext.getZipEntryAsObject(path);
331    
332                    if (stagedModel != null) {
333                            return stagedModel;
334                    }
335    
336                    path = ExportImportPathUtil.getCompanyModelPath(
337                            portletDataContext.getSourceCompanyId(), className, classPK);
338    
339                    return (StagedModel)portletDataContext.getZipEntryAsObject(path);
340            }
341    
342            private static StagedModel _getStagedModel(
343                    PortletDataContext portletDataContext, Element element) {
344    
345                    StagedModel stagedModel = null;
346                    Attribute classNameAttribute = null;
347    
348                    String elementName = element.getName();
349    
350                    if (elementName.equals("reference")) {
351                            stagedModel = _getReferenceStagedModel(portletDataContext, element);
352    
353                            Element referenceStagedModelElement =
354                                    portletDataContext.getImportDataElement(stagedModel);
355    
356                            if (referenceStagedModelElement != null) {
357                                    classNameAttribute = referenceStagedModelElement.attribute(
358                                            "class-name");
359                            }
360                    }
361                    else {
362                            String path = element.attributeValue("path");
363    
364                            stagedModel = (StagedModel)portletDataContext.getZipEntryAsObject(
365                                    element, path);
366    
367                            classNameAttribute = element.attribute("class-name");
368                    }
369    
370                    if ((classNameAttribute != null) &&
371                            (stagedModel instanceof TypedModel)) {
372    
373                            String className = classNameAttribute.getValue();
374    
375                            if (Validator.isNotNull(className)) {
376                                    long classNameId = PortalUtil.getClassNameId(className);
377    
378                                    TypedModel typedModel = (TypedModel)stagedModel;
379    
380                                    typedModel.setClassNameId(classNameId);
381                            }
382                    }
383    
384                    return stagedModel;
385            }
386    
387            private static <T extends StagedModel> StagedModelDataHandler<T>
388                    _getStagedModelDataHandler(T stagedModel) {
389    
390                    StagedModelDataHandler<T> stagedModelDataHandler =
391                            (StagedModelDataHandler<T>)
392                                    StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
393                                            ExportImportClassedModelUtil.getClassName(stagedModel));
394    
395                    return stagedModelDataHandler;
396            }
397    
398    }