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.documentlibrary.lar;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryUtil;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.lar.BaseStagedModelDataHandler;
020    import com.liferay.portal.kernel.lar.ExportImportPathUtil;
021    import com.liferay.portal.kernel.lar.PortletDataContext;
022    import com.liferay.portal.kernel.lar.PortletDataException;
023    import com.liferay.portal.kernel.lar.StagedModelDataHandlerUtil;
024    import com.liferay.portal.kernel.lar.StagedModelModifiedDateComparator;
025    import com.liferay.portal.kernel.util.GetterUtil;
026    import com.liferay.portal.kernel.util.ListUtil;
027    import com.liferay.portal.kernel.util.MapUtil;
028    import com.liferay.portal.kernel.util.StringUtil;
029    import com.liferay.portal.kernel.xml.Element;
030    import com.liferay.portal.model.Group;
031    import com.liferay.portal.model.UserConstants;
032    import com.liferay.portal.service.ServiceContext;
033    import com.liferay.portal.service.UserLocalServiceUtil;
034    import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
035    import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
036    import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeLocalServiceUtil;
037    import com.liferay.portlet.documentlibrary.util.DLUtil;
038    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
039    import com.liferay.portlet.dynamicdatamapping.service.DDMStructureLocalServiceUtil;
040    
041    import java.util.HashMap;
042    import java.util.List;
043    import java.util.Map;
044    
045    /**
046     * @author Mate Thurzo
047     */
048    public class DLFileEntryTypeStagedModelDataHandler
049            extends BaseStagedModelDataHandler<DLFileEntryType> {
050    
051            public static final String[] CLASS_NAMES =
052                    {DLFileEntryType.class.getName()};
053    
054            @Override
055            public void deleteStagedModel(
056                            String uuid, long groupId, String className, String extraData)
057                    throws PortalException {
058    
059                    DLFileEntryType dlFileEntryType = fetchStagedModelByUuidAndGroupId(
060                            uuid, groupId);
061    
062                    if (dlFileEntryType != null) {
063                            DLFileEntryTypeLocalServiceUtil.deleteFileEntryType(
064                                    dlFileEntryType);
065                    }
066            }
067    
068            @Override
069            public DLFileEntryType fetchStagedModelByUuidAndCompanyId(
070                    String uuid, long companyId) {
071    
072                    List<DLFileEntryType> fileEntryTypes =
073                            DLFileEntryTypeLocalServiceUtil.
074                                    getDLFileEntryTypesByUuidAndCompanyId(
075                                            uuid, companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
076                                            new StagedModelModifiedDateComparator<DLFileEntryType>());
077    
078                    if (ListUtil.isEmpty(fileEntryTypes)) {
079                            return null;
080                    }
081    
082                    return fileEntryTypes.get(0);
083            }
084    
085            @Override
086            public DLFileEntryType fetchStagedModelByUuidAndGroupId(
087                    String uuid, long groupId) {
088    
089                    return DLFileEntryTypeLocalServiceUtil.
090                            fetchDLFileEntryTypeByUuidAndGroupId(uuid, groupId);
091            }
092    
093            @Override
094            public String[] getClassNames() {
095                    return CLASS_NAMES;
096            }
097    
098            @Override
099            public Map<String, String> getReferenceAttributes(
100                    PortletDataContext portletDataContext, DLFileEntryType fileEntryType) {
101    
102                    Map<String, String> referenceAttributes = new HashMap<String, String>();
103    
104                    referenceAttributes.put(
105                            "file-entry-type-key", fileEntryType.getFileEntryTypeKey());
106    
107                    long defaultUserId = UserConstants.USER_ID_DEFAULT;
108    
109                    try {
110                            defaultUserId = UserLocalServiceUtil.getDefaultUserId(
111                                    fileEntryType.getCompanyId());
112                    }
113                    catch (Exception e) {
114                    }
115    
116                    boolean preloaded = false;
117    
118                    if ((fileEntryType.getFileEntryTypeId() ==
119                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) ||
120                            (defaultUserId == fileEntryType.getUserId())) {
121    
122                            preloaded = true;
123                    }
124    
125                    referenceAttributes.put("preloaded", String.valueOf(preloaded));
126    
127                    return referenceAttributes;
128            }
129    
130            @Override
131            public void importMissingReference(
132                            PortletDataContext portletDataContext, Element referenceElement)
133                    throws PortletDataException {
134    
135                    importMissingGroupReference(portletDataContext, referenceElement);
136    
137                    String uuid = referenceElement.attributeValue("uuid");
138    
139                    Map<Long, Long> groupIds =
140                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
141                                    Group.class);
142    
143                    long liveGroupId = GetterUtil.getLong(
144                            referenceElement.attributeValue("live-group-id"));
145    
146                    liveGroupId = MapUtil.getLong(groupIds, liveGroupId);
147    
148                    String fileEntryTypeKey = referenceElement.attributeValue(
149                            "file-entry-type-key");
150                    boolean preloaded = GetterUtil.getBoolean(
151                            referenceElement.attributeValue("preloaded"));
152    
153                    DLFileEntryType existingFileEntryType = null;
154    
155                    existingFileEntryType = fetchExistingFileEntryType(
156                            uuid, liveGroupId, fileEntryTypeKey, preloaded);
157    
158                    Map<Long, Long> fileEntryTypeIds =
159                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
160                                    DLFileEntryType.class);
161    
162                    long fileEntryTypeId = GetterUtil.getLong(
163                            referenceElement.attributeValue("class-pk"));
164    
165                    fileEntryTypeIds.put(
166                            fileEntryTypeId, existingFileEntryType.getFileEntryTypeId());
167            }
168    
169            @Override
170            public boolean validateReference(
171                    PortletDataContext portletDataContext, Element referenceElement) {
172    
173                    validateMissingGroupReference(portletDataContext, referenceElement);
174    
175                    String uuid = referenceElement.attributeValue("uuid");
176    
177                    Map<Long, Long> groupIds =
178                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
179                                    Group.class);
180    
181                    long liveGroupId = GetterUtil.getLong(
182                            referenceElement.attributeValue("live-group-id"));
183    
184                    liveGroupId = MapUtil.getLong(groupIds, liveGroupId);
185    
186                    String fileEntryTypeKey = referenceElement.attributeValue(
187                            "file-entry-type-key");
188                    boolean preloaded = GetterUtil.getBoolean(
189                            referenceElement.attributeValue("preloaded"));
190    
191                    DLFileEntryType existingFileEntryType = fetchExistingFileEntryType(
192                            uuid, liveGroupId, fileEntryTypeKey, preloaded);
193    
194                    if (existingFileEntryType == null) {
195                            return false;
196                    }
197    
198                    return true;
199            }
200    
201            @Override
202            protected void doExportStagedModel(
203                            PortletDataContext portletDataContext,
204                            DLFileEntryType fileEntryType)
205                    throws Exception {
206    
207                    Element fileEntryTypeElement = portletDataContext.getExportDataElement(
208                            fileEntryType);
209    
210                    List<DDMStructure> ddmStructures = fileEntryType.getDDMStructures();
211    
212                    for (DDMStructure ddmStructure : ddmStructures) {
213                            Element referenceElement =
214                                    StagedModelDataHandlerUtil.exportReferenceStagedModel(
215                                            portletDataContext, fileEntryType, ddmStructure,
216                                            PortletDataContext.REFERENCE_TYPE_STRONG);
217    
218                            referenceElement.addAttribute(
219                                    "structure-id",
220                                    StringUtil.valueOf(ddmStructure.getStructureId()));
221                    }
222    
223                    long defaultUserId = UserLocalServiceUtil.getDefaultUserId(
224                            fileEntryType.getCompanyId());
225    
226                    if (defaultUserId == fileEntryType.getUserId()) {
227                            fileEntryTypeElement.addAttribute("preloaded", "true");
228                    }
229    
230                    portletDataContext.addClassedModel(
231                            fileEntryTypeElement,
232                            ExportImportPathUtil.getModelPath(fileEntryType), fileEntryType);
233            }
234    
235            @Override
236            protected void doImportStagedModel(
237                            PortletDataContext portletDataContext,
238                            DLFileEntryType fileEntryType)
239                    throws Exception {
240    
241                    long userId = portletDataContext.getUserId(fileEntryType.getUserUuid());
242    
243                    List<Element> ddmStructureReferenceElements =
244                            portletDataContext.getReferenceElements(
245                                    fileEntryType, DDMStructure.class);
246    
247                    long[] ddmStructureIdsArray =
248                            new long[ddmStructureReferenceElements.size()];
249    
250                    Map<Long, Long> ddmStructureIds =
251                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
252                                    DDMStructure.class);
253    
254                    for (int i = 0; i < ddmStructureReferenceElements.size(); i++) {
255                            Element ddmStructureReferenceElement =
256                                    ddmStructureReferenceElements.get(i);
257    
258                            long ddmStructureId = GetterUtil.getLong(
259                                    ddmStructureReferenceElement.attributeValue("class-pk"));
260    
261                            ddmStructureIdsArray[i] = MapUtil.getLong(
262                                    ddmStructureIds, ddmStructureId);
263                    }
264    
265                    ServiceContext serviceContext = portletDataContext.createServiceContext(
266                            fileEntryType);
267    
268                    DLFileEntryType importedDLFileEntryType = null;
269    
270                    Element element = portletDataContext.getImportDataStagedModelElement(
271                            fileEntryType);
272    
273                    boolean preloaded = GetterUtil.getBoolean(
274                            element.attributeValue("preloaded"));
275    
276                    if (portletDataContext.isDataStrategyMirror()) {
277                            DLFileEntryType existingDLFileEntryType =
278                                    fetchExistingFileEntryType(
279                                            fileEntryType.getUuid(),
280                                            portletDataContext.getScopeGroupId(),
281                                            fileEntryType.getFileEntryTypeKey(), preloaded);
282    
283                            if (existingDLFileEntryType == null) {
284                                    serviceContext.setUuid(fileEntryType.getUuid());
285    
286                                    importedDLFileEntryType =
287                                            DLFileEntryTypeLocalServiceUtil.addFileEntryType(
288                                                    userId, portletDataContext.getScopeGroupId(),
289                                                    fileEntryType.getFileEntryTypeKey(),
290                                                    fileEntryType.getNameMap(),
291                                                    fileEntryType.getDescriptionMap(), ddmStructureIdsArray,
292                                                    serviceContext);
293                            }
294                            else {
295                                    DLFileEntryTypeLocalServiceUtil.updateFileEntryType(
296                                            userId, existingDLFileEntryType.getFileEntryTypeId(),
297                                            fileEntryType.getNameMap(),
298                                            fileEntryType.getDescriptionMap(), ddmStructureIdsArray,
299                                            serviceContext);
300    
301                                    importedDLFileEntryType =
302                                            DLFileEntryTypeLocalServiceUtil.fetchDLFileEntryType(
303                                                    existingDLFileEntryType.getFileEntryTypeId());
304                            }
305                    }
306                    else {
307                            importedDLFileEntryType =
308                                    DLFileEntryTypeLocalServiceUtil.addFileEntryType(
309                                            userId, portletDataContext.getScopeGroupId(),
310                                            fileEntryType.getFileEntryTypeKey(),
311                                            fileEntryType.getNameMap(),
312                                            fileEntryType.getDescriptionMap(), ddmStructureIdsArray,
313                                            serviceContext);
314                    }
315    
316                    portletDataContext.importClassedModel(
317                            fileEntryType, importedDLFileEntryType);
318    
319                    if (preloaded) {
320                            return;
321                    }
322    
323                    String importedDLFileEntryDDMStructureKey = DLUtil.getDDMStructureKey(
324                            importedDLFileEntryType);
325    
326                    List<DDMStructure> importedDDMStructures =
327                            importedDLFileEntryType.getDDMStructures();
328    
329                    for (DDMStructure importedDDMStructure : importedDDMStructures) {
330                            String ddmStructureKey = importedDDMStructure.getStructureKey();
331    
332                            if (!DLUtil.isAutoGeneratedDLFileEntryTypeDDMStructureKey(
333                                            ddmStructureKey)) {
334    
335                                    continue;
336                            }
337    
338                            if (ddmStructureKey.equals(importedDLFileEntryDDMStructureKey)) {
339                                    continue;
340                            }
341    
342                            importedDDMStructure.setStructureKey(
343                                    importedDLFileEntryDDMStructureKey);
344    
345                            DDMStructureLocalServiceUtil.updateDDMStructure(
346                                    importedDDMStructure);
347                    }
348            }
349    
350            protected DLFileEntryType fetchExistingFileEntryType(
351                    String uuid, long groupId, String fileEntryTypeKey, boolean preloaded) {
352    
353                    DLFileEntryType existingDLFileEntryType = null;
354    
355                    if (!preloaded) {
356                            existingDLFileEntryType = fetchStagedModelByUuidAndGroupId(
357                                    uuid, groupId);
358                    }
359                    else {
360                            existingDLFileEntryType =
361                                    DLFileEntryTypeLocalServiceUtil.fetchFileEntryType(
362                                            groupId, fileEntryTypeKey);
363                    }
364    
365                    return existingDLFileEntryType;
366            }
367    
368    }