001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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.ListUtil;
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.Group;
026    import com.liferay.portal.model.Portlet;
027    import com.liferay.portal.model.StagedGroupedModel;
028    import com.liferay.portal.model.StagedModel;
029    import com.liferay.portal.model.TypedModel;
030    import com.liferay.portal.service.GroupLocalServiceUtil;
031    import com.liferay.portal.service.PortletLocalServiceUtil;
032    import com.liferay.portal.util.PortalUtil;
033    
034    import java.util.List;
035    import java.util.Map;
036    
037    /**
038     * @author Brian Wing Shun Chan
039     * @author Mate Thurzo
040     */
041    public class StagedModelDataHandlerUtil {
042    
043            public static void deleteStagedModel(
044                            PortletDataContext portletDataContext, Element deletionElement)
045                    throws PortalException, SystemException {
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                    Element referenceElement = null;
068    
069                    Portlet referrerPortlet = PortletLocalServiceUtil.getPortletById(
070                            referrerPortletId);
071    
072                    if (stagedModel instanceof StagedGroupedModel) {
073                            StagedGroupedModel stagedGroupedModel =
074                                    (StagedGroupedModel)stagedModel;
075    
076                            if (portletDataContext.isCompanyStagedGroupedModel(
077                                            stagedGroupedModel)) {
078    
079                                    referenceElement = portletDataContext.addReferenceElement(
080                                            referrerPortlet,
081                                            portletDataContext.getExportDataRootElement(), stagedModel,
082                                            PortletDataContext.REFERENCE_TYPE_DEPENDENCY, true);
083    
084                                    return referenceElement;
085                            }
086                    }
087    
088                    exportStagedModel(portletDataContext, stagedModel);
089    
090                    referenceElement = portletDataContext.addReferenceElement(
091                            referrerPortlet, portletDataContext.getExportDataRootElement(),
092                            stagedModel, PortletDataContext.REFERENCE_TYPE_DEPENDENCY, false);
093    
094                    return referenceElement;
095            }
096    
097            /**
098             * @deprecated As of 7.0.0, replaced by {@link
099             *             #exportReferenceStagedModel(PortletDataContext, StagedModel,
100             *             StagedModel, String)}
101             */
102            @Deprecated
103            public static <T extends StagedModel, U extends StagedModel> Element
104                            exportReferenceStagedModel(
105                                    PortletDataContext portletDataContext, T referrerStagedModel,
106                                    Class<?> referrerStagedModelClass, U stagedModel,
107                                    Class<?> stagedModelClass, String referenceType)
108                    throws PortletDataException {
109    
110                    return exportReferenceStagedModel(
111                            portletDataContext, referrerStagedModel, stagedModel,
112                            referenceType);
113            }
114    
115            /**
116             * @deprecated As of 7.0.0, replaced by {@link
117             *             #exportReferenceStagedModel(PortletDataContext, StagedModel,
118             *             StagedModel, String)}
119             */
120            @Deprecated
121            public static <T extends StagedModel, U extends StagedModel> Element
122                            exportReferenceStagedModel(
123                                    PortletDataContext portletDataContext, T referrerStagedModel,
124                                    Element referrerStagedModelElement, U stagedModel,
125                                    Class<?> stagedModelClass, String referenceType)
126                    throws PortletDataException {
127    
128                    return exportReferenceStagedModel(
129                            portletDataContext, referrerStagedModel, stagedModel,
130                            referenceType);
131            }
132    
133            public static <T extends StagedModel, U extends StagedModel> Element
134                            exportReferenceStagedModel(
135                                    PortletDataContext portletDataContext, T referrerStagedModel,
136                                    U stagedModel, String referenceType)
137                    throws PortletDataException {
138    
139                    Element referrerStagedModelElement =
140                            portletDataContext.getExportDataElement(referrerStagedModel);
141    
142                    Element referenceElement = null;
143    
144                    if (stagedModel instanceof StagedGroupedModel) {
145                            StagedGroupedModel stagedGroupedModel =
146                                    (StagedGroupedModel)stagedModel;
147    
148                            if (portletDataContext.isCompanyStagedGroupedModel(
149                                            stagedGroupedModel)) {
150    
151                                    referenceElement = portletDataContext.addReferenceElement(
152                                            referrerStagedModel, referrerStagedModelElement,
153                                            stagedModel, PortletDataContext.REFERENCE_TYPE_DEPENDENCY,
154                                            true);
155    
156                                    return referenceElement;
157                            }
158                    }
159    
160                    exportStagedModel(portletDataContext, stagedModel);
161    
162                    referenceElement = portletDataContext.addReferenceElement(
163                            referrerStagedModel, referrerStagedModelElement, stagedModel,
164                            referenceType, false);
165    
166                    return referenceElement;
167            }
168    
169            public static <T extends StagedModel> void exportStagedModel(
170                            PortletDataContext portletDataContext, T stagedModel)
171                    throws PortletDataException {
172    
173                    StagedModelDataHandler<T> stagedModelDataHandler =
174                            _getStagedModelDataHandler(stagedModel);
175    
176                    stagedModelDataHandler.exportStagedModel(
177                            portletDataContext, stagedModel);
178            }
179    
180            public static <T extends StagedModel> String getDisplayName(T stagedModel) {
181                    StagedModelDataHandler<T> stagedModelDataHandler =
182                            _getStagedModelDataHandler(stagedModel);
183    
184                    if (stagedModelDataHandler == null) {
185                            return StringPool.BLANK;
186                    }
187    
188                    return stagedModelDataHandler.getDisplayName(stagedModel);
189            }
190    
191            public static Map<String, String> getReferenceAttributes(
192                    PortletDataContext portletDataContext, StagedModel stagedModel) {
193    
194                    StagedModelDataHandler<StagedModel> stagedModelDataHandler =
195                            _getStagedModelDataHandler(stagedModel);
196    
197                    return stagedModelDataHandler.getReferenceAttributes(
198                            portletDataContext, stagedModel);
199            }
200    
201            public static <T extends StagedModel> void importReferenceStagedModel(
202                            PortletDataContext portletDataContext, T referrerStagedModel,
203                            Class<?> stagedModelClass, long classPK)
204                    throws PortletDataException {
205    
206                    Element referenceElement =
207                            portletDataContext.getReferenceElement(
208                                    referrerStagedModel, stagedModelClass, classPK);
209    
210                    if (referenceElement == null) {
211                            return;
212                    }
213    
214                    boolean missing = portletDataContext.isMissingReference(
215                            referenceElement);
216    
217                    long groupId = GetterUtil.getLong(
218                            referenceElement.attributeValue("group-id"),
219                            portletDataContext.getSourceGroupId());
220    
221                    boolean parent = false;
222    
223                    String referenceType = referenceElement.attributeValue("type");
224    
225                    if (Validator.equals(
226                                    PortletDataContext.REFERENCE_TYPE_PARENT, referenceType)) {
227    
228                            parent = true;
229                    }
230    
231                    if (missing || parent) {
232                            Group group = null;
233                            boolean hasAncestors = false;
234    
235                            try {
236                                    group = GroupLocalServiceUtil.fetchGroup(
237                                            portletDataContext.getScopeGroupId());
238    
239                                    if ((group != null) &&
240                                            !ListUtil.isEmpty(group.getAncestors())) {
241    
242                                            hasAncestors = true;
243                                    }
244                            }
245                            catch (Exception e) {
246                                    throw new PortletDataException(e);
247                            }
248    
249                            if ((portletDataContext.getSourceGroupId() != groupId) &&
250                                    hasAncestors) {
251    
252                                    StagedModelDataHandler<?> stagedModelDataHandler =
253                                            StagedModelDataHandlerRegistryUtil.
254                                            getStagedModelDataHandler(stagedModelClass.getName());
255    
256                                    stagedModelDataHandler.importParentSiteStagedModel(
257                                            portletDataContext, referenceElement,
258                                            portletDataContext.getScopeGroupId());
259    
260                                    return;
261                            }
262                    }
263    
264                    if (missing) {
265                            StagedModelDataHandler<?> stagedModelDataHandler =
266                                    StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
267                                            stagedModelClass.getName());
268    
269                            stagedModelDataHandler.importCompanyStagedModel(
270                                    portletDataContext, referenceElement);
271    
272                            return;
273                    }
274    
275                    Element referenceDataElement =
276                            portletDataContext.getReferenceDataElement(
277                                    referrerStagedModel, stagedModelClass, classPK);
278    
279                    if (referenceDataElement != null) {
280                            importStagedModel(portletDataContext, referenceDataElement);
281    
282                            return;
283                    }
284    
285                    String stagedModelPath = ExportImportPathUtil.getModelPath(
286                            groupId, stagedModelClass.getName(), classPK);
287    
288                    StagedModel stagedModel =
289                            (StagedModel)portletDataContext.getZipEntryAsObject(
290                                    stagedModelPath);
291    
292                    if (stagedModel != null) {
293                            importStagedModel(portletDataContext, stagedModel);
294                    }
295            }
296    
297            public static void importReferenceStagedModels(
298                            PortletDataContext portletDataContext, Class<?> stagedModelClass)
299                    throws PortletDataException {
300    
301                    Element importDataRootElement =
302                            portletDataContext.getImportDataRootElement();
303    
304                    Element referencesElement = importDataRootElement.element("references");
305    
306                    if (referencesElement == null) {
307                            return;
308                    }
309    
310                    List<Element> referenceElements = referencesElement.elements();
311    
312                    for (Element referenceElement : referenceElements) {
313                            String className = referenceElement.attributeValue("class-name");
314                            String stagedModelClassName = stagedModelClass.getName();
315    
316                            if (!stagedModelClassName.equals(className)) {
317                                    continue;
318                            }
319    
320                            boolean missing = portletDataContext.isMissingReference(
321                                    referenceElement);
322    
323                            boolean parent = false;
324                            String referenceType = referenceElement.attributeValue("type");
325    
326                            if (Validator.equals(
327                                            PortletDataContext.REFERENCE_TYPE_PARENT, referenceType)) {
328    
329                                    parent = true;
330                            }
331    
332                            if (missing || parent) {
333                                    Group group = null;
334                                    boolean hasAncestors = false;
335    
336                                    try {
337                                            group = GroupLocalServiceUtil.fetchGroup(
338                                                    portletDataContext.getScopeGroupId());
339    
340                                            if ((group != null) &&
341                                                    !ListUtil.isEmpty(group.getAncestors())) {
342    
343                                                    hasAncestors = true;
344                                            }
345                                    }
346                                    catch (Exception e) {
347                                            throw new PortletDataException(e);
348                                    }
349    
350                                    long groupId = GetterUtil.getLong(
351                                            referenceElement.attributeValue("group-id"),
352                                            portletDataContext.getSourceGroupId());
353    
354                                    if ((portletDataContext.getSourceGroupId() != groupId) &&
355                                            hasAncestors) {
356    
357                                            StagedModelDataHandler<?> stagedModelDataHandler =
358                                                    StagedModelDataHandlerRegistryUtil.
359                                                            getStagedModelDataHandler(
360                                                                    stagedModelClass.getName());
361    
362                                            stagedModelDataHandler.importParentSiteStagedModel(
363                                                    portletDataContext, referenceElement,
364                                                    portletDataContext.getScopeGroupId());
365    
366                                            continue;
367                                    }
368                            }
369    
370                            if (missing) {
371                                    StagedModelDataHandler<?> stagedModelDataHandler =
372                                            StagedModelDataHandlerRegistryUtil.
373                                                    getStagedModelDataHandler(stagedModelClass.getName());
374    
375                                    stagedModelDataHandler.importCompanyStagedModel(
376                                            portletDataContext, referenceElement);
377    
378                                    continue;
379                            }
380    
381                            long groupId = GetterUtil.getLong(
382                                    referenceElement.attributeValue("group-id"),
383                                    portletDataContext.getSourceGroupId());
384                            long classPK = GetterUtil.getLong(
385                                    referenceElement.attributeValue("class-pk"));
386    
387                            String stagedModelPath = ExportImportPathUtil.getModelPath(
388                                    groupId, stagedModelClass.getName(), classPK);
389    
390                            StagedModel stagedModel =
391                                    (StagedModel)portletDataContext.getZipEntryAsObject(
392                                            stagedModelPath);
393    
394                            importStagedModel(portletDataContext, stagedModel);
395                    }
396            }
397    
398            public static <T extends StagedModel> void importReferenceStagedModels(
399                            PortletDataContext portletDataContext, T referrerStagedModel,
400                            Class<?> stagedModelClass)
401                    throws PortletDataException {
402    
403                    List<Element> referenceElements =
404                            portletDataContext.getReferenceElements(
405                                    referrerStagedModel, stagedModelClass);
406    
407                    for (Element referenceElement : referenceElements) {
408                            long classPK = GetterUtil.getLong(
409                                    referenceElement.attributeValue("class-pk"));
410    
411                            importReferenceStagedModel(
412                                    portletDataContext, referrerStagedModel, stagedModelClass,
413                                    classPK);
414                    }
415            }
416    
417            public static void importStagedModel(
418                            PortletDataContext portletDataContext, Element element)
419                    throws PortletDataException {
420    
421                    StagedModel stagedModel = _getStagedModel(portletDataContext, element);
422    
423                    importStagedModel(portletDataContext, stagedModel);
424            }
425    
426            public static <T extends StagedModel> void importStagedModel(
427                            PortletDataContext portletDataContext, T stagedModel)
428                    throws PortletDataException {
429    
430                    StagedModelDataHandler<T> stagedModelDataHandler =
431                            _getStagedModelDataHandler(stagedModel);
432    
433                    stagedModelDataHandler.importStagedModel(
434                            portletDataContext, stagedModel);
435            }
436    
437            private static StagedModel _getStagedModel(
438                    PortletDataContext portletDataContext, Element element) {
439    
440                    String path = element.attributeValue("path");
441    
442                    StagedModel stagedModel =
443                            (StagedModel)portletDataContext.getZipEntryAsObject(element, path);
444    
445                    Attribute classNameAttribute = element.attribute("class-name");
446    
447                    if ((classNameAttribute != null) &&
448                            (stagedModel instanceof TypedModel)) {
449    
450                            String className = classNameAttribute.getValue();
451    
452                            if (Validator.isNotNull(className)) {
453                                    long classNameId = PortalUtil.getClassNameId(className);
454    
455                                    TypedModel typedModel = (TypedModel)stagedModel;
456    
457                                    typedModel.setClassNameId(classNameId);
458                            }
459                    }
460    
461                    return stagedModel;
462            }
463    
464            private static <T extends StagedModel> StagedModelDataHandler<T>
465                    _getStagedModelDataHandler(T stagedModel) {
466    
467                    StagedModelDataHandler<T> stagedModelDataHandler =
468                            (StagedModelDataHandler<T>)
469                                    StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
470                                            ExportImportClassedModelUtil.getClassName(stagedModel));
471    
472                    return stagedModelDataHandler;
473            }
474    
475    }