Source code

001/*
002 * This library is part of OpenCms -
003 * the Open Source Content Management System
004 *
005 * Copyright (C) Alkacon Software (http://www.alkacon.com)
006 *
007 * This library is free software; you can redistribute it and/or
008 * modify it under the terms of the GNU Lesser General Public
009 * License as published by the Free Software Foundation; either
010 * version 2.1 of the License, or (at your option) any later version.
011 *
012 * This library is distributed in the hope that it will be useful,
013 * but WITHOUT ANY WARRANTY; without even the implied warranty of
014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015 * Lesser General Public License for more details.
016 *
017 * For further information about Alkacon Software, please see the
018 * company website: http://www.alkacon.com
019 *
020 * For further information about OpenCms, please see the
021 * project website: http://www.opencms.org
022 *
023 * You should have received a copy of the GNU Lesser General Public
024 * License along with this library; if not, write to the Free Software
025 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
026 */
027
028package org.opencms.acacia.client;
029
030import org.opencms.acacia.shared.CmsContentDefinition;
031import org.opencms.acacia.shared.CmsValidationResult;
032import org.opencms.util.CmsPair;
033
034import java.util.Collections;
035import java.util.HashMap;
036import java.util.HashSet;
037import java.util.Map;
038import java.util.Set;
039
040/**
041 * The validation context. Keeps track of valid and invalid entity id's as well as of entity ids with warnings attached.<p>
042 */
043public class CmsValidationContext {
044
045    /** The invalid entity id's with error path information. */
046    private Map<String, Set<String>> m_invalidEntityIds;
047
048    /** The warning entity id's with warning path information. */
049    private Map<String, Set<String>> m_warningEntityIds;
050
051    /** The valid entity id's. */
052    private Set<String> m_validEntityIds;
053
054    /** The synchronized paths. */
055    private Set<String> m_synchronizedPaths;
056
057    /**
058     * Constructor.<p>
059     */
060    public CmsValidationContext() {
061
062        m_invalidEntityIds = new HashMap<>();
063        m_validEntityIds = new HashSet<>();
064        m_warningEntityIds = new HashMap<>();
065    }
066
067    /**
068     * Constructor, starting with an initial validation result.
069     * @param validationResult the validation result to initialize the context with.
070     * @param synchronizedPaths paths that should be synchronized.
071     */
072    public CmsValidationContext(CmsValidationResult validationResult, Set<String> synchronizedPaths) {
073
074        m_invalidEntityIds = new HashMap<>();
075        m_validEntityIds = new HashSet<>();
076        m_warningEntityIds = new HashMap<>();
077
078        for (String entityId : validationResult.getWarnings().keySet()) {
079            if (validationResult.hasWarnings(entityId)) {
080                setWarningEntity(entityId, validationResult.getWarnings(entityId));
081            }
082        }
083        for (String entityId : validationResult.getErrors().keySet()) {
084            if (validationResult.hasErrors(entityId)) {
085                setInvalidEntity(entityId, validationResult.getErrors(entityId));
086            }
087        }
088
089        m_synchronizedPaths = synchronizedPaths;
090
091    }
092
093    /**
094     * Clears a warning entity id.<p>
095     *
096     * @param entityId the entity id
097     */
098    public void clearWarningEntity(String entityId) {
099
100        Set<String> currentPaths = m_warningEntityIds.get(entityId);
101        updateSyncWarnings(currentPaths, null);
102        m_warningEntityIds.remove(entityId);
103    }
104
105    /**
106     * Returns the invalid entity id's.<p>
107     *
108     * @return the invalid entity id's
109     */
110    public Set<String> getInvalidEntityIds() {
111
112        return m_invalidEntityIds.keySet();
113    }
114
115    /**
116     * Returns the valid entity id's.<p>
117     *
118     * @return the valid entity id's
119     */
120    public Set<String> getValidEntityIds() {
121
122        return m_validEntityIds;
123    }
124
125    /**
126     * Returns the warning entity id's.<p>
127     *
128     * @return the warning entity id's
129     */
130    public Set<String> getWarningEntityIds() {
131
132        return m_warningEntityIds.keySet();
133    }
134
135    /**
136     * Returns if there are any invalid entities.<p>
137     *
138     * @return <code>true</code>  if there are any invalid entities
139     */
140    public boolean hasValidationErrors() {
141
142        return !m_invalidEntityIds.isEmpty();
143    }
144
145    /**
146     * Returns if there are any warning entities.<p>
147     *
148     * @return <code>true</code>  if there are any warning entities
149     */
150    public boolean hasValidationWarnings() {
151
152        return !m_warningEntityIds.isEmpty();
153    }
154
155    /**
156     * Removes the given entity id, use when validating the entity is no longer required.<p>
157     *
158     * @param entityId the entity id
159     */
160    public void removeEntityId(String entityId) {
161
162        m_invalidEntityIds.remove(entityId);
163        m_validEntityIds.remove(entityId);
164        m_warningEntityIds.remove(entityId);
165    }
166
167    /**
168     * Sets an entity as invalid and adds the error paths.<p>
169     *
170     * @param entityId the entity id
171     * @param errors the errors for the entity
172     */
173    public void setInvalidEntity(String entityId, Map<String[], CmsPair<String, String>> errors) {
174
175        Set<String> newPaths = extractPaths(errors);
176        updateSyncErrors(m_invalidEntityIds.get(entityId), newPaths);
177        m_validEntityIds.remove(entityId);
178        m_invalidEntityIds.put(entityId, newPaths);
179    }
180
181    /**
182     * Sets an entity as valid.<p>
183     *
184     * @param entityId the entity id
185     */
186    public void setValidEntity(String entityId) {
187
188        updateSyncErrors(m_invalidEntityIds.get(entityId), null);
189        m_invalidEntityIds.remove(entityId);
190        m_validEntityIds.add(entityId);
191    }
192
193    /**
194     * Sets warnings for an entity id.<p>
195     *
196     * @param entityId the entity id
197     * @param warnings the warnings for the entity
198     */
199    public void setWarningEntity(String entityId, Map<String[], CmsPair<String, String>> warnings) {
200
201        Set<String> newPaths = extractPaths(warnings);
202        Set<String> currentPaths = m_warningEntityIds.get(entityId);
203        updateSyncWarnings(currentPaths, newPaths);
204        m_warningEntityIds.put(entityId, newPaths);
205    }
206
207    /**
208     * Extracts the path information for synchronization comparison from the warning/error information.
209     * @param issues the warnings/errors as returned from the validation result.
210     * @return the path information. I.e., paths without indexes.
211     */
212    private Set<String> extractPaths(Map<String[], CmsPair<String, String>> issues) {
213
214        Set<String> result = new HashSet<>(issues.keySet().size());
215        for (String[] e : issues.keySet()) {
216            String path = "";
217            for (int i = 0; i < e.length; i++) {
218                String ep = e[i];
219                if (ep != "ATTRIBUTE_CHOICE") {
220                    path += CmsContentDefinition.removeIndex(ep.substring(ep.lastIndexOf('/')));
221                }
222            }
223            result.add(path.substring(1));
224        }
225        return result;
226    }
227
228    /**
229     * Returns the paths to remove from all entities due to synchronization, when the provided current
230     * issue paths are updated to the new ones.
231     * @param currentPaths the current issue paths
232     * @param newPaths the new issue paths, replacing the current ones
233     * @return the removed paths for which synchronization is needed.
234     */
235    private Set<String> getPathsToSyncRemovedIssues(Set<String> currentPaths, Set<String> newPaths) {
236
237        if ((m_synchronizedPaths != null) && !m_synchronizedPaths.isEmpty()) {
238            Set<String> result = new HashSet<>(m_synchronizedPaths.size());
239            if ((currentPaths != null) && !currentPaths.isEmpty()) {
240                Set<String> intersection = new HashSet<>(m_synchronizedPaths);
241                intersection.retainAll(currentPaths);
242                for (String p : intersection) {
243                    if ((null == newPaths) || !newPaths.contains(p)) {
244                        result.add(p);
245                    }
246                }
247            }
248            return result;
249        }
250        return Collections.emptySet();
251    }
252
253    /**
254     * Removes errors for all entities, if an error for a synchronized element is removed.
255     * @param currentPaths the current error paths
256     * @param newPaths the error paths that replace the current ones
257     */
258    private void updateSyncErrors(Set<String> currentPaths, Set<String> newPaths) {
259
260        Set<String> pathsToUpdate = getPathsToSyncRemovedIssues(currentPaths, newPaths);
261        if (!pathsToUpdate.isEmpty()) {
262            Set<String> invalidEntities = new HashSet<>(m_invalidEntityIds.keySet());
263            for (String entity : invalidEntities) {
264                Set<String> paths = m_invalidEntityIds.get(entity);
265                paths.removeAll(pathsToUpdate);
266                if (paths.isEmpty()) {
267                    m_invalidEntityIds.remove(entity);
268                    m_validEntityIds.add(entity);
269                }
270            }
271        }
272    }
273
274    /**
275     * Removes warnings for all entities, if a warning for a synchronized element is removed.
276     * @param currentPaths the current error paths
277     * @param newPaths the error paths that replace the current ones
278     */
279    private void updateSyncWarnings(Set<String> currentPaths, Set<String> newPaths) {
280
281        Set<String> pathsToUpdate = getPathsToSyncRemovedIssues(currentPaths, newPaths);
282        if (!pathsToUpdate.isEmpty()) {
283            Set<String> warningEntities = new HashSet<>(m_warningEntityIds.keySet());
284            for (String entity : warningEntities) {
285                Set<String> paths = m_warningEntityIds.get(entity);
286                paths.removeAll(pathsToUpdate);
287                if (paths.isEmpty()) {
288                    m_warningEntityIds.remove(entity);
289                }
290            }
291        }
292    }
293}