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