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