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