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