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