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
240             *             #getAllModelDeletionCounts()}
241             */
242            @Deprecated
243            public long getModelDeletionCount() {
244                    return getAllModelDeletionCounts();
245            }
246    
247            /**
248             * @deprecated As of 7.0.0, replaced by {@link
249             *             #getModelDeletionCount(StagedModel)}
250             */
251            @Deprecated
252            public long getModelDeletionCount(Class<? extends ClassedModel> clazz) {
253                    return getModelDeletionCount(new StagedModelType(clazz));
254            }
255    
256            public long getModelDeletionCount(StagedModel stagedModel) {
257                    return getModelDeletionCount(stagedModel.getStagedModelType());
258            }
259    
260            public long getModelDeletionCount(StagedModelType stagedModelType) {
261                    return getModelDeletionCount(
262                            stagedModelType.getClassName(),
263                            stagedModelType.getReferrerClassName());
264            }
265    
266            public long getModelDeletionCount(StagedModelType[] stagedModelTypes) {
267                    if (ArrayUtil.isEmpty(stagedModelTypes)) {
268                            return 0;
269                    }
270    
271                    long modelDeletionCount = -1;
272    
273                    for (StagedModelType stagedModelType : stagedModelTypes) {
274                            long stagedModelTypeModelDeletionCount = getModelDeletionCount(
275                                    stagedModelType);
276    
277                            if (stagedModelTypeModelDeletionCount == -1) {
278                                    continue;
279                            }
280    
281                            if (modelDeletionCount == -1) {
282                                    modelDeletionCount = stagedModelTypeModelDeletionCount;
283                            }
284                            else {
285                                    modelDeletionCount += stagedModelTypeModelDeletionCount;
286                            }
287                    }
288    
289                    return modelDeletionCount;
290            }
291    
292            public long getModelDeletionCount(String manifestSummaryKey) {
293                    if (!_modelDeletionCounters.containsKey(manifestSummaryKey)) {
294                            return -1;
295                    }
296    
297                    LongWrapper modelDeletionCounter = _modelDeletionCounters.get(
298                            manifestSummaryKey);
299    
300                    return modelDeletionCounter.getValue();
301            }
302    
303            public Map<String, LongWrapper> getModelDeletionCounters() {
304                    return _modelDeletionCounters;
305            }
306    
307            public void incrementModelAdditionCount(StagedModelType stagedModelType) {
308                    String manifestSummaryKey = getManifestSummaryKey(stagedModelType);
309    
310                    if (!_modelAdditionCounters.containsKey(manifestSummaryKey)) {
311                            _modelAdditionCounters.put(manifestSummaryKey, new LongWrapper(1));
312    
313                            _manifestSummaryKeys.add(manifestSummaryKey);
314    
315                            return;
316                    }
317    
318                    LongWrapper modelAdditionCounter = _modelAdditionCounters.get(
319                            manifestSummaryKey);
320    
321                    modelAdditionCounter.increment();
322            }
323    
324            public void incrementModelDeletionCount(StagedModelType stagedModelType) {
325                    String manifestSummaryKey = getManifestSummaryKey(stagedModelType);
326    
327                    if (!_modelDeletionCounters.containsKey(manifestSummaryKey)) {
328                            _modelDeletionCounters.put(manifestSummaryKey, new LongWrapper(1));
329    
330                            _manifestSummaryKeys.add(manifestSummaryKey);
331    
332                            return;
333                    }
334    
335                    LongWrapper modelDeletionCounter = _modelDeletionCounters.get(
336                            manifestSummaryKey);
337    
338                    modelDeletionCounter.increment();
339            }
340    
341            public void resetCounters() {
342                    _modelAdditionCounters.clear();
343                    _modelDeletionCounters.clear();
344    
345                    _manifestSummaryKeys.clear();
346            }
347    
348            public void setExportDate(Date exportDate) {
349                    _exportDate = exportDate;
350            }
351    
352            @Override
353            public String toString() {
354                    StringBundler sb = new StringBundler(5);
355    
356                    sb.append("{modelAdditionCounters=");
357                    sb.append(MapUtil.toString(_modelAdditionCounters));
358                    sb.append(", modelDeletionCounters=");
359                    sb.append(MapUtil.toString(_modelDeletionCounters));
360                    sb.append("}");
361    
362                    return sb.toString();
363            }
364    
365            protected static String getManifestSummaryKey(
366                    String modelName, String referrerModelName) {
367    
368                    if (Validator.isNull(referrerModelName)) {
369                            return modelName;
370                    }
371    
372                    return modelName.concat(StringPool.POUND).concat(referrerModelName);
373            }
374    
375            protected long getModelAdditionCount(
376                    String className, String referrerClassName) {
377    
378                    if (Validator.isNull(referrerClassName) ||
379                            (!referrerClassName.equals(
380                                    StagedModelType.REFERRER_CLASS_NAME_ALL) &&
381                             !referrerClassName.equals(
382                                     StagedModelType.REFERRER_CLASS_NAME_ANY))) {
383    
384                            String manifestSummaryKey = getManifestSummaryKey(
385                                    className, referrerClassName);
386    
387                            return getModelAdditionCount(manifestSummaryKey);
388                    }
389    
390                    long modelAdditionCount = -1;
391    
392                    for (String key : _modelAdditionCounters.keySet()) {
393                            if (!key.startsWith(className.concat(StringPool.POUND)) &&
394                                    (!key.equals(className) ||
395                                     !referrerClassName.equals(
396                                             StagedModelType.REFERRER_CLASS_NAME_ALL))) {
397    
398                                    continue;
399                            }
400    
401                            long count = getModelAdditionCount(key);
402    
403                            if (count >= 0) {
404                                    if (modelAdditionCount < 0) {
405                                            modelAdditionCount = count;
406                                    }
407                                    else {
408                                            modelAdditionCount += count;
409                                    }
410                            }
411                    }
412    
413                    return modelAdditionCount;
414            }
415    
416            protected long getModelDeletionCount(
417                    String className, String referrerClassName) {
418    
419                    if (Validator.isNull(referrerClassName) ||
420                            (!referrerClassName.equals(
421                                    StagedModelType.REFERRER_CLASS_NAME_ALL) &&
422                             !referrerClassName.equals(
423                                     StagedModelType.REFERRER_CLASS_NAME_ANY))) {
424    
425                            String manifestSummaryKey = getManifestSummaryKey(
426                                    className, referrerClassName);
427    
428                            return getModelDeletionCount(manifestSummaryKey);
429                    }
430    
431                    long modelDeletionCount = -1;
432    
433                    for (String key : _modelDeletionCounters.keySet()) {
434                            if (!key.startsWith(className.concat(StringPool.POUND)) &&
435                                    (!key.equals(className) ||
436                                     !referrerClassName.equals(
437                                             StagedModelType.REFERRER_CLASS_NAME_ALL))) {
438    
439                                    continue;
440                            }
441    
442                            long count = getModelDeletionCount(key);
443    
444                            if (count >= 0) {
445                                    if (modelDeletionCount < 0) {
446                                            modelDeletionCount = count;
447                                    }
448                                    else {
449                                            modelDeletionCount += count;
450                                    }
451                            }
452                    }
453    
454                    return modelDeletionCount;
455            }
456    
457            private Map<String, String[]> _configurationPortletOptions =
458                    new HashMap<>();
459            private List<Portlet> _dataPortlets = new ArrayList<>();
460            private Date _exportDate;
461            private List<Portlet> _layoutPortlets = new ArrayList<>();
462            private Set<String> _manifestSummaryKeys = new HashSet<>();
463            private Map<String, LongWrapper> _modelAdditionCounters = new HashMap<>();
464            private Map<String, LongWrapper> _modelDeletionCounters = new HashMap<>();
465    
466    }