Source code

001/*
002 *  Copyright 2017 Anyware Services
003 *
004 *  Licensed under the Apache License, Version 2.0 (the "License");
005 *  you may not use this file except in compliance with the License.
006 *  You may obtain a copy of the License at
007 *
008 *      http://www.apache.org/licenses/LICENSE-2.0
009 *
010 *  Unless required by applicable law or agreed to in writing, software
011 *  distributed under the License is distributed on an "AS IS" BASIS,
012 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 *  See the License for the specific language governing permissions and
014 *  limitations under the License.
015 */
016package org.ametys.plugins.contentio.synchronize;
017
018import java.time.ZonedDateTime;
019import java.util.Arrays;
020import java.util.Collection;
021import java.util.HashMap;
022import java.util.HashSet;
023import java.util.LinkedHashMap;
024import java.util.List;
025import java.util.Locale;
026import java.util.Map;
027import java.util.Objects;
028import java.util.Set;
029import java.util.stream.Collectors;
030import java.util.stream.Stream;
031
032import org.apache.avalon.framework.component.Component;
033import org.apache.avalon.framework.service.ServiceException;
034import org.apache.avalon.framework.service.ServiceManager;
035import org.apache.avalon.framework.service.Serviceable;
036import org.apache.commons.lang3.LocaleUtils;
037import org.apache.commons.lang3.StringUtils;
038
039import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
040import org.ametys.cms.repository.Content;
041import org.ametys.cms.repository.ModifiableContent;
042import org.ametys.core.user.CurrentUserProvider;
043import org.ametys.plugins.repository.AmetysObjectResolver;
044import org.ametys.plugins.repository.AmetysRepositoryException;
045import org.ametys.plugins.repository.data.holder.ModelLessDataHolder;
046import org.ametys.plugins.repository.query.expression.Expression;
047import org.ametys.plugins.repository.query.expression.Expression.Operator;
048import org.ametys.plugins.repository.query.expression.ExpressionContext;
049import org.ametys.plugins.repository.query.expression.StringExpression;
050import org.ametys.runtime.model.type.ModelItemTypeConstants;
051import org.ametys.runtime.plugin.component.AbstractLogEnabled;
052
053import com.google.common.collect.ImmutableList;
054import com.google.common.collect.ImmutableMap;
055
056/**
057 * Helper for Synchronizable Contents Collections.
058 */
059public class SynchronizableContentsCollectionHelper extends AbstractLogEnabled implements Serviceable, Component
060{
061    /** The Avalon Role */
062    public static final String ROLE = SynchronizableContentsCollectionHelper.class.getName();
063    
064    /** SCC DAO */
065    protected SynchronizableContentsCollectionDAO _sccDAO;
066    /** The content type extension point */
067    protected ContentTypeExtensionPoint _contentTypeEP;
068    /** The current user provider */
069    protected CurrentUserProvider _currentUserProvider;
070    /** The Ametys resolver */
071    protected AmetysObjectResolver _resolver;
072    
073    @Override
074    public void service(ServiceManager smanager) throws ServiceException
075    {
076        _sccDAO = (SynchronizableContentsCollectionDAO) smanager.lookup(SynchronizableContentsCollectionDAO.ROLE);
077        _contentTypeEP = (ContentTypeExtensionPoint) smanager.lookup(ContentTypeExtensionPoint.ROLE);
078        _currentUserProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
079        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
080    }
081    
082    /**
083     * Get the first {@link SynchronizableContentsCollection} found for the given SCC model id.
084     * @param modelId Id of the SCC model
085     * @return The first SCC found or null
086     */
087    public SynchronizableContentsCollection getSCCFromModelId(String modelId)
088    {
089        SynchronizableContentsCollection collection = null;
090
091        // Get the first collection corresponding to the SCC model
092        for (SynchronizableContentsCollection scc : _sccDAO.getSynchronizableContentsCollections())
093        {
094            if (scc.getSynchronizeCollectionModelId().equals(modelId))
095            {
096                collection = scc;
097                break;
098            }
099        }
100        
101        return collection;
102    }
103
104    /**
105     * Transform results to be organized by content attribute, and remove the null values.
106     * @param searchResult Remote values from a search by content and column or attribute
107     * @param mapping Mapping between content attribute and columns/attributes
108     * @return A {@link Map} of possible attribute values organized by content synchronization key and attribute name
109     */
110    public Map<String, Map<String, List<Object>>> organizeRemoteValuesByAttribute(Map<String, Map<String, Object>> searchResult, Map<String, List<String>> mapping)
111    {
112        Map<String, Map<String, List<Object>>> result = new LinkedHashMap<>();
113        
114        // For each searchResult line (1 line = 1 content)
115        for (String resultKey : searchResult.keySet())
116        {
117            Map<String, Object> searchItem = searchResult.get(resultKey);
118            Map<String, List<Object>> contentResult = new HashMap<>();
119            
120            // For each attribute in the mapping
121            for (String attributeName : mapping.keySet())
122            {
123                List<String> columns = mapping.get(attributeName); // Get the columns for the current attribute
124                List<Object> values = columns.stream() // For each column corresponding to the attribute
125                        .map(searchItem::get) // Map the values
126                        .flatMap(o ->
127                        {
128                            if (o instanceof Collection<?>)
129                            {
130                                return ((Collection<?>) o).stream();
131                            }
132                            return Stream.of(o);
133                        }) // If it's a list of objects, get a flat stream
134                        .filter(Objects::nonNull) // Remove null values
135                        .collect(Collectors.toList()); // Collect it into a List
136                
137                contentResult.put(attributeName, values); // Add the retrieved attribute values list to the contentResult
138            }
139            
140            result.put(resultKey, contentResult);
141        }
142        
143        return result;
144    }
145    
146    /**
147     * Add the given synchronizable collection id to the existing ones
148     * @param content The synchronized content
149     * @param collectionId The ID of the collection to add
150     */
151    public void updateSCCProperty(Content content, String collectionId)
152    {
153        Set<String> collectionIds = getSynchronizableCollectionIds(content);
154        if (collectionIds.add(collectionId))
155        {
156            content.getInternalDataHolder().setValue(SynchronizableContentsCollection.COLLECTION_ID_DATA_NAME, collectionIds.toArray(new String[collectionIds.size()]));
157        }
158    }
159    
160    /**
161     * Remove the synchronizable collection id from the SCC property
162     * @param content The synchronized content
163     * @param collectionId The ID of the collection to remove
164     */
165    public void removeSCCProperty(Content content, String collectionId)
166    {
167        Set<String> collectionIds = getSynchronizableCollectionIds(content);
168        if (collectionIds.remove(collectionId))
169        {
170            content.getInternalDataHolder().setValue(SynchronizableContentsCollection.COLLECTION_ID_DATA_NAME, collectionIds.toArray(new String[collectionIds.size()]));
171        }
172    }
173    
174    /**
175     * Update the given content's synchronization properties
176     * @param content the synchronized content
177     */
178    public void updateLastSynchronizationProperties(Content content)
179    {
180        content.getInternalDataHolder().setValue(SynchronizableContentsCollection.LAST_SYNCHRONIZATION_DATA_NAME, ZonedDateTime.now(), ModelItemTypeConstants.DATETIME_TYPE_ID);
181        content.getInternalDataHolder().setValue(SynchronizableContentsCollection.LAST_SYNCHRONIZATION_USER_DATA_NAME, _currentUserProvider.getUser(), org.ametys.cms.data.type.ModelItemTypeConstants.USER_ELEMENT_TYPE_ID);
182    }
183    
184    /**
185     * Retrieves the synchronizable collection identifiers
186     * @param content the content
187     * @return the synchronizable collection identifiers
188     * @throws AmetysRepositoryException if an error occurs while reading SCC info on the given content
189     */
190    public Set<String> getSynchronizableCollectionIds(Content content) throws AmetysRepositoryException
191    {
192        ModelLessDataHolder internalDataHolder = content.getInternalDataHolder();
193        
194        Set<String> collectionIds = new HashSet<>();
195        if (internalDataHolder.hasValue(SynchronizableContentsCollection.COLLECTION_ID_DATA_NAME))
196        {
197            String[] existingCollectionIds = internalDataHolder.getValue(SynchronizableContentsCollection.COLLECTION_ID_DATA_NAME);
198            collectionIds = Arrays.stream(existingCollectionIds)
199                                  .collect(Collectors.toSet());
200        }
201        
202        return collectionIds;
203    }
204    
205    /**
206     * Retrieves a query expression testing the collection
207     * @param collectionId the identifier of the collection to test
208     * @return the query expression
209     */
210    public Expression getCollectionExpression(String collectionId)
211    {
212        ExpressionContext context = ExpressionContext.newInstance()
213                                                     .withInternal(true);
214        
215        return new StringExpression(SynchronizableContentsCollection.COLLECTION_ID_DATA_NAME, Operator.EQ, collectionId, context);
216    }
217    
218    /**
219     * Import the content specified by the id in the specified collection.
220     * @param collectionId Collection ID
221     * @param id Synchronization ID of the content
222     * @param additionalParameters Additional parameters
223     * @return Imported contents
224     */
225    public Map<String, Object> importContent(String collectionId, String id, Map<String, Object> additionalParameters)
226    {
227        if (StringUtils.isBlank(id))
228        {
229            getLogger().warn("The synchronization code cannot be empty.");
230            return Map.of("error", "noSyncCode");
231        }
232        
233        Map<String, Object> result = new HashMap<>();
234        
235        try
236        {
237            Locale defaultLocale = additionalParameters.containsKey("language") ? LocaleUtils.toLocale((String) additionalParameters.get("language")) : null;
238            Set<Map<String, String>> contentsList = new HashSet<>();
239            
240            SynchronizableContentsCollection collection = _sccDAO.getSynchronizableContentsCollection(collectionId);
241            Content existingContent = collection.getContent(null, id, true);
242            if (existingContent == null)
243            {
244                List<ModifiableContent> contents = collection.importContent(id, additionalParameters, getLogger());
245                for (ModifiableContent content : contents)
246                {
247                    Map<String, String> contentMap = new HashMap<>();
248                    contentMap.put("id", content.getId());
249                    contentMap.put("title", content.getTitle(defaultLocale));
250                    contentMap.put("lang", content.getLanguage());
251                    contentsList.add(contentMap);
252                }
253                result.put("contents", contentsList);
254                result.put("total", contents.size());
255            }
256            else
257            {
258                result.put("contents", ImmutableList.of(ImmutableMap.of("id", existingContent.getId(), "title", existingContent.getTitle(defaultLocale), "lang", existingContent.getLanguage())));
259                result.put("error", "alreadyImported");
260            }
261        }
262        catch (Exception e)
263        {
264            String errorMessage = "An exception occured during import of the content '" + id + "' on SCC '" + collectionId + "'";
265            getLogger().error(errorMessage, e);
266            throw new IllegalStateException(errorMessage);
267        }
268        
269        return result;
270    }
271    
272    /**
273     * Synchronize the content on the given collection with the given synchronization code.
274     * @param collectionId Collection ID
275     * @param contentId Content ID
276     * @param syncCode Synchronization code
277     * @return true if an error occurred
278     */
279    public boolean synchronizeContent(String collectionId, String contentId, String syncCode)
280    {
281        ModifiableContent content = _resolver.resolveById(contentId);
282        boolean hasErrors = false;
283        
284        try
285        {
286            SynchronizableContentsCollection collection = _sccDAO.getSynchronizableContentsCollection(collectionId);
287            
288            // First, add, update or remove synchronization informations
289            collection.updateSyncInformations(content, syncCode, getLogger());
290            
291            // If the synchronization code is empty, the process ends here
292            if (StringUtils.isBlank(syncCode))
293            {
294                return false;
295            }
296            
297            Map<String, Object> searchParameters = new HashMap<>();
298            searchParameters.put(collection.getIdField(), syncCode);
299            
300            if (collection.getTotalCount(searchParameters, getLogger()) > 0)
301            {
302                collection.synchronizeContent(content, getLogger());
303            }
304            else
305            {
306                getLogger().warn("In the collection '{}', there is not content matching with the synchronization code '{}'.", collectionId, syncCode);
307                hasErrors = true;
308            }
309        }
310        catch (Exception e)
311        {
312            getLogger().error("An error occured while synchronizing the content '{}' with the synchronization code '{}' from the '{}' collection.", contentId, syncCode, collectionId, e);
313            hasErrors = true;
314        }
315        
316        return hasErrors;
317    }
318    
319    /**
320     * Get the value of the synchronization field.
321     * @param collectionId Collection ID
322     * @param contentId Content ID
323     * @return The value of the synchronization field
324     */
325    public String getSyncCode(String contentId, String collectionId)
326    {
327        SynchronizableContentsCollection collection = _sccDAO.getSynchronizableContentsCollection(collectionId);
328        Content content = _resolver.resolveById(contentId);
329        
330        String syncCode = null;
331        if (content.hasValue(collection.getIdField()))
332        {
333            syncCode = content.getValue(collection.getIdField());
334        }
335        return syncCode;
336    }
337}