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.exportimport.lar;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.util.ArrayUtil;
020    import com.liferay.portal.kernel.util.LongWrapper;
021    import com.liferay.portal.kernel.util.MapUtil;
022    import com.liferay.portal.kernel.util.StringBundler;
023    import com.liferay.portal.kernel.util.StringPool;
024    import com.liferay.portal.kernel.util.Validator;
025    import com.liferay.portal.model.ClassedModel;
026    import com.liferay.portal.model.Portlet;
027    import com.liferay.portal.model.StagedModel;
028    
029    import java.io.Serializable;
030    
031    import java.util.ArrayList;
032    import java.util.Collection;
033    import java.util.Date;
034    import java.util.HashMap;
035    import java.util.HashSet;
036    import java.util.List;
037    import java.util.Map;
038    import java.util.Set;
039    
040    /**
041     * @author Mate Thurzo
042     * @author Zsolt Berentey
043     * @author Daniel Kocsis
044     */
045    @ProviderType
046    public class ManifestSummary implements Serializable {
047    
048            public static String getManifestSummaryKey(
049                    StagedModelType stagedModelType) {
050    
051                    return getManifestSummaryKey(
052                            stagedModelType.getClassName(),
053                            stagedModelType.getReferrerClassName());
054            }
055    
056            public void addDataPortlet(
057                    Portlet portlet, String[] configurationPortletOptions) {
058    
059                    String rootPortletId = portlet.getRootPortletId();
060    
061                    if (!_configurationPortletOptions.containsKey(rootPortletId)) {
062                            _dataPortlets.add(portlet);
063    
064                            _configurationPortletOptions.put(
065                                    rootPortletId, configurationPortletOptions);
066                    }
067            }
068    
069            public void addLayoutPortlet(
070                    Portlet portlet, String[] configurationPortletOptions) {
071    
072                    String rootPortletId = portlet.getRootPortletId();
073    
074                    if (!_configurationPortletOptions.containsKey(rootPortletId)) {
075                            _layoutPortlets.add(portlet);
076    
077                            _configurationPortletOptions.put(
078                                    rootPortletId, configurationPortletOptions);
079                    }
080            }
081    
082            public void addModelAdditionCount(
083                    StagedModelType stagedModelType, long count) {
084    
085                    addModelAdditionCount(getManifestSummaryKey(stagedModelType), count);
086            }
087    
088            public void addModelAdditionCount(String manifestSummaryKey, long count) {
089                    LongWrapper modelAdditionCounter = _modelAdditionCounters.get(
090                            manifestSummaryKey);
091    
092                    if (modelAdditionCounter == null) {
093                            modelAdditionCounter = new LongWrapper();
094    
095                            _modelAdditionCounters.put(
096                                    manifestSummaryKey, modelAdditionCounter);
097                    }
098    
099                    modelAdditionCounter.setValue(count);
100    
101                    _manifestSummaryKeys.add(manifestSummaryKey);
102            }
103    
104            public void addModelDeletionCount(
105                    StagedModelType stagedModelType, long count) {
106    
107                    addModelDeletionCount(getManifestSummaryKey(stagedModelType), count);
108            }
109    
110            public void addModelDeletionCount(String manifestSummaryKey, long count) {
111                    LongWrapper modelDeletionCounter = _modelDeletionCounters.get(
112                            manifestSummaryKey);
113    
114                    if (modelDeletionCounter == null) {
115                            modelDeletionCounter = new LongWrapper();
116    
117                            _modelDeletionCounters.put(
118                                    manifestSummaryKey, modelDeletionCounter);
119                    }
120    
121                    modelDeletionCounter.setValue(count);
122    
123                    _manifestSummaryKeys.add(manifestSummaryKey);
124            }
125    
126            @Override
127            public Object clone() {
128                    ManifestSummary manifestSummary = new ManifestSummary();
129    
130                    manifestSummary._configurationPortletOptions =
131                            new HashMap<String, String[]> (
132                                    manifestSummary._configurationPortletOptions);
133                    manifestSummary._dataPortlets = new ArrayList<>(_dataPortlets);
134                    manifestSummary._layoutPortlets = new ArrayList<>(_layoutPortlets);
135    
136                    if (_exportDate != null) {
137                            manifestSummary.setExportDate(new Date(_exportDate.getTime()));
138                    }
139    
140                    manifestSummary._manifestSummaryKeys = new HashSet<>(
141                            _manifestSummaryKeys);
142                    manifestSummary._modelAdditionCounters = new HashMap<>(
143                            _modelAdditionCounters);
144                    manifestSummary._modelDeletionCounters = new HashMap<>(
145                            _modelDeletionCounters);
146    
147                    return manifestSummary;
148            }
149    
150            public long getAllModelDeletionCounts() {
151                    long modelDeletionCount = -1;
152    
153                    for (String manifestSummaryKey : _manifestSummaryKeys) {
154                            long manifestSummaryKeyModelDeletionCount = getModelDeletionCount(
155                                    manifestSummaryKey);
156    
157                            if (manifestSummaryKeyModelDeletionCount == -1) {
158                                    continue;
159                            }
160    
161                            if (modelDeletionCount == -1) {
162                                    modelDeletionCount = manifestSummaryKeyModelDeletionCount;
163                            }
164                            else {
165                                    modelDeletionCount += manifestSummaryKeyModelDeletionCount;
166                            }
167                    }
168    
169                    return modelDeletionCount;
170            }
171    
172            public String[] getConfigurationPortletOptions(String rootPortletId) {
173                    return _configurationPortletOptions.get(rootPortletId);
174            }
175    
176            public List<Portlet> getDataPortlets() {
177                    return _dataPortlets;
178            }
179    
180            public Date getExportDate() {
181                    return _exportDate;
182            }
183    
184            public List<Portlet> getLayoutPortlets() {
185                    return _layoutPortlets;
186            }
187    
188            public Collection<String> getManifestSummaryKeys() {
189                    return _manifestSummaryKeys;
190            }
191    
192            /**
193             * @deprecated As of 7.0.0, replaced by {@link
194             *             #getModelAdditionCount(StagedModel)}
195             */
196            @Deprecated
197            public long getModelAdditionCount(Class<? extends ClassedModel> clazz) {
198                    return getModelAdditionCount(new StagedModelType(clazz));
199            }
200    
201            /**
202             * @deprecated As of 7.0.0, replaced by {@link
203             *             #getModelAdditionCount(StagedModelType)}
204             */
205            @Deprecated
206            public long getModelAdditionCount(
207                    Class<? extends ClassedModel> clazz,
208                    Class<? extends ClassedModel> referrerClass) {
209    
210                    return getModelAdditionCount(clazz.getName(), referrerClass.getName());
211            }
212    
213            public long getModelAdditionCount(StagedModel stagedModel) {
214                    return getModelAdditionCount(stagedModel.getStagedModelType());
215            }
216    
217            public long getModelAdditionCount(StagedModelType stagedModelType) {
218                    return getModelAdditionCount(
219                            stagedModelType.getClassName(),
220                            stagedModelType.getReferrerClassName());
221            }
222    
223            public long getModelAdditionCount(String manifestSummaryKey) {
224                    if (!_modelAdditionCounters.containsKey(manifestSummaryKey)) {
225                            return -1;
226                    }
227    
228                    LongWrapper modelAdditionCounter = _modelAdditionCounters.get(
229                            manifestSummaryKey);
230    
231                    return modelAdditionCounter.getValue();
232            }
233    
234            public Map<String, LongWrapper> getModelAdditionCounters() {
235                    return _modelAdditionCounters;
236            }
237    
238            /**
239             * @deprecated As of 7.0.0, replaced by {@link #getAllModelDeletionCounts()}
240             */
241            @Deprecated
242            public long getModelDeletionCount() {
243                    return getAllModelDeletionCounts();
244            }
245    
246            /**
247             * @deprecated As of 7.0.0, replaced by {@link
248             *             #getModelDeletionCount(StagedModel)}
249             */
250            @Deprecated
251            public long getModelDeletionCount(Class<? extends ClassedModel> clazz) {
252                    return getModelDeletionCount(new StagedModelType(clazz));
253            }
254    
255            public long getModelDeletionCount(StagedModel stagedModel) {
256                    return getModelDeletionCount(stagedModel.getStagedModelType());
257            }
258    
259            public long getModelDeletionCount(StagedModelType stagedModelType) {
260                    return getModelDeletionCount(
261                            stagedModelType.getClassName(),
262                            stagedModelType.getReferrerClassName());
263            }
264    
265            public long getModelDeletionCount(StagedModelType[] stagedModelTypes) {
266                    if (ArrayUtil.isEmpty(stagedModelTypes)) {
267                            return 0;
268                    }
269    
270                    long modelDeletionCount = -1;
271    
272                    for (StagedModelType stagedModelType : stagedModelTypes) {
273                            long stagedModelTypeModelDeletionCount = getModelDeletionCount(
274                                    stagedModelType);
275    
276                            if (stagedModelTypeModelDeletionCount == -1) {
277                                    continue;
278                            }
279    
280                            if (modelDeletionCount == -1) {
281                                    modelDeletionCount = stagedModelTypeModelDeletionCount;
282                            }
283                            else {
284                                    modelDeletionCount += stagedModelTypeModelDeletionCount;
285                            }
286                    }
287    
288                    return modelDeletionCount;
289            }
290    
291            public long getModelDeletionCount(String manifestSummaryKey) {
292                    if (!_modelDeletionCounters.containsKey(manifestSummaryKey)) {
293                            return -1;
294                    }
295    
296                    LongWrapper modelDeletionCounter = _modelDeletionCounters.get(
297                            manifestSummaryKey);
298    
299                    return modelDeletionCounter.getValue();
300            }
301    
302            public Map<String, LongWrapper> getModelDeletionCounters() {
303                    return _modelDeletionCounters;
304            }
305    
306            public void incrementModelAdditionCount(StagedModelType stagedModelType) {
307                    String manifestSummaryKey = getManifestSummaryKey(stagedModelType);
308    
309                    if (!_modelAdditionCounters.containsKey(manifestSummaryKey)) {
310                            _modelAdditionCounters.put(manifestSummaryKey, new LongWrapper(1));
311    
312                            _manifestSummaryKeys.add(manifestSummaryKey);
313    
314                            return;
315                    }
316    
317                    LongWrapper modelAdditionCounter = _modelAdditionCounters.get(
318                            manifestSummaryKey);
319    
320                    modelAdditionCounter.increment();
321            }
322    
323            public void incrementModelDeletionCount(StagedModelType stagedModelType) {
324                    String manifestSummaryKey = getManifestSummaryKey(stagedModelType);
325    
326                    if (!_modelDeletionCounters.containsKey(manifestSummaryKey)) {
327                            _modelDeletionCounters.put(manifestSummaryKey, new LongWrapper(1));
328    
329                            _manifestSummaryKeys.add(manifestSummaryKey);
330    
331                            return;
332                    }
333    
334                    LongWrapper modelDeletionCounter = _modelDeletionCounters.get(
335                            manifestSummaryKey);
336    
337                    modelDeletionCounter.increment();
338            }
339    
340            public void resetCounters() {
341                    _modelAdditionCounters.clear();
342                    _modelDeletionCounters.clear();
343    
344                    _manifestSummaryKeys.clear();
345            }
346    
347            public void setExportDate(Date exportDate) {
348                    _exportDate = exportDate;
349            }
350    
351            @Override
352            public String toString() {
353                    StringBundler sb = new StringBundler(5);
354    
355                    sb.append("{modelAdditionCounters=");
356                    sb.append(MapUtil.toString(_modelAdditionCounters));
357                    sb.append(", modelDeletionCounters=");
358                    sb.append(MapUtil.toString(_modelDeletionCounters));
359                    sb.append("}");
360    
361                    return sb.toString();
362            }
363    
364            protected static String getManifestSummaryKey(
365                    String modelName, String referrerModelName) {
366    
367                    if (Validator.isNull(referrerModelName)) {
368                            return modelName;
369                    }
370    
371                    return modelName.concat(StringPool.POUND).concat(referrerModelName);
372            }
373    
374            protected long getModelAdditionCount(
375                    String className, String referrerClassName) {
376    
377                    if (Validator.isNull(referrerClassName) ||
378                            (!referrerClassName.equals(
379                                    StagedModelType.REFERRER_CLASS_NAME_ALL) &&
380                             !referrerClassName.equals(
381                                     StagedModelType.REFERRER_CLASS_NAME_ANY))) {
382    
383                            String manifestSummaryKey = getManifestSummaryKey(
384                                    className, referrerClassName);
385    
386                            return getModelAdditionCount(manifestSummaryKey);
387                    }
388    
389                    long modelAdditionCount = -1;
390    
391                    for (String key : _modelAdditionCounters.keySet()) {
392                            if (!key.startsWith(className.concat(StringPool.POUND)) &&
393                                    (!key.equals(className) ||
394                                     !referrerClassName.equals(
395                                             StagedModelType.REFERRER_CLASS_NAME_ALL))) {
396    
397                                    continue;
398                            }
399    
400                            long count = getModelAdditionCount(key);
401    
402                            if (count >= 0) {
403                                    if (modelAdditionCount < 0) {
404                                            modelAdditionCount = count;
405                                    }
406                                    else {
407                                            modelAdditionCount += count;
408                                    }
409                            }
410                    }
411    
412                    return modelAdditionCount;
413            }
414    
415            protected long getModelDeletionCount(
416                    String className, String referrerClassName) {
417    
418                    if (Validator.isNull(referrerClassName) ||
419                            (!referrerClassName.equals(
420                                    StagedModelType.REFERRER_CLASS_NAME_ALL) &&
421                             !referrerClassName.equals(
422                                     StagedModelType.REFERRER_CLASS_NAME_ANY))) {
423    
424                            String manifestSummaryKey = getManifestSummaryKey(
425                                    className, referrerClassName);
426    
427                            return getModelDeletionCount(manifestSummaryKey);
428                    }
429    
430                    long modelDeletionCount = -1;
431    
432                    for (String key : _modelDeletionCounters.keySet()) {
433                            if (!key.startsWith(className.concat(StringPool.POUND)) &&
434                                    (!key.equals(className) ||
435                                     !referrerClassName.equals(
436                                             StagedModelType.REFERRER_CLASS_NAME_ALL))) {
437    
438                                    continue;
439                            }
440    
441                            long count = getModelDeletionCount(key);
442    
443                            if (count >= 0) {
444                                    if (modelDeletionCount < 0) {
445                                            modelDeletionCount = count;
446                                    }
447                                    else {
448                                            modelDeletionCount += count;
449                                    }
450                            }
451                    }
452    
453                    return modelDeletionCount;
454            }
455    
456            private Map<String, String[]> _configurationPortletOptions =
457                    new HashMap<>();
458            private List<Portlet> _dataPortlets = new ArrayList<>();
459            private Date _exportDate;
460            private List<Portlet> _layoutPortlets = new ArrayList<>();
461            private Set<String> _manifestSummaryKeys = new HashSet<>();
462            private Map<String, LongWrapper> _modelAdditionCounters = new HashMap<>();
463            private Map<String, LongWrapper> _modelDeletionCounters = new HashMap<>();
464    
465    }