001/* 002 * (C) Copyright 2014-2018 Nuxeo (http://nuxeo.com/) and others. 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 * 016 * Contributors: 017 * <a href="mailto:grenard@nuxeo.com">Guillaume</a> 018 */ 019package org.nuxeo.ecm.collections.core; 020 021import java.io.Serializable; 022import java.util.ArrayList; 023import java.util.HashMap; 024import java.util.List; 025import java.util.Map; 026import java.util.Set; 027import java.util.TreeSet; 028 029import org.apache.commons.lang3.StringUtils; 030import org.nuxeo.ecm.collections.api.CollectionConstants; 031import org.nuxeo.ecm.collections.api.CollectionLocationService; 032import org.nuxeo.ecm.collections.api.CollectionManager; 033import org.nuxeo.ecm.collections.core.adapter.Collection; 034import org.nuxeo.ecm.collections.core.adapter.CollectionMember; 035import org.nuxeo.ecm.collections.core.listener.CollectionAsynchrnonousQuery; 036import org.nuxeo.ecm.collections.core.worker.DuplicateCollectionMemberWork; 037import org.nuxeo.ecm.collections.core.worker.RemoveFromCollectionWork; 038import org.nuxeo.ecm.collections.core.worker.RemovedAbstractWork; 039import org.nuxeo.ecm.collections.core.worker.RemovedCollectionMemberWork; 040import org.nuxeo.ecm.collections.core.worker.RemovedCollectionWork; 041import org.nuxeo.ecm.core.api.CoreSession; 042import org.nuxeo.ecm.core.api.DocumentModel; 043import org.nuxeo.ecm.core.api.DocumentRef; 044import org.nuxeo.ecm.core.api.DocumentSecurityException; 045import org.nuxeo.ecm.core.api.IdRef; 046import org.nuxeo.ecm.core.api.NuxeoException; 047import org.nuxeo.ecm.core.api.PathRef; 048import org.nuxeo.ecm.core.api.UnrestrictedSessionRunner; 049import org.nuxeo.ecm.core.api.event.CoreEventConstants; 050import org.nuxeo.ecm.core.api.event.DocumentEventCategories; 051import org.nuxeo.ecm.core.api.pathsegment.PathSegmentService; 052import org.nuxeo.ecm.core.api.security.SecurityConstants; 053import org.nuxeo.ecm.core.api.versioning.VersioningService; 054import org.nuxeo.ecm.core.event.Event; 055import org.nuxeo.ecm.core.event.EventService; 056import org.nuxeo.ecm.core.event.impl.DocumentEventContext; 057import org.nuxeo.ecm.core.work.api.WorkManager; 058import org.nuxeo.ecm.platform.dublincore.listener.DublinCoreListener; 059import org.nuxeo.runtime.api.Framework; 060import org.nuxeo.runtime.model.DefaultComponent; 061 062/** 063 * @since 5.9.3 064 */ 065public class CollectionManagerImpl extends DefaultComponent implements CollectionManager { 066 067 private static final String PERMISSION_ERROR_MESSAGE = "Privilege '%s' is not granted to '%s'"; 068 069 public static void disableEvents(final DocumentModel doc) { 070 doc.putContextData(DublinCoreListener.DISABLE_DUBLINCORE_LISTENER, true); 071 doc.putContextData(CollectionConstants.DISABLE_NOTIFICATION_SERVICE, true); 072 doc.putContextData(CollectionConstants.DISABLE_AUDIT_LOGGER, true); 073 doc.putContextData(VersioningService.DISABLE_AUTO_CHECKOUT, true); 074 } 075 076 @Override 077 public void addToCollection(final DocumentModel collection, final DocumentModel documentToBeAdded, 078 final CoreSession session) throws DocumentSecurityException { 079 checkCanAddToCollection(collection, documentToBeAdded, session); 080 final Map<String, Serializable> props = new HashMap<>(); 081 props.put(CollectionConstants.COLLECTION_REF_EVENT_CTX_PROP, collection.getRef()); 082 fireEvent(documentToBeAdded, session, CollectionConstants.BEFORE_ADDED_TO_COLLECTION, props); 083 Collection colAdapter = collection.getAdapter(Collection.class); 084 colAdapter.addDocument(documentToBeAdded.getId()); 085 session.saveDocument(colAdapter.getDocument()); 086 087 new UnrestrictedSessionRunner(session) { 088 089 @Override 090 public void run() { 091 092 documentToBeAdded.addFacet(CollectionConstants.COLLECTABLE_FACET); 093 094 // We want to disable the following listener on a 095 // collection member when it is added to a collection 096 disableEvents(documentToBeAdded); 097 098 CollectionMember docAdapter = documentToBeAdded.getAdapter(CollectionMember.class); 099 docAdapter.addToCollection(collection.getId()); 100 DocumentModel addedDoc = session.saveDocument(docAdapter.getDocument()); 101 fireEvent(addedDoc, session, CollectionConstants.ADDED_TO_COLLECTION, props); 102 } 103 104 }.runUnrestricted(); 105 } 106 107 @Override 108 public void addToCollection(final DocumentModel collection, final List<DocumentModel> documentListToBeAdded, 109 final CoreSession session) { 110 for (DocumentModel documentToBeAdded : documentListToBeAdded) { 111 addToCollection(collection, documentToBeAdded, session); 112 } 113 } 114 115 @Override 116 public void addToNewCollection(final String newTitle, final String newDescription, 117 final DocumentModel documentToBeAdded, final CoreSession session) { 118 addToCollection(createCollection(newTitle, newDescription, documentToBeAdded, session), documentToBeAdded, 119 session); 120 } 121 122 @Override 123 public void addToNewCollection(final String newTitle, final String newDescription, 124 final List<DocumentModel> documentListToBeAdded, CoreSession session) { 125 DocumentModel newCollection = createCollection(newTitle, newDescription, documentListToBeAdded.get(0), session); 126 for (DocumentModel documentToBeAdded : documentListToBeAdded) { 127 addToCollection(newCollection, documentToBeAdded, session); 128 } 129 } 130 131 @Override 132 public boolean canAddToCollection(final DocumentModel collection, final CoreSession session) { 133 return isCollection(collection) 134 && session.hasPermission(collection.getRef(), SecurityConstants.WRITE_PROPERTIES); 135 } 136 137 @Override 138 public boolean canManage(final DocumentModel collection, final CoreSession session) { 139 return isCollection(collection) && session.hasPermission(collection.getRef(), SecurityConstants.EVERYTHING); 140 } 141 142 public void checkCanAddToCollection(final DocumentModel collection, final DocumentModel documentToBeAdded, 143 final CoreSession session) { 144 if (!isCollectable(documentToBeAdded)) { 145 throw new IllegalArgumentException( 146 String.format("Document %s is not collectable", documentToBeAdded.getTitle())); 147 } 148 checkCanCollectInCollection(collection, session); 149 } 150 151 /** 152 * @since 8.4 153 */ 154 protected void checkCanCollectInCollection(final DocumentModel collection, final CoreSession session) { 155 if (!isCollection(collection)) { 156 throw new IllegalArgumentException(String.format("Document %s is not a collection", collection.getTitle())); 157 } 158 if (!session.hasPermission(collection.getRef(), SecurityConstants.WRITE_PROPERTIES)) { 159 throw new DocumentSecurityException(String.format(PERMISSION_ERROR_MESSAGE, 160 CollectionConstants.CAN_COLLECT_PERMISSION, session.getPrincipal().getName())); 161 } 162 } 163 164 protected DocumentModel createCollection(final String newTitle, final String newDescription, 165 final DocumentModel context, final CoreSession session) { 166 DocumentModel defaultCollections = getUserDefaultCollections(session); 167 PathSegmentService pss = Framework.getService(PathSegmentService.class); 168 Map<String, Object> options = new HashMap<>(); 169 options.put(CoreEventConstants.PARENT_PATH, defaultCollections.getPath().toString()); 170 options.put(CoreEventConstants.DESTINATION_NAME, pss.generatePathSegment(newTitle)); 171 DocumentModel newCollection = session.createDocumentModel(CollectionConstants.COLLECTION_TYPE, options); 172 newCollection.setPropertyValue("dc:title", newTitle); 173 newCollection.setPropertyValue("dc:description", newDescription); 174 return session.createDocument(newCollection); 175 } 176 177 @Override 178 @Deprecated 179 public DocumentModel getUserDefaultCollections(final DocumentModel context, final CoreSession session) { 180 return getUserDefaultCollections(session); 181 } 182 183 @Override 184 public DocumentModel getUserDefaultCollections(final CoreSession session) { 185 return Framework.getService(CollectionLocationService.class) 186 .getUserDefaultCollectionsRoot(session); 187 } 188 189 @Override 190 public List<DocumentModel> getVisibleCollection(final DocumentModel collectionMember, final CoreSession session) { 191 return getVisibleCollection(collectionMember, CollectionConstants.MAX_COLLECTION_RETURNED, session); 192 } 193 194 @Override 195 public List<DocumentModel> getVisibleCollection(final DocumentModel collectionMember, int maxResult, 196 CoreSession session) { 197 List<DocumentModel> result = new ArrayList<>(); 198 if (isCollected(collectionMember)) { 199 CollectionMember collectionMemberAdapter = collectionMember.getAdapter(CollectionMember.class); 200 List<String> collectionIds = collectionMemberAdapter.getCollectionIds(); 201 for (int i = 0; i < collectionIds.size() && result.size() < maxResult; i++) { 202 final String collectionId = collectionIds.get(i); 203 DocumentRef documentRef = new IdRef(collectionId); 204 if (session.exists(documentRef) && session.hasPermission(documentRef, SecurityConstants.READ)) { 205 DocumentModel collection = session.getDocument(documentRef); 206 if (!collection.isTrashed() && !collection.isVersion()) { 207 result.add(collection); 208 } 209 } 210 } 211 } 212 return result; 213 } 214 215 @Override 216 public boolean hasVisibleCollection(final DocumentModel collectionMember, CoreSession session) { 217 CollectionMember collectionMemberAdapter = collectionMember.getAdapter(CollectionMember.class); 218 List<String> collectionIds = collectionMemberAdapter.getCollectionIds(); 219 for (final String collectionId : collectionIds) { 220 DocumentRef documentRef = new IdRef(collectionId); 221 if (session.exists(documentRef) && session.hasPermission(documentRef, SecurityConstants.READ)) { 222 return true; 223 } 224 } 225 return false; 226 } 227 228 @Override 229 public boolean isCollectable(final DocumentModel doc) { 230 return !doc.hasFacet(CollectionConstants.NOT_COLLECTABLE_FACET); 231 } 232 233 @Override 234 public boolean isCollected(final DocumentModel doc) { 235 return doc.hasFacet(CollectionConstants.COLLECTABLE_FACET); 236 } 237 238 @Override 239 public boolean isCollection(final DocumentModel doc) { 240 return doc.hasFacet(CollectionConstants.COLLECTION_FACET); 241 } 242 243 @Override 244 public boolean isInCollection(DocumentModel collection, DocumentModel document, CoreSession session) { 245 if (isCollected(document)) { 246 final CollectionMember collectionMemberAdapter = document.getAdapter(CollectionMember.class); 247 return collectionMemberAdapter.getCollectionIds().contains(collection.getId()); 248 } 249 return false; 250 } 251 252 @Override 253 public void processCopiedCollection(final DocumentModel collection) { 254 Collection collectionAdapter = collection.getAdapter(Collection.class); 255 List<String> documentIds = collectionAdapter.getCollectedDocumentIds(); 256 257 int i = 0; 258 while (i < documentIds.size()) { 259 int limit = (int) (((i + CollectionAsynchrnonousQuery.MAX_RESULT) > documentIds.size()) ? documentIds.size() 260 : (i + CollectionAsynchrnonousQuery.MAX_RESULT)); 261 DuplicateCollectionMemberWork work = new DuplicateCollectionMemberWork(collection.getRepositoryName(), 262 collection.getId(), documentIds.subList(i, limit), i); 263 WorkManager workManager = Framework.getService(WorkManager.class); 264 workManager.schedule(work, WorkManager.Scheduling.IF_NOT_SCHEDULED, true); 265 266 i = limit; 267 } 268 } 269 270 @Override 271 public void processRemovedCollection(final DocumentModel collection) { 272 final WorkManager workManager = Framework.getService(WorkManager.class); 273 final RemovedAbstractWork work = new RemovedCollectionWork(); 274 work.setDocument(collection.getRepositoryName(), collection.getId()); 275 workManager.schedule(work, WorkManager.Scheduling.IF_NOT_SCHEDULED, true); 276 } 277 278 @Override 279 public void processRemovedCollectionMember(final DocumentModel collectionMember) { 280 final WorkManager workManager = Framework.getService(WorkManager.class); 281 final RemovedAbstractWork work = new RemovedCollectionMemberWork(); 282 work.setDocument(collectionMember.getRepositoryName(), collectionMember.getId()); 283 workManager.schedule(work, WorkManager.Scheduling.IF_NOT_SCHEDULED, true); 284 } 285 286 @Override 287 public void processRestoredCollection(DocumentModel collection, DocumentModel version) { 288 final Set<String> collectionMemberIdsToBeRemoved = new TreeSet<>( 289 collection.getAdapter(Collection.class).getCollectedDocumentIds()); 290 collectionMemberIdsToBeRemoved.removeAll(version.getAdapter(Collection.class).getCollectedDocumentIds()); 291 292 final Set<String> collectionMemberIdsToBeAdded = new TreeSet<>( 293 version.getAdapter(Collection.class).getCollectedDocumentIds()); 294 collectionMemberIdsToBeAdded.removeAll(collection.getAdapter(Collection.class).getCollectedDocumentIds()); 295 296 int i = 0; 297 while (i < collectionMemberIdsToBeRemoved.size()) { 298 int limit = (int) (((i + CollectionAsynchrnonousQuery.MAX_RESULT) > collectionMemberIdsToBeRemoved.size()) 299 ? collectionMemberIdsToBeRemoved.size() : (i + CollectionAsynchrnonousQuery.MAX_RESULT)); 300 RemoveFromCollectionWork work = new RemoveFromCollectionWork(collection.getRepositoryName(), 301 collection.getId(), new ArrayList<>(collectionMemberIdsToBeRemoved).subList(i, limit), i); 302 WorkManager workManager = Framework.getService(WorkManager.class); 303 workManager.schedule(work, WorkManager.Scheduling.IF_NOT_SCHEDULED, true); 304 305 i = limit; 306 } 307 i = 0; 308 while (i < collectionMemberIdsToBeAdded.size()) { 309 int limit = (int) (((i + CollectionAsynchrnonousQuery.MAX_RESULT) > collectionMemberIdsToBeAdded.size()) 310 ? collectionMemberIdsToBeAdded.size() : (i + CollectionAsynchrnonousQuery.MAX_RESULT)); 311 DuplicateCollectionMemberWork work = new DuplicateCollectionMemberWork(collection.getRepositoryName(), 312 collection.getId(), new ArrayList<>(collectionMemberIdsToBeAdded).subList(i, limit), i); 313 WorkManager workManager = Framework.getService(WorkManager.class); 314 workManager.schedule(work, WorkManager.Scheduling.IF_NOT_SCHEDULED, true); 315 316 i = limit; 317 } 318 } 319 320 @Override 321 public void removeAllFromCollection(final DocumentModel collection, 322 final List<DocumentModel> documentListToBeRemoved, final CoreSession session) { 323 for (DocumentModel documentToBeRemoved : documentListToBeRemoved) { 324 removeFromCollection(collection, documentToBeRemoved, session); 325 } 326 } 327 328 @Override 329 public void removeFromCollection(final DocumentModel collection, final DocumentModel documentToBeRemoved, 330 final CoreSession session) { 331 checkCanAddToCollection(collection, documentToBeRemoved, session); 332 Map<String, Serializable> props = new HashMap<>(); 333 props.put(CollectionConstants.COLLECTION_REF_EVENT_CTX_PROP, new IdRef(collection.getId())); 334 fireEvent(documentToBeRemoved, session, CollectionConstants.BEFORE_REMOVED_FROM_COLLECTION, props); 335 Collection colAdapter = collection.getAdapter(Collection.class); 336 colAdapter.removeDocument(documentToBeRemoved.getId()); 337 session.saveDocument(colAdapter.getDocument()); 338 339 new UnrestrictedSessionRunner(session) { 340 341 @Override 342 public void run() { 343 doRemoveFromCollection(documentToBeRemoved, collection.getId(), session); 344 } 345 346 }.runUnrestricted(); 347 } 348 349 @Override 350 public void doRemoveFromCollection(DocumentModel documentToBeRemoved, String collectionId, CoreSession session) { 351 // We want to disable the following listener on a 352 // collection member when it is removed from a collection 353 disableEvents(documentToBeRemoved); 354 355 CollectionMember docAdapter = documentToBeRemoved.getAdapter(CollectionMember.class); 356 docAdapter.removeFromCollection(collectionId); 357 DocumentModel removedDoc = session.saveDocument(docAdapter.getDocument()); 358 Map<String, Serializable> props = new HashMap<>(); 359 props.put(CollectionConstants.COLLECTION_REF_EVENT_CTX_PROP, new IdRef(collectionId)); 360 fireEvent(removedDoc, session, CollectionConstants.REMOVED_FROM_COLLECTION, props); 361 } 362 363 @Override 364 public DocumentModel createCollection(final CoreSession session, String title, String description, String path) { 365 DocumentModel newCollection; 366 // Test if the path is null or empty 367 if (StringUtils.isEmpty(path)) { 368 // A default collection is created with the given name 369 newCollection = createCollection(title, description, null, session); 370 } else { 371 // If the path does not exist, an exception is thrown 372 if (!session.exists(new PathRef(path))) { 373 throw new NuxeoException(String.format("Path \"%s\" specified in parameter not found", path)); 374 } 375 // Create a new collection in the given path 376 DocumentModel collectionModel = session.createDocumentModel(path, title, 377 CollectionConstants.COLLECTION_TYPE); 378 collectionModel.setPropertyValue("dc:title", title); 379 collectionModel.setPropertyValue("dc:description", description); 380 newCollection = session.createDocument(collectionModel); 381 } 382 return newCollection; 383 } 384 385 protected void fireEvent(DocumentModel doc, CoreSession session, String eventName, 386 Map<String, Serializable> props) { 387 EventService eventService = Framework.getService(EventService.class); 388 DocumentEventContext ctx = new DocumentEventContext(session, session.getPrincipal(), doc); 389 ctx.setProperty(CoreEventConstants.REPOSITORY_NAME, session.getRepositoryName()); 390 ctx.setProperty("category", DocumentEventCategories.EVENT_DOCUMENT_CATEGORY); 391 ctx.setProperties(props); 392 Event event = ctx.newEvent(eventName); 393 eventService.fireEvent(event); 394 } 395 396 @Override 397 public boolean moveMembers(final CoreSession session, final DocumentModel collection, final DocumentModel member1, 398 final DocumentModel member2) { 399 checkCanCollectInCollection(collection, session); 400 Collection collectionAdapter = collection.getAdapter(Collection.class); 401 boolean result = collectionAdapter.moveMembers(member1.getId(), member2 != null ? member2.getId() : null); 402 if (result) { 403 session.saveDocument(collectionAdapter.getDocument()); 404 } 405 return result; 406 } 407 408}