@Test
public void shouldUnIndexSubTree() throws Exception {
buildAndIndexTree();
DocumentRef ref = new PathRef("/folder0/folder1/folder2");
Assert.assertTrue(session.exists(ref));
startTransaction();
session.removeDocument(ref);
TransactionHelper.commitOrRollbackTransaction();
waitForCompletion();
assertNumberOfCommandProcessed(1);
startTransaction();
SearchResponse searchResponse =
esa.getClient()
.prepareSearch(IDX_NAME)
.setTypes(TYPE_NAME)
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setFrom(0)
.setSize(60)
.execute()
.actionGet();
Assert.assertEquals(2, searchResponse.getHits().getTotalHits());
}
@Override
public void initTree(
String sid,
CoreSession coreSession,
Map<String, String> parameters,
PublishedDocumentFactory factory,
String configName,
String title) {
super.initTree(sid, coreSession, parameters, factory, configName, title);
DocumentRef ref = new PathRef(rootPath);
boolean exists = coreSession.exists(ref);
if (!exists) {
log.debug(
"Root section "
+ rootPath
+ " doesn't exist. Check "
+ "publicationTreeConfig with name "
+ configName);
}
if (exists && coreSession.hasPermission(ref, SecurityConstants.READ)) {
treeRoot = coreSession.getDocument(new PathRef(rootPath));
rootNode = new CoreFolderPublicationNode(treeRoot, getConfigName(), sid, factory);
} else {
rootNode =
new VirtualCoreFolderPublicationNode(
coreSession.getSessionId(), rootPath, getConfigName(), sid, factory);
sessionId = coreSession.getSessionId();
}
}
public DocumentModel getDocumentFor(String mainTabId, DocumentModel defaultDocument) {
DocumentModel doc = documentsByMainTabs.get(mainTabId);
if (doc == null
|| !documentManager.exists(doc.getRef())
|| !documentManager.hasPermission(doc.getRef(), SecurityConstants.READ)) {
documentsByMainTabs.put(mainTabId, defaultDocument);
doc = null;
}
if (doc != null && !documentManager.exists(new PathRef(doc.getPathAsString()))) {
// path has changed, refresh the document to have a correct URL
doc = documentManager.getDocument(doc.getRef());
documentsByMainTabs.put(mainTabId, doc);
}
return doc != null ? doc : defaultDocument;
}
@Test
public void shouldReindexSubTreeInTrash() throws Exception {
buildAndIndexTree();
startTransaction();
DocumentRef ref = new PathRef("/folder0/folder1/folder2");
Assert.assertTrue(session.exists(ref));
session.followTransition(ref, "delete");
TransactionHelper.commitOrRollbackTransaction();
// let the bulkLifeCycleChangeListener do its work
waitForCompletion();
assertNumberOfCommandProcessed(8);
startTransaction();
DocumentModelList docs =
ess.query(
new NxQueryBuilder(session)
.nxql("select * from Document where ecm:currentLifeCycleState != 'deleted'"));
// for (DocumentModel doc : docs) {
// System.out.println(doc.getPathAsString());
// }
Assert.assertEquals(2, docs.totalSize());
}
@Override
public void execute(CoreSession session) {
try {
DamService damService = Framework.getLocalService(DamService.class);
AssetLibrary assetLibrary = damService.getAssetLibrary();
if (assetLibrary != null) {
DocumentRef docRef = new PathRef(assetLibrary.getPath());
if (!session.exists(docRef)) {
Path path = new Path(assetLibrary.getPath());
String parentPath = path.removeLastSegments(1).toString();
String name = path.lastSegment();
DocumentModel doc =
session.createDocumentModel(parentPath, name, Constants.IMPORT_ROOT_TYPE);
doc.setPropertyValue(DC_TITLE, assetLibrary.getTitle());
doc.setPropertyValue(DC_DESCRIPTION, assetLibrary.getDescription());
session.createDocument(doc);
}
}
} catch (ClientException e) {
throw new ClientRuntimeException(e);
}
}
@Test
public void testIntegrationTestsSetupAndTearDown() throws Exception {
// ---------------------------------------------------------
// Setup the integration tests environment as Administrator
// ---------------------------------------------------------
Blob testUserCredentialsBlob =
(Blob)
clientSession
.newRequest(NuxeoDriveSetupIntegrationTests.ID)
.set("userNames", "joe,jack")
.execute();
assertNotNull(testUserCredentialsBlob);
// Check test users
String testUserCredentials = IOUtils.toString(testUserCredentialsBlob.getStream(), "UTF-8");
assertNotNull(testUserCredentials);
String[] testUserCrendentialsArray = StringUtils.split(testUserCredentials, ",");
assertEquals(2, testUserCrendentialsArray.length);
assertTrue(testUserCrendentialsArray[0].startsWith("nuxeoDriveTestUser_joe:"));
assertTrue(testUserCrendentialsArray[1].startsWith("nuxeoDriveTestUser_jack:"));
// useMembersGroup is false by default
NuxeoPrincipal joePrincipal = userManager.getPrincipal("nuxeoDriveTestUser_joe");
assertNotNull(joePrincipal);
assertFalse(joePrincipal.getGroups().contains("members"));
NuxeoPrincipal jackPrincipal = userManager.getPrincipal("nuxeoDriveTestUser_jack");
assertNotNull(jackPrincipal);
assertFalse(jackPrincipal.getGroups().contains("members"));
// Check test workspace
DocumentRef testWorkspaceRef = new PathRef(TEST_WORKSPACE_PATH);
DocumentModel testWorkspace = session.getDocument(testWorkspaceRef);
assertEquals("Workspace", testWorkspace.getType());
assertEquals("Nuxeo Drive Test Workspace", testWorkspace.getTitle());
assertTrue(session.hasPermission(joePrincipal, testWorkspaceRef, SecurityConstants.WRITE));
assertTrue(session.hasPermission(jackPrincipal, testWorkspaceRef, SecurityConstants.WRITE));
// Create test users' personal workspaces for cleanup check
userWorkspaceService.getUserPersonalWorkspace(
"nuxeoDriveTestUser_joe", session.getRootDocument());
userWorkspaceService.getUserPersonalWorkspace(
"nuxeoDriveTestUser_jack", session.getRootDocument());
assertNotNull(
session.getDocument(new PathRef(USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-joe")));
assertNotNull(
session.getDocument(new PathRef(USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-jack")));
// ----------------------------------------------------------------------
// Setup the integration tests environment with other user names without
// having teared it down previously => should start by cleaning it up
// ----------------------------------------------------------------------
testUserCredentialsBlob =
(Blob)
clientSession
.newRequest(NuxeoDriveSetupIntegrationTests.ID)
.set("userNames", "sarah")
.set("useMembersGroup", true)
.execute();
assertNotNull(testUserCredentialsBlob);
// Check cleanup
assertNull(userManager.getPrincipal("nuxeoDriveTestUser_joe"));
assertNull(userManager.getPrincipal("nuxeoDriveTestUser_jack"));
// Invalid VCS cache
session.save();
try {
session.getDocument(new PathRef(USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-joe"));
fail("User workspace should not exist.");
} catch (ClientException e) {
assertEquals(
"Failed to get document " + USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-joe",
e.getMessage());
}
try {
session.getDocument(new PathRef(USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-jack"));
fail("User workspace should not exist.");
} catch (ClientException e) {
assertEquals(
"Failed to get document " + USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-jack",
e.getMessage());
}
// Check test users
testUserCredentials = IOUtils.toString(testUserCredentialsBlob.getStream(), "UTF-8");
assertNotNull(testUserCredentials);
testUserCrendentialsArray = StringUtils.split(testUserCredentials, ",");
assertEquals(1, testUserCrendentialsArray.length);
assertTrue(testUserCrendentialsArray[0].startsWith("nuxeoDriveTestUser_sarah:"));
NuxeoPrincipal sarahPrincipal = userManager.getPrincipal("nuxeoDriveTestUser_sarah");
assertNotNull(sarahPrincipal);
assertTrue(sarahPrincipal.getGroups().contains("members"));
// Check test workspace
testWorkspace = session.getDocument(testWorkspaceRef);
assertEquals("Nuxeo Drive Test Workspace", testWorkspace.getTitle());
assertTrue(session.hasPermission(sarahPrincipal, testWorkspaceRef, SecurityConstants.WRITE));
// Create test users' personal workspaces for cleanup check
userWorkspaceService.getUserPersonalWorkspace(
"nuxeoDriveTestUser_sarah", session.getRootDocument());
assertNotNull(
session.getDocument(new PathRef(USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-sarah")));
// ----------------------------------------------------------------------
// Try to setup the integration tests environment as an unauthorized
// user => should fail
// ----------------------------------------------------------------------
Session unauthorizedSession =
automationClient.getSession("nuxeoDriveTestUser_sarah", testUserCrendentialsArray[0]);
try {
unauthorizedSession
.newRequest(NuxeoDriveSetupIntegrationTests.ID)
.set("userNames", "john,bob")
.execute();
fail(
"NuxeoDrive.SetupIntegrationTests operation should not be callable by a non administrator.");
} catch (Exception e) {
// Expected
}
// ----------------------------------------------------------------------
// Try to tear down the integration tests environment as an unauthorized
// user => should fail
// ----------------------------------------------------------------------
try {
unauthorizedSession.newRequest(NuxeoDriveTearDownIntegrationTests.ID).execute();
fail(
"NuxeoDrive.TearDownIntegrationTests operation should not be callable by a non administrator.");
} catch (Exception e) {
// Expected
}
// ----------------------------------------------------------------------
// Tear down the integration tests environment as Administrator
// ----------------------------------------------------------------------
clientSession.newRequest(NuxeoDriveTearDownIntegrationTests.ID).execute();
assertTrue(userManager.searchUsers("nuxeoDriveTestUser_").isEmpty());
// Invalid VCS cache
session.save();
try {
session.getDocument(new PathRef(USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-sarah"));
fail("User workspace should not exist.");
} catch (ClientException e) {
assertEquals(
"Failed to get document " + USER_WORKSPACE_PARENT_PATH + "/nuxeoDriveTestUser-sarah",
e.getMessage());
}
assertFalse(session.exists(testWorkspaceRef));
}
@SuppressWarnings({"unchecked", "boxing"})
public static AdditionalDocumentAuditParams getAuditParamsForUUID(
String uuid, CoreSession session) {
AdditionalDocumentAuditParams result = null;
IdRef ref = new IdRef(uuid);
if (session.exists(ref)) {
DocumentModel doc = session.getDocument(ref);
String targetUUID = null;
if (doc.isProxy() || doc.isVersion()) {
SourceDocumentResolver resolver = new SourceDocumentResolver(session, doc);
resolver.runUnrestricted();
if (resolver.sourceDocument != null) {
targetUUID = resolver.sourceDocument.getId();
// now get from Audit Logs the creation date of
// the version / proxy
AuditReader reader = Framework.getLocalService(AuditReader.class);
FilterMapEntry filter = new FilterMapEntry();
filter.setColumnName("eventId");
filter.setOperator("=");
filter.setQueryParameterName("eventId");
filter.setObject(DocumentEventTypes.DOCUMENT_CREATED);
Map<String, FilterMapEntry> filters = new HashMap<String, FilterMapEntry>();
filters.put("eventId", filter);
List<LogEntry> entries = reader.getLogEntriesFor(uuid, filters, false);
if (entries != null && entries.size() > 0) {
result = new AdditionalDocumentAuditParams();
result.maxDate = entries.get(0).getEventDate();
result.targetUUID = targetUUID;
result.eventId = entries.get(0).getId();
} else {
// we have no entry in audit log to get the maxDate
// fallback to repository timestamp
// this code is here only for compatibility
// so that it works before version events were added to
// the audit log
if (doc.getPropertyValue("dc:modified") != null) {
result = new AdditionalDocumentAuditParams();
Calendar estimatedDate = ((Calendar) doc.getPropertyValue("dc:modified"));
// We can not directly use the repo timestamp
// because Audit and VCS can be in separated DB
// => try to find the matching TS in Audit
StringBuilder queryString = new StringBuilder();
queryString.append("from LogEntry log where log.docUUID in (");
queryString.append("'" + targetUUID + "'");
if (doc.isVersion()) {
DocumentModelList proxies = session.getProxies(doc.getRef(), null);
for (DocumentModel proxy : proxies) {
queryString.append(",'" + proxy.getId() + "'");
}
}
queryString.append(",'" + doc.getId() + "'");
queryString.append(") AND log.eventId IN (");
queryString.append("'" + DocumentEventTypes.DOCUMENT_CREATED + "'");
queryString.append(",'" + DocumentEventTypes.DOCUMENT_CHECKEDIN + "'");
queryString.append(") AND log.eventDate >= :minDate ");
queryString.append(" order by log.eventId asc");
estimatedDate.add(Calendar.MILLISECOND, -500);
Map<String, Object> params = new HashMap<String, Object>();
params.put("minDate", estimatedDate.getTime());
List<LogEntry> dateEntries =
(List<LogEntry>) reader.nativeQuery(queryString.toString(), params, 0, 20);
if (dateEntries.size() > 0) {
result.targetUUID = targetUUID;
Calendar maxDate = new GregorianCalendar();
maxDate.setTime(dateEntries.get(0).getEventDate());
maxDate.add(Calendar.MILLISECOND, -500);
result.maxDate = maxDate.getTime();
} else {
// no other choice : use the VCS TS
// results may be truncated in some DB config
result.targetUUID = targetUUID;
result.maxDate = ((Calendar) doc.getPropertyValue("dc:modified")).getTime();
}
}
}
}
}
}
return result;
}
@Test
public void shouldIndexMovedSubTree() throws Exception {
buildAndIndexTree();
startTransaction();
DocumentRef ref = new PathRef("/folder0/folder1/folder2");
Assert.assertTrue(session.exists(ref));
DocumentModel doc = session.getDocument(ref);
// move in the same folder : rename
session.move(ref, doc.getParentRef(), "folderA");
TransactionHelper.commitOrRollbackTransaction();
waitForCompletion();
if (syncMode) {
// in sync we split recursive update into 2 commands:
// 1 sync non recurse + 1 async recursive
assertNumberOfCommandProcessed(9);
} else {
assertNumberOfCommandProcessed(8);
}
startTransaction();
SearchResponse searchResponse =
esa.getClient()
.prepareSearch(IDX_NAME)
.setTypes(TYPE_NAME)
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setFrom(0)
.setSize(60)
.execute()
.actionGet();
Assert.assertEquals(10, searchResponse.getHits().getTotalHits());
// check sub tree search
searchResponse =
esa.getClient()
.prepareSearch(IDX_NAME)
.setTypes(TYPE_NAME)
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setQuery(QueryBuilders.prefixQuery("ecm:path", "/folder0/folder1/folder2"))
.execute()
.actionGet();
Assert.assertEquals(0, searchResponse.getHits().getTotalHits());
searchResponse =
esa.getClient()
.prepareSearch(IDX_NAME)
.setTypes(TYPE_NAME)
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setQuery(QueryBuilders.prefixQuery("ecm:path", "/folder0/folder1/folderA"))
.execute()
.actionGet();
Assert.assertEquals(8, searchResponse.getHits().getTotalHits());
searchResponse =
esa.getClient()
.prepareSearch(IDX_NAME)
.setTypes(TYPE_NAME)
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setQuery(QueryBuilders.prefixQuery("ecm:path", "/folder0/folder1"))
.execute()
.actionGet();
Assert.assertEquals(9, searchResponse.getHits().getTotalHits());
}
protected void createNewDocument(Element el, DocConfigDescriptor conf) {
DocumentModel doc = session.createDocumentModel(conf.getDocType());
String path = resolvePath(el, conf.getParent());
Object nameOb = resolveName(el, conf.getName());
String name = null;
if (nameOb == null) {
if (log.isDebugEnabled()) {
log.debug(String.format(MSG_NO_ELEMENT_FOUND, conf.getName(), el.getUniquePath()));
}
int idx = 1;
for (int i = 0; i < docsStack.size(); i++) {
if (docsStack.get(i).getType().equals(conf.getDocType())) {
idx++;
}
}
name = conf.getDocType() + "-" + idx;
} else {
name = nameOb.toString();
}
doc.setPathInfo(path, name);
if (log.isDebugEnabled()) {
if (conf.getUpdate()) {
log.debug(String.format(MSG_UPDATE, path, name, el.getUniquePath(), conf.toString()));
} else {
log.debug(String.format(MSG_CREATION, path, name, el.getUniquePath(), conf.toString()));
}
}
try {
if (conf.getUpdate() && session.exists(doc.getRef())) {
DocumentModel existingDoc = session.getDocument(doc.getRef());
// get attributes, if attribute needs to be overwritten, empty in the document
for (Object e : el.elements()) {
List<AttributeConfigDescriptor> configs = getAttributConfigs((Element) e);
if (configs != null) {
if (!deletedAttributes.containsKey(existingDoc.getId())) {
deletedAttributes.put(existingDoc.getId(), new ArrayList<String>());
}
for (AttributeConfigDescriptor config : configs) {
String targetDocProperty = config.getTargetDocProperty();
// check deletedAttributes for attribute which should be overwritten
// if it is there, don't empty it a second time
if (config.overwrite
&& !deletedAttributes.get(existingDoc.getId()).contains(targetDocProperty)) {
deletedAttributes.get(existingDoc.getId()).add(targetDocProperty);
existingDoc.setPropertyValue(targetDocProperty, new ArrayList<>());
}
}
}
}
doc = existingDoc;
} else {
doc = session.createDocument(doc);
}
} catch (NuxeoException e) {
e.addInfo(String.format(MSG_CREATION, path, name, el.getUniquePath(), conf.toString()));
throw e;
}
pushInStack(doc);
elToDoc.put(el, doc);
}
