@Override
public EntityReference getDefaultReference(EntityType type) {
EntityReference result = null;
XWikiContext xcontext = this.xcontextProvider.get();
if (xcontext != null) {
if (type == EntityType.WIKI) {
result = xcontext.getWikiReference();
} else if (type == EntityType.SPACE) {
XWikiDocument currentDoc = xcontext.getDoc();
if (currentDoc != null) {
SpaceReference spaceReference = currentDoc.getDocumentReference().getLastSpaceReference();
// Keep only the spaces part
result = spaceReference.removeParent(spaceReference.getWikiReference());
}
} else if (type == EntityType.DOCUMENT) {
XWikiDocument currentDoc = xcontext.getDoc();
if (currentDoc != null) {
DocumentReference documentReference = currentDoc.getDocumentReference();
// Keep only the document part
result = documentReference.removeParent(documentReference.getLastSpaceReference());
}
}
}
if (result == null) {
result = super.getDefaultReference(type);
}
return result;
}
/**
* Verify that {@link XWiki#rollback(XWikiDocument, String, XWikiContext)} fires the right events.
*/
@Test
public void rollbackFiresEvents() throws Exception {
ObservationManager observationManager = mocker.getInstance(ObservationManager.class);
DocumentReference documentReference = new DocumentReference("wiki", "Space", "Page");
XWikiDocument document = mock(XWikiDocument.class);
when(document.getDocumentReference()).thenReturn(documentReference);
XWikiDocument originalDocument = mock(XWikiDocument.class);
// Mark the document as existing so that the roll-back method will fire an update event.
when(originalDocument.isNew()).thenReturn(false);
XWikiDocument result = mock(XWikiDocument.class);
when(result.clone()).thenReturn(result);
when(result.getDocumentReference()).thenReturn(documentReference);
when(result.getOriginalDocument()).thenReturn(originalDocument);
String revision = "3.5";
when(xwiki.getVersioningStore().loadXWikiDoc(document, revision, context)).thenReturn(result);
this.mocker.registerMockComponent(ContextualLocalizationManager.class);
xwiki.rollback(document, revision, context);
verify(observationManager)
.notify(new DocumentRollingBackEvent(documentReference, revision), result, context);
verify(observationManager)
.notify(new DocumentUpdatingEvent(documentReference), result, context);
verify(observationManager).notify(new DocumentUpdatedEvent(documentReference), result, context);
verify(observationManager)
.notify(new DocumentRolledBackEvent(documentReference, revision), result, context);
}
@Before
public void setUp_AbstractDocumentUpdateListenerTest() throws Exception {
context = getContext();
classRef = new DocumentReference("wiki", "Classes", "SomeClass");
fields = Arrays.asList("field1", "field2");
docRef = new DocumentReference("wiki", "Space", "SomeDoc");
docMock = createMockAndAddToDefault(XWikiDocument.class);
expect(docMock.getDocumentReference()).andReturn(docRef).anyTimes();
origDocMock = createMockAndAddToDefault(XWikiDocument.class);
expect(origDocMock.getDocumentReference()).andReturn(docRef).anyTimes();
expect(docMock.getOriginalDocument()).andReturn(origDocMock).anyTimes();
listener = new TestDocumentUpdateListener();
listener.injectWebUtilsService(Utils.getComponent(IWebUtilsService.class));
listener.injecExecution(Utils.getComponent(Execution.class));
listener.injectCopyDocService(Utils.getComponent(ICopyDocumentRole.class));
listener.injectRemoteObservationManagerContext(
remoteObsManContextMock = createMockAndAddToDefault(RemoteObservationManagerContext.class));
listener.injectObservationManager(
obsManagerMock = createMockAndAddToDefault(ObservationManager.class));
listener.configSrc = Utils.getComponent(ConfigurationSource.class);
creatingEventMock = createMockAndAddToDefault(Event.class);
createdEventMock = createMockAndAddToDefault(Event.class);
updatingEventMock = createMockAndAddToDefault(Event.class);
updatedEventMock = createMockAndAddToDefault(Event.class);
deletingEventMock = createMockAndAddToDefault(Event.class);
deletedEventMock = createMockAndAddToDefault(Event.class);
}
@Test
public void getMembersWhenGroupIsLooping() throws Exception {
setUpBaseMocks();
DocumentReference groupReference = new DocumentReference("groupwiki", "XWiki", "grouppage");
XWikiDocument document = mock(XWikiDocument.class);
when(document.isNew()).thenReturn(false);
when(document.getDocumentReference()).thenReturn(groupReference);
when(xwiki.getDocument(groupReference, this.xwikiContext)).thenReturn(document);
List<BaseObject> memberObjects = new ArrayList<>();
BaseObject bo = mock(BaseObject.class);
when(bo.getStringValue("member")).thenReturn("XWiki.othergroup");
memberObjects.add(bo);
bo = mock(BaseObject.class);
when(bo.getStringValue("member")).thenReturn("XWiki.userpage");
memberObjects.add(bo);
when(document.getXObjects(new DocumentReference("groupwiki", "XWiki", "XWikiGroups")))
.thenReturn(memberObjects);
DocumentReference userpageReference = new DocumentReference("groupwiki", "XWiki", "userpage");
setUpUserPageMocks(userpageReference);
when(this.resolver.resolve("XWiki.userpage", groupReference)).thenReturn(userpageReference);
DocumentReference otherGroupReference =
new DocumentReference("groupwiki", "XWiki", "othergroup");
document = mock(XWikiDocument.class);
when(document.isNew()).thenReturn(false);
when(document.getDocumentReference()).thenReturn(otherGroupReference);
when(xwiki.getDocument(otherGroupReference, this.xwikiContext)).thenReturn(document);
memberObjects = new ArrayList<>();
bo = mock(BaseObject.class);
when(bo.getStringValue("member")).thenReturn("XWiki.grouppage");
memberObjects.add(bo);
bo = mock(BaseObject.class);
when(bo.getStringValue("member")).thenReturn("XWiki.anotheruser");
memberObjects.add(bo);
when(document.getXObjects(new DocumentReference("groupwiki", "XWiki", "XWikiGroups")))
.thenReturn(memberObjects);
DocumentReference anotheruserReference =
new DocumentReference("groupwiki", "XWiki", "anotheruser");
setUpUserPageMocks(anotheruserReference);
when(this.resolver.resolve("XWiki.anotheruser", otherGroupReference))
.thenReturn(anotheruserReference);
when(this.resolver.resolve("XWiki.grouppage", otherGroupReference)).thenReturn(groupReference);
when(this.resolver.resolve("XWiki.othergroup", groupReference)).thenReturn(otherGroupReference);
Iterator<DocumentReference> iterator =
new ReferenceUserIterator(groupReference, this.resolver, this.execution);
assertThat(
(List<DocumentReference>) IteratorUtils.toList(iterator),
containsInAnyOrder(userpageReference, anotheruserReference));
}
/**
* Load document files from provided directory and sub-directories into packager.
*
* @param dir the directory from where to load documents.
* @param context the XWiki context.
* @param description the package descriptor.
* @return the number of loaded documents.
* @throws IOException error when loading documents.
* @throws XWikiException error when loading documents.
*/
public int readFromDir(File dir, XWikiContext context, Document description)
throws IOException, XWikiException {
File[] files = dir.listFiles();
SAXReader reader = new SAXReader();
int count = 0;
for (int i = 0; i < files.length; ++i) {
File file = files[i];
if (file.isDirectory()) {
count += readFromDir(file, context, description);
} else {
boolean validWikiDoc = false;
Document domdoc = null;
try {
domdoc = reader.read(new FileInputStream(file));
validWikiDoc = XWikiDocument.containsXMLWikiDocument(domdoc);
} catch (DocumentException e1) {
}
if (validWikiDoc) {
XWikiDocument doc = readFromXML(domdoc);
try {
filter(doc, context);
if (documentExistInPackageFile(doc.getFullName(), doc.getLanguage(), description)) {
add(doc, context);
++count;
} else {
throw new PackageException(
XWikiException.ERROR_XWIKI_UNKNOWN,
"document "
+ doc.getDocumentReference()
+ " does not exist in package definition");
}
} catch (ExcludeDocumentException e) {
LOGGER.info("Skip the document '" + doc.getDocumentReference() + "'");
}
} else if (!file.getName().equals(DefaultPackageFileName)) {
LOGGER.info(file.getAbsolutePath() + " is not a valid wiki document");
}
}
}
return count;
}
private Map<AccessLevel, List<DocumentReference>> getCollaborators(XWikiDocument doc) {
Map<AccessLevel, List<DocumentReference>> collaborators =
new LinkedHashMap<AccessLevel, List<DocumentReference>>();
List<BaseObject> collaboratorObjects = doc.getXObjects(Collaborator.CLASS_REFERENCE);
if (collaboratorObjects == null || collaboratorObjects.isEmpty()) {
return Collections.emptyMap();
}
for (BaseObject collaborator : collaboratorObjects) {
if (collaborator == null) {
continue;
}
String collaboratorName = collaborator.getStringValue("collaborator");
String accessName = collaborator.getStringValue("access");
if (StringUtils.isBlank(collaboratorName) || StringUtils.isBlank(accessName)) {
continue;
}
DocumentReference userOrGroup =
this.stringEntityResolver.resolve(collaboratorName, doc.getDocumentReference());
AccessLevel access = this.manager.resolveAccessLevel(accessName);
List<DocumentReference> list = collaborators.get(access);
if (list == null) {
list = new LinkedList<DocumentReference>();
collaborators.put(access, list);
}
list.add(userOrGroup);
}
return collaborators;
}
/**
* Generate a relative path based on provided document for the directory where the document should
* be stored.
*
* @param doc the document to export
* @return the corresponding path
*/
public String getDirectoryForDocument(XWikiDocument doc) {
StringBuilder path = new StringBuilder();
for (SpaceReference space : doc.getDocumentReference().getSpaceReferences()) {
path.append(space.getName()).append('/');
}
return path.toString();
}
private void addWikiTranslation(String key, String message, Locale locale) throws XWikiException {
XWikiDocument document =
this.oldcore
.getMockXWiki()
.getDocument(this.defaultWikiTranslationReference, this.oldcore.getXWikiContext());
if (!locale.equals(Locale.ROOT)) {
XWikiDocument translatedDocument =
document.getTranslatedDocument(locale, this.oldcore.getXWikiContext());
if (translatedDocument == document) {
translatedDocument = new XWikiDocument(document.getDocumentReference(), locale);
translatedDocument.setDefaultLocale(document.getDefaultLocale());
}
document = translatedDocument;
}
document.setSyntax(Syntax.PLAIN_1_0);
StringBuilder builder = new StringBuilder(document.getContent());
builder.append('\n');
builder.append(key);
builder.append('=');
builder.append(message);
document.setContent(builder.toString());
this.oldcore.getMockXWiki().saveDocument(document, "", this.oldcore.getXWikiContext());
setBundles(document.getFullName());
}
@Test
public void getMembersWhenSingleUserButBothUserAndGroupReference() throws Exception {
setUpBaseMocks();
DocumentReference reference = new DocumentReference("wiki", "XWiki", "page");
XWikiDocument document = mock(XWikiDocument.class);
when(document.isNew()).thenReturn(false);
when(document.getDocumentReference()).thenReturn(reference);
when(this.xwiki.getDocument(reference, this.xwikiContext)).thenReturn(document);
// It's a user reference
BaseObject bo1 = mock(BaseObject.class);
when(document.getXObject(new DocumentReference("wiki", "XWiki", "XWikiUsers"))).thenReturn(bo1);
// It's also a group reference (with one user in it)
List<BaseObject> memberObjects = new ArrayList<>();
BaseObject bo2 = mock(BaseObject.class);
when(bo2.getStringValue("member")).thenReturn("XWiki.user");
memberObjects.add(bo2);
when(document.getXObjects(new DocumentReference("wiki", "XWiki", "XWikiGroups")))
.thenReturn(memberObjects);
DocumentReference userReference = new DocumentReference("wiki", "XWiki", "user");
when(this.resolver.resolve("XWiki.user", reference)).thenReturn(userReference);
setUpUserPageMocks(userReference);
Iterator<DocumentReference> iterator =
new ReferenceUserIterator(reference, this.resolver, this.execution);
assertTrue(iterator.hasNext());
assertEquals(new DocumentReference("wiki", "XWiki", "page"), iterator.next());
assertTrue(iterator.hasNext());
assertEquals(new DocumentReference("wiki", "XWiki", "user"), iterator.next());
assertFalse(iterator.hasNext());
}
@Test
public void deleteAllDocumentsAndWithoutSendingToTrash() throws Exception {
XWiki xwiki = new XWiki();
XWikiDocument document = mock(XWikiDocument.class);
DocumentReference reference = new DocumentReference("wiki", "space", "page");
when(document.getDocumentReference()).thenReturn(reference);
// Make sure we have a trash for the test.
XWikiRecycleBinStoreInterface recycleBinStoreInterface =
mock(XWikiRecycleBinStoreInterface.class);
xwiki.setRecycleBinStore(recycleBinStoreInterface);
when(xwikiCfgConfigurationSource.getProperty("xwiki.recyclebin", "1")).thenReturn("1");
// Configure the mocked Store to later verify if it's called
XWikiStoreInterface storeInterface = mock(XWikiStoreInterface.class);
xwiki.setStore(storeInterface);
XWikiContext xwikiContext = mock(XWikiContext.class);
xwiki.deleteAllDocuments(document, false, xwikiContext);
// Verify that saveToRecycleBin is never called since otherwise it would mean the doc has been
// saved in the
// trash
verify(recycleBinStoreInterface, never())
.saveToRecycleBin(
any(XWikiDocument.class),
any(String.class),
any(Date.class),
any(XWikiContext.class),
any(Boolean.class));
// Verify that deleteXWikiDoc() is called
verify(storeInterface).deleteXWikiDoc(document, xwikiContext);
}
@Test
public void onEventWithExceptions() throws ComponentLookupException, XWikiException {
Utils.setComponentManager(this.mocker);
DocumentReference docReference = new DocumentReference("xwiki", "Groups", "Group1");
XWikiContext context = mock(XWikiContext.class);
XWiki xwiki = mock(XWiki.class);
when(context.getWiki()).thenReturn(xwiki);
XWikiDocument doc = mock(XWikiDocument.class);
when(doc.getDocumentReference()).thenReturn(docReference);
when(doc.getXObject(Group.CLASS_REFERENCE)).thenReturn(mock(BaseObject.class));
DocumentReference adminsDocReference =
new DocumentReference("xwiki", "Groups", "Group1 Administrators");
when(xwiki.getDocument(eq(adminsDocReference), eq(context)))
.thenThrow(new XWikiException(0, 0, "DB Error"));
DocumentAccessBridge dab = this.mocker.getInstance(DocumentAccessBridge.class);
DocumentReference userReference = new DocumentReference("xwiki", "XWiki", "User");
when(dab.getCurrentUserReference()).thenReturn(userReference);
this.mocker
.getComponentUnderTest()
.onEvent(new DocumentCreatingEvent(docReference), doc, context);
Mockito.verify(xwiki, Mockito.never())
.saveDocument(eq(doc), any(String.class), any(Boolean.class), eq(context));
Mockito.verify(doc).getXObject(Group.CLASS_REFERENCE);
Mockito.verify(doc).getDocumentReference();
Mockito.verifyNoMoreInteractions(doc);
}
/**
* @see "XWIKI-9399: Attachment version is incremented when a document is rolled back even if the
* attachment did not change"
*/
@Test
public void rollbackDoesNotSaveUnchangedAttachment() throws Exception {
String version = "1.1";
String fileName = "logo.png";
Date date = new Date();
XWikiAttachment currentAttachment = mock(XWikiAttachment.class);
when(currentAttachment.getAttachmentRevision(version, context)).thenReturn(currentAttachment);
when(currentAttachment.getDate()).thenReturn(new Timestamp(date.getTime()));
when(currentAttachment.getVersion()).thenReturn(version);
when(currentAttachment.getFilename()).thenReturn(fileName);
XWikiAttachment oldAttachment = mock(XWikiAttachment.class);
when(oldAttachment.getFilename()).thenReturn(fileName);
when(oldAttachment.getVersion()).thenReturn(version);
when(oldAttachment.getDate()).thenReturn(date);
DocumentReference documentReference = new DocumentReference("wiki", "Space", "Page");
XWikiDocument document = mock(XWikiDocument.class);
when(document.getDocumentReference()).thenReturn(documentReference);
when(document.getAttachmentList()).thenReturn(Arrays.asList(currentAttachment));
when(document.getAttachment(fileName)).thenReturn(currentAttachment);
XWikiDocument result = mock(XWikiDocument.class);
when(result.clone()).thenReturn(result);
when(result.getDocumentReference()).thenReturn(documentReference);
when(result.getAttachmentList()).thenReturn(Arrays.asList(oldAttachment));
when(result.getAttachment(fileName)).thenReturn(oldAttachment);
String revision = "3.5";
when(xwiki.getVersioningStore().loadXWikiDoc(document, revision, context)).thenReturn(result);
AttachmentRecycleBinStore attachmentRecycleBinStore = mock(AttachmentRecycleBinStore.class);
xwiki.setAttachmentRecycleBinStore(attachmentRecycleBinStore);
DocumentReference reference = document.getDocumentReference();
this.mocker.registerMockComponent(ContextualLocalizationManager.class);
when(xwiki.getStore().loadXWikiDoc(any(XWikiDocument.class), same(context)))
.thenReturn(new XWikiDocument(reference));
xwiki.rollback(document, revision, context);
verify(attachmentRecycleBinStore, never())
.saveToRecycleBin(
same(currentAttachment), any(String.class), any(Date.class), same(context), eq(true));
verify(oldAttachment, never()).setMetaDataDirty(true);
}
@Override
public boolean checkAccess(String action, XWikiDocument doc, XWikiContext context)
throws XWikiException {
DocumentReference userReference = getCurrentUser(context);
User user =
this.userManager.getUser(userReference != null ? userReference.toString() : null, true);
boolean result =
this.service.hasAccess(user, actionToRight(action), doc.getDocumentReference());
if (!result && context.getUserReference() == null && !"login".equals(context.getAction())) {
this.logger.debug(
"Redirecting unauthenticated user to login, since it have been denied [{}] on [{}].",
actionToRight(action),
doc.getDocumentReference());
context.getWiki().getAuthService().showLogin(context);
}
return result;
}
@Test
public void onEvent() throws ComponentLookupException, XWikiException {
Utils.setComponentManager(this.mocker);
DocumentReference docReference = new DocumentReference("xwiki", "Groups", "Group1");
XWikiContext context = mock(XWikiContext.class);
XWiki xwiki = mock(XWiki.class);
when(context.getWiki()).thenReturn(xwiki);
XWikiDocument doc = mock(XWikiDocument.class);
when(doc.getDocumentReference()).thenReturn(docReference);
BaseObject groupObject = new BaseObject();
BaseObject rightsObject = new BaseObject();
when(doc.newXObject(eq(this.groupsClassReference), eq(context))).thenReturn(groupObject);
when(doc.newXObject(eq(this.rightsClassReference), eq(context))).thenReturn(rightsObject);
when(doc.getXObject(Group.CLASS_REFERENCE)).thenReturn(mock(BaseObject.class));
DocumentReference adminsDocReference =
new DocumentReference("xwiki", "Groups", "Group1 Administrators");
XWikiDocument adminsDoc = mock(XWikiDocument.class);
BaseObject adminsGroupObject = new BaseObject();
BaseObject adminsRightsObject = new BaseObject();
when(adminsDoc.newXObject(eq(this.groupsClassReference), eq(context)))
.thenReturn(adminsGroupObject);
when(adminsDoc.newXObject(eq(this.rightsClassReference), eq(context)))
.thenReturn(adminsRightsObject);
when(xwiki.getDocument(eq(adminsDocReference), eq(context))).thenReturn(adminsDoc);
DocumentAccessBridge dab = this.mocker.getInstance(DocumentAccessBridge.class);
DocumentReference userReference = new DocumentReference("xwiki", "XWiki", "User");
when(dab.getCurrentUserReference()).thenReturn(userReference);
this.mocker
.getComponentUnderTest()
.onEvent(new DocumentCreatingEvent(docReference), doc, context);
Mockito.verify(xwiki).saveDocument(eq(adminsDoc), any(String.class), eq(true), eq(context));
Mockito.verify(xwiki, Mockito.never())
.saveDocument(eq(doc), any(String.class), any(Boolean.class), eq(context));
Assert.assertEquals(1, rightsObject.getIntValue("allow"));
Assert.assertEquals("edit", rightsObject.getStringValue("levels"));
Assert.assertEquals(
"xwiki:Groups.Group1 Administrators", rightsObject.getLargeStringValue("groups"));
Assert.assertEquals("", rightsObject.getLargeStringValue("users"));
Assert.assertEquals(1, adminsRightsObject.getIntValue("allow"));
Assert.assertEquals("edit", adminsRightsObject.getStringValue("levels"));
Assert.assertEquals(
"xwiki:Groups.Group1 Administrators", adminsRightsObject.getLargeStringValue("groups"));
Assert.assertEquals("", adminsRightsObject.getLargeStringValue("users"));
Assert.assertEquals("xwiki:Groups.Group1 Administrators", groupObject.getStringValue("member"));
Assert.assertEquals("xwiki:XWiki.User", adminsGroupObject.getStringValue("member"));
}
/**
* Add rendered document to ZIP stream.
*
* @param pageName the name (used with {@link com.xpn.xwiki.XWiki#getDocument(String,
* XWikiContext)}) of the page to render.
* @param zos the ZIP output stream.
* @param context the XWiki context.
* @param vcontext the Velocity context.
* @throws XWikiException error when rendering document.
* @throws IOException error when rendering document.
*/
private void renderDocument(
String pageName, ZipOutputStream zos, XWikiContext context, VelocityContext vcontext)
throws XWikiException, IOException {
@SuppressWarnings("unchecked")
EntityReferenceResolver<String> resolver = Utils.getComponent(EntityReferenceResolver.class);
DocumentReference docReference =
new DocumentReference(resolver.resolve(pageName, EntityType.DOCUMENT));
XWikiDocument doc = context.getWiki().getDocument(docReference, context);
String zipname = doc.getDocumentReference().getWikiReference().getName();
for (EntityReference space : doc.getDocumentReference().getSpaceReferences()) {
zipname += POINT + space.getName();
}
zipname += POINT + doc.getDocumentReference().getName();
String language = doc.getLanguage();
if (language != null && language.length() != 0) {
zipname += POINT + language;
}
zipname += ".html";
ZipEntry zipentry = new ZipEntry(zipname);
zos.putNextEntry(zipentry);
String originalDatabase = context.getDatabase();
try {
context.setDatabase(doc.getDocumentReference().getWikiReference().getName());
context.setDoc(doc);
vcontext.put(VCONTEXT_DOC, doc.newDocument(context));
vcontext.put(VCONTEXT_CDOC, vcontext.get(VCONTEXT_DOC));
XWikiDocument tdoc = doc.getTranslatedDocument(context);
context.put(CONTEXT_TDOC, tdoc);
vcontext.put(VCONTEXT_TDOC, tdoc.newDocument(context));
String content = context.getWiki().evaluateTemplate("view.vm", context);
zos.write(content.getBytes(context.getWiki().getEncoding()));
zos.closeEntry();
} finally {
context.setDatabase(originalDatabase);
}
}
private String export(String format, XWikiContext context) throws XWikiException, IOException {
// We currently use the PDF export infrastructure but we have to redesign the export code.
XWikiURLFactory urlFactory = new OfficeExporterURLFactory();
PdfExport exporter = new OfficeExporter();
// Check if the office exporter supports the specified format.
ExportType exportType = ((OfficeExporter) exporter).getExportType(format);
// Note 1: exportType will be null if no office server is started or it doesn't support the
// passed format
// Note 2: we don't use the office server for PDF exports since it doesn't work OOB. Instead we
// use FOP.
if ("pdf".equalsIgnoreCase(format)) {
// The export format is PDF or the office converter can't be used (either it doesn't support
// the specified
// format or the office server is not started).
urlFactory = new PdfURLFactory();
exporter = new PdfExportImpl();
exportType = ExportType.PDF;
} else if (exportType == null) {
context.put("message", "core.export.formatUnknown");
return "exception";
}
urlFactory.init(context);
context.setURLFactory(urlFactory);
handleRevision(context);
XWikiDocument doc = context.getDoc();
context.getResponse().setContentType(exportType.getMimeType());
context
.getResponse()
.addHeader(
"Content-disposition",
String.format(
"inline; filename=%s_%s.%s",
Util.encodeURI(
doc.getDocumentReference().getLastSpaceReference().getName(), context),
Util.encodeURI(doc.getDocumentReference().getName(), context),
exportType.getExtension()));
exporter.export(doc, context.getResponse().getOutputStream(), exportType, context);
return null;
}
private void setUpUserPageMocks(DocumentReference userReference) throws Exception {
XWikiDocument document = mock(XWikiDocument.class);
when(document.isNew()).thenReturn(false);
when(document.getDocumentReference()).thenReturn(userReference);
BaseObject baseObject = mock(BaseObject.class);
when(document.getXObject(
new DocumentReference(
userReference.getWikiReference().getName(), "XWiki", "XWikiUsers")))
.thenReturn(baseObject);
when(this.xwiki.getDocument(userReference, this.xwikiContext)).thenReturn(document);
}
private void removeExistingDescriptor(XWikiDocument document) {
List<BaseObject> existingServerClassObjects = document.getXObjects(SERVER_CLASS);
if (existingServerClassObjects != null && !existingServerClassObjects.isEmpty()) {
String wikiId =
wikiDescriptorDocumentHelper.getWikiIdFromDocumentReference(
document.getDocumentReference());
DefaultWikiDescriptor existingDescriptor = cache.getFromId(wikiId);
if (existingDescriptor != null) {
cache.remove(existingDescriptor);
}
}
}
public void addToDir(XWikiDocument doc, File dir, boolean withVersions, XWikiContext context)
throws XWikiException {
try {
filter(doc, context);
File spacedir = new File(dir, getDirectoryForDocument(doc));
if (!spacedir.exists()) {
if (!spacedir.mkdirs()) {
Object[] args = new Object[1];
args[0] = dir.toString();
throw new XWikiException(
XWikiException.MODULE_XWIKI,
XWikiException.ERROR_XWIKI_MKDIR,
"Error creating directory {0}",
null,
args);
}
}
String filename = getFileNameFromDocument(doc, context);
File file = new File(spacedir, filename);
FileOutputStream fos = new FileOutputStream(file);
doc.toXML(fos, true, false, true, withVersions, context);
fos.flush();
fos.close();
} catch (ExcludeDocumentException e) {
LOGGER.info("Skip the document " + doc.getDocumentReference());
} catch (Exception e) {
Object[] args = new Object[1];
args[0] = doc.getDocumentReference();
throw new XWikiException(
XWikiException.MODULE_XWIKI_DOC,
XWikiException.ERROR_XWIKI_DOC_EXPORT,
"Error creating file {0}",
e,
args);
}
}
/**
* Generate a file name based on provided document.
*
* @param doc the document to export.
* @return the corresponding file name.
*/
public String getFileNameFromDocument(XWikiDocument doc, XWikiContext context) {
StringBuffer fileName = new StringBuffer(doc.getDocumentReference().getName());
// Add language
String language = doc.getLanguage();
if ((language != null) && (!language.equals(""))) {
fileName.append(".");
fileName.append(language);
}
// Add extension
fileName.append('.').append(DEFAULT_FILEEXT);
return fileName.toString();
}
@Override
public boolean hasProgrammingRights(XWikiDocument doc, XWikiContext context) {
DocumentReference user;
WikiReference wiki;
if (doc != null) {
user = doc.getContentAuthorReference();
wiki = doc.getDocumentReference().getWikiReference();
} else {
user = context.getUserReference();
wiki = new WikiReference(context.getDatabase());
}
return authorizationManager.hasAccess(Right.PROGRAM, user, wiki);
}
@Test
public void getMembersWhenSingleReferenceNotAUser() throws Exception {
setUpBaseMocks();
XWikiDocument document = mock(XWikiDocument.class);
when(document.isNew()).thenReturn(false);
DocumentReference reference = new DocumentReference("somewiki", "XWiki", "somepage");
when(document.getDocumentReference()).thenReturn(reference);
when(document.getXObject(new DocumentReference("somewiki", "XWiki", "XWikiUsers")))
.thenReturn(null);
when(this.xwiki.getDocument(reference, this.xwikiContext)).thenReturn(document);
Iterator<DocumentReference> iterator =
new ReferenceUserIterator(reference, null, this.execution);
assertFalse(iterator.hasNext());
}
@Test
public void getMembersWhenGroupWithNullMember() throws Exception {
setUpBaseMocks();
DocumentReference groupReference = new DocumentReference("groupwiki", "XWiki", "grouppage");
XWikiDocument document = mock(XWikiDocument.class);
when(document.isNew()).thenReturn(false);
when(document.getDocumentReference()).thenReturn(groupReference);
when(xwiki.getDocument(groupReference, this.xwikiContext)).thenReturn(document);
List<BaseObject> memberObjects = new ArrayList<>();
memberObjects.add(null);
when(document.getXObjects(new DocumentReference("groupwiki", "XWiki", "XWikiGroups")))
.thenReturn(memberObjects);
Iterator<DocumentReference> iterator =
new ReferenceUserIterator(groupReference, this.resolver, this.execution);
assertFalse(iterator.hasNext());
}
/**
* Gets the translated version of a document, in the specified language. If the translation does
* not exist, a new document translation is created. If the requested language does not correspond
* to a translation (is not defined or is the same as the main document), then the main document
* is returned.
*
* @param doc the main (default, untranslated) document to translate
* @param language the requested document language
* @param context the current request context
* @return the translated document, or the original untranslated document if the requested
* language is not a translation
* @throws XWikiException if the translation cannot be retrieved from the database
*/
protected XWikiDocument getTranslatedDocument(
XWikiDocument doc, String language, XWikiContext context) throws XWikiException {
XWikiDocument tdoc;
if (StringUtils.isBlank(language)
|| language.equals("default")
|| language.equals(doc.getDefaultLanguage())) {
tdoc = doc;
} else {
tdoc = doc.getTranslatedDocument(language, context);
if (tdoc == doc) {
tdoc = new XWikiDocument(doc.getDocumentReference());
tdoc.setLanguage(language);
tdoc.setStore(doc.getStore());
}
tdoc.setTranslation(1);
}
return tdoc;
}
public boolean add(XWikiDocument doc, int defaultAction, XWikiContext context)
throws XWikiException {
if (!context.getWiki().checkAccess("edit", doc, context)) {
return false;
}
for (int i = 0; i < this.files.size(); i++) {
DocumentInfo di = this.files.get(i);
if (di.getFullName().equals(doc.getFullName())
&& (di.getLanguage().equals(doc.getLanguage()))) {
if (defaultAction != DocumentInfo.ACTION_NOT_DEFINED) {
di.setAction(defaultAction);
}
if (!doc.isNew()) {
di.setDoc(doc);
}
return true;
}
}
doc = doc.clone();
try {
filter(doc, context);
DocumentInfo docinfo = new DocumentInfo(doc);
docinfo.setAction(defaultAction);
this.files.add(docinfo);
BaseClass bclass = doc.getXClass();
if (bclass.getFieldList().size() > 0) {
this.classFiles.add(docinfo);
}
if (bclass.getCustomMapping() != null) {
this.customMappingFiles.add(docinfo);
}
return true;
} catch (ExcludeDocumentException e) {
LOGGER.info("Skip the document " + doc.getDocumentReference());
return false;
}
}
@Test
public void onEventWithTemplate() throws ComponentLookupException, XWikiException {
Utils.setComponentManager(this.mocker);
DocumentReference docReference =
new DocumentReference("xwiki", "PhenoTips", "PhenoTipsGroupTemplate");
XWikiContext context = mock(XWikiContext.class);
XWikiDocument doc = mock(XWikiDocument.class);
when(doc.getXObject(Group.CLASS_REFERENCE)).thenReturn(mock(BaseObject.class));
when(doc.getDocumentReference()).thenReturn(docReference);
this.mocker
.getComponentUnderTest()
.onEvent(new DocumentCreatingEvent(docReference), doc, context);
Mockito.verifyZeroInteractions(context);
Mockito.verify(doc).getXObject(Group.CLASS_REFERENCE);
Mockito.verify(doc).getDocumentReference();
Mockito.verifyNoMoreInteractions(doc);
}
private void renameLinks(
XWikiDocument document, DocumentReference oldTarget, DocumentReference newTarget)
throws XWikiException {
DocumentReference currentDocumentReference = document.getDocumentReference();
// We support only the syntaxes for which there is an available renderer.
if (!this.contextComponentManagerProvider
.get()
.hasComponent(BlockRenderer.class, document.getSyntax().toIdString())) {
this.logger.warn(
"We can't rename the links from [{}] "
+ "because there is no renderer available for its syntax [{}].",
currentDocumentReference,
document.getSyntax());
return;
}
XDOM xdom = document.getXDOM();
List<Block> blocks = linkedResourceHelper.getBlocks(xdom);
boolean modified = false;
for (Block block : blocks) {
try {
modified |= renameLink(block, currentDocumentReference, oldTarget, newTarget);
} catch (InvalidArgumentException e) {
continue;
}
}
if (modified) {
document.setContent(xdom);
saveDocumentPreservingContentAuthor(document, "Renamed back-links.", false);
this.logger.info(
"The links from [{}] that were targeting [{}] have been updated to target [{}].",
document.getDocumentReferenceWithLocale(),
oldTarget,
newTarget);
} else {
this.logger.info("No back-links to update in [{}].", currentDocumentReference);
}
}
private void deleteOldWorkspaceObject(BaseObject oldObject, XWikiDocument oldWikiDescriptor)
throws DataMigrationException {
// Context, XWiki
XWikiContext context = getXWikiContext();
XWiki xwiki = context.getWiki();
// Delete the old object
oldWikiDescriptor.removeXObject(oldObject);
// Save the document
try {
xwiki.saveDocument(
oldWikiDescriptor, "Remove the old WorkspaceManager.WorkspaceClass object.", context);
} catch (XWikiException e) {
throw new DataMigrationException(
String.format(
"Failed to save the document [%s] to remove the WorkspaceManager.WorkspaceClass object.",
oldWikiDescriptor.getDocumentReference().toString()),
e);
}
}
@Override
public boolean checkAccess(String action, XWikiDocument doc, XWikiContext context)
throws XWikiException {
Right right = actionToRight(action);
EntityReference entityReference = doc.getDocumentReference();
LOGGER.debug("checkAccess for action {} on entity {}.", right, entityReference);
DocumentReference userReference = authenticateUser(right, entityReference, context);
if (userReference == null) {
showLogin(context);
return false;
}
if (authorizationManager.hasAccess(right, userReference, entityReference)) {
return true;
}
// If the right has been denied, and we have guest user, redirect the user to login page
// unless the denied is on the login action, which could cause infinite redirection.
// FIXME: The hasAccessLevel is broken (do not allow document creator) on the delete action in
// the old
// implementation, so code that simply want to verify if a user can delete (but is not actually
// deleting)
// has to call checkAccess. This happen really often, and this why we should not redirect to
// login on failed
// delete, since it would prevent most user to do anything.
if (context.getUserReference() == null
&& !DELETE_ACTION.equals(action)
&& !LOGIN_ACTION.equals(action)) {
LOGGER.debug(
"Redirecting guest user to login, since it have been denied {} on {}.",
right,
entityReference);
showLogin(context);
}
return false;
}
@Test
public void getPlainUserName() throws XWikiException {
XWikiDocument document = mock(XWikiDocument.class);
DocumentReference userReference = new DocumentReference("wiki", "XWiki", "user");
when(document.getDocumentReference()).thenReturn(userReference);
when(this.storeMock.loadXWikiDoc(any(XWikiDocument.class), any(XWikiContext.class)))
.thenReturn(document);
BaseObject userObject = mock(BaseObject.class);
when(document.getObject("XWiki.XWikiUsers")).thenReturn(userObject);
when(userObject.getStringValue("first_name")).thenReturn("first<name");
when(userObject.getStringValue("last_name")).thenReturn("last'name");
assertEquals("first<name last'name", xwiki.getPlainUserName(userReference, context));
when(userObject.getStringValue("first_name")).thenReturn("first<name");
when(userObject.getStringValue("last_name")).thenReturn("");
assertEquals("first<name", xwiki.getPlainUserName(userReference, context));
when(userObject.getStringValue("first_name")).thenReturn("");
when(userObject.getStringValue("last_name")).thenReturn("last'name");
assertEquals("last'name", xwiki.getPlainUserName(userReference, context));
}