use of org.xwiki.rendering.macro.wikibridge.WikiMacroDescriptor in project xwiki-platform by xwiki.
the class DefaultWikiMacroFactory method buildMacro.
/**
* Creates a {@link WikiMacro} from an {@link XWikiDocument} which contains a macro definition.
*
* @param doc the {@link XWikiDocument} to look for a macro definition
* @return the {@link WikiMacro} found inside the document
* @throws WikiMacroException when an invalid macro definition or no macro definition was found
*/
private WikiMacro buildMacro(XWikiDocument doc) throws WikiMacroException {
DocumentReference documentReference = doc.getDocumentReference();
// Check whether this document contains a macro definition.
BaseObject macroDefinition = doc.getObject(WIKI_MACRO_CLASS);
if (null == macroDefinition) {
throw new WikiMacroException(String.format("No macro definition found in document : [%s]", documentReference));
}
// Extract macro definition.
String macroId = macroDefinition.getStringValue(MACRO_ID_PROPERTY);
String macroName = macroDefinition.getStringValue(MACRO_NAME_PROPERTY);
// The macro description as plain text
String macroDescription = macroDefinition.getStringValue(MACRO_DESCRIPTION_PROPERTY);
String macroDefaultCategory = macroDefinition.getStringValue(MACRO_DEFAULT_CATEGORY_PROPERTY);
WikiMacroVisibility macroVisibility = WikiMacroVisibility.fromString(macroDefinition.getStringValue(MACRO_VISIBILITY_PROPERTY));
boolean macroSupportsInlineMode = (macroDefinition.getIntValue(MACRO_INLINE_PROPERTY) == 0) ? false : true;
String macroContentType = macroDefinition.getStringValue(MACRO_CONTENT_TYPE_PROPERTY);
// The macro content description as plain text
String macroContentDescription = macroDefinition.getStringValue(MACRO_CONTENT_DESCRIPTION_PROPERTY);
String macroCode = macroDefinition.getStringValue(MACRO_CODE_PROPERTY);
// Verify macro id.
if (StringUtils.isEmpty(macroId)) {
throw new WikiMacroException(String.format("Incomplete macro definition in [%s], macro id is empty", documentReference));
}
// Verify macro name.
if (StringUtils.isEmpty(macroName)) {
macroName = macroId;
this.logger.debug(String.format("Incomplete macro definition in [%s], macro name is empty", documentReference));
}
// Verify macro description.
if (StringUtils.isEmpty(macroDescription)) {
this.logger.debug(String.format("Incomplete macro definition in [%s], macro description is empty", documentReference));
}
// Verify default macro category.
if (StringUtils.isEmpty(macroDefaultCategory)) {
macroDefaultCategory = null;
this.logger.debug(String.format("Incomplete macro definition in [%s], default macro category is empty", documentReference));
}
// Verify macro content type.
if (StringUtils.isEmpty(macroContentType)) {
macroContentType = MACRO_CONTENT_OPTIONAL;
}
// Verify macro content description.
if (!macroContentType.equals(MACRO_CONTENT_EMPTY) && StringUtils.isEmpty(macroContentDescription)) {
String errorMsg = "Incomplete macro definition in [%s], macro content description is empty";
this.logger.debug(String.format(errorMsg, documentReference));
macroContentDescription = "Macro content";
}
// Verify macro code.
if (StringUtils.isEmpty(macroCode)) {
throw new WikiMacroException(String.format("Incomplete macro definition in [%s], macro code is empty", documentReference));
}
// Extract macro parameters.
List<WikiMacroParameterDescriptor> parameterDescriptors = new ArrayList<WikiMacroParameterDescriptor>();
Vector<BaseObject> macroParameters = doc.getObjects(WIKI_MACRO_PARAMETER_CLASS);
if (null != macroParameters) {
for (BaseObject macroParameter : macroParameters) {
// Vectors can contain null values
if (null == macroParameter) {
continue;
}
// Extract parameter definition.
String parameterName = macroParameter.getStringValue(PARAMETER_NAME_PROPERTY);
String parameterDescription = macroParameter.getStringValue(PARAMETER_DESCRIPTION_PROPERTY);
boolean parameterMandatory = (macroParameter.getIntValue(PARAMETER_MANDATORY_PROPERTY) == 0) ? false : true;
String parameterDefaultValue = macroParameter.getStringValue(PARAMETER_DEFAULT_VALUE_PROPERTY);
// Verify parameter name.
if (StringUtils.isEmpty(parameterName)) {
throw new WikiMacroException(String.format("Incomplete macro definition in [%s], macro parameter name is empty", documentReference));
}
// Verify parameter description.
if (StringUtils.isEmpty(parameterDescription)) {
String errorMessage = "Incomplete macro definition in [%s], macro parameter description is empty";
this.logger.debug(String.format(errorMessage, documentReference));
}
// If field empty, assume no default value was provided.
if (StringUtils.isEmpty(parameterDefaultValue)) {
parameterDefaultValue = null;
}
// Create the parameter descriptor.
parameterDescriptors.add(new WikiMacroParameterDescriptor(parameterName, parameterDescription, parameterMandatory, parameterDefaultValue));
}
}
// Create macro content descriptor.
ContentDescriptor contentDescriptor = null;
if (!macroContentType.equals(MACRO_CONTENT_EMPTY)) {
contentDescriptor = new DefaultContentDescriptor(macroContentDescription, macroContentType.equals(MACRO_CONTENT_MANDATORY));
}
// Create macro descriptor.
// Note that we register wiki macros for all syntaxes FTM and there's currently no way to restrict a wiki
// macro for a given syntax only.
MacroId id = new MacroId(macroId);
MacroDescriptor macroDescriptor = new WikiMacroDescriptor(id, macroName, macroDescription, macroDefaultCategory, macroVisibility, contentDescriptor, parameterDescriptors);
XDOM xdom;
try {
xdom = parser.parse(macroCode, doc.getSyntax(), documentReference);
} catch (MissingParserException ex) {
throw new WikiMacroException("Could not find a parser for macro content", ex);
} catch (ParseException ex) {
throw new WikiMacroException("Error while parsing macro content", ex);
}
// Create & return the macro.
return new DefaultWikiMacro(documentReference, doc.getAuthorReference(), macroSupportsInlineMode, macroDescriptor, xdom, doc.getSyntax(), this.componentManager);
}
use of org.xwiki.rendering.macro.wikibridge.WikiMacroDescriptor in project xwiki-platform by xwiki.
the class DefaultWikiMacroTest method registerWikiMacro.
private void registerWikiMacro(String macroId, String macroContent, Syntax syntax, List<WikiMacroParameterDescriptor> parameterDescriptors) throws Exception {
WikiMacroDescriptor descriptor = new WikiMacroDescriptor(new MacroId(macroId), "Wiki Macro", "Description", "Test", WikiMacroVisibility.GLOBAL, new DefaultContentDescriptor(false), parameterDescriptors);
Parser parser = getComponentManager().getInstance(Parser.class, syntax.toIdString());
DefaultWikiMacro wikiMacro = new DefaultWikiMacro(wikiMacroDocumentReference, null, true, descriptor, parser.parse(new StringReader(macroContent)), syntax, getComponentManager());
this.wikiMacroManager.registerWikiMacro(wikiMacroDocumentReference, wikiMacro);
}
use of org.xwiki.rendering.macro.wikibridge.WikiMacroDescriptor in project xwiki-platform by xwiki.
the class DefaultWikiMacroManager method registerWikiMacro.
@Override
public void registerWikiMacro(DocumentReference documentReference, WikiMacro wikiMacro) throws InsufficientPrivilegesException, WikiMacroException {
WikiMacroDescriptor macroDescriptor = (WikiMacroDescriptor) wikiMacro.getDescriptor();
// Verify that the user has the right to register this wiki macro the chosen visibility
if (this.wikiMacroFactory.isAllowed(documentReference, macroDescriptor.getVisibility())) {
DefaultComponentDescriptor<Macro> componentDescriptor = new DefaultComponentDescriptor<>();
componentDescriptor.setRoleType(Macro.class);
componentDescriptor.setRoleHint(wikiMacro.getDescriptor().getId().getId());
// Save current context informations
String currentUser = this.bridge.getCurrentUser();
EntityReference currentEntityReference = this.modelContext.getCurrentEntityReference();
try {
// Put the proper context information to let components manager use the proper keys to find
// components to unregister
this.bridge.setCurrentUser(this.serializer.serialize(wikiMacro.getAuthorReference() != null ? wikiMacro.getAuthorReference() : this.bridge.getCurrentUserReference()));
this.modelContext.setCurrentEntityReference(documentReference);
// Register the macro against the right Component Manager, depending on the defined macro visibility.
findComponentManager(macroDescriptor.getVisibility()).registerComponent(componentDescriptor, wikiMacro);
this.wikiMacroMap.put(documentReference, new WikiMacroData(componentDescriptor.getRoleHint(), wikiMacro));
} catch (Exception e) {
throw new WikiMacroException(String.format("Failed to register macro [%s] in [%s] for visibility [%s]", wikiMacro.getDescriptor().getId().getId(), documentReference, macroDescriptor.getVisibility()), e);
} finally {
// Restore previous context informations
this.bridge.setCurrentUser(currentUser);
this.modelContext.setCurrentEntityReference(currentEntityReference);
}
} else {
throw new InsufficientPrivilegesException(String.format("Unable to register macro [%s] in [%s] for visibility [%s] due to insufficient privileges", wikiMacro.getDescriptor().getId().getId(), documentReference, macroDescriptor.getVisibility()));
}
}
use of org.xwiki.rendering.macro.wikibridge.WikiMacroDescriptor in project xwiki-platform by xwiki.
the class DefaultWikiMacroTest method registerWikiMacro.
private void registerWikiMacro(String macroId, String macroContent, List<WikiMacroParameterDescriptor> parameterDescriptors) throws Exception {
WikiMacroDescriptor descriptor = new WikiMacroDescriptor(new MacroId(macroId), "Wiki Macro", "Description", "Test", WikiMacroVisibility.GLOBAL, new DefaultContentDescriptor(false), parameterDescriptors);
DefaultWikiMacro wikiMacro = new DefaultWikiMacro(wikiMacroDocumentReference, this.user.getDocumentReference(), true, descriptor, this.xwiki20Parser.parse(new StringReader(macroContent)), Syntax.XWIKI_2_0, getComponentManager());
this.wikiMacroManager.registerWikiMacro(wikiMacroDocumentReference, wikiMacro);
}
use of org.xwiki.rendering.macro.wikibridge.WikiMacroDescriptor in project xwiki-platform by xwiki.
the class DefaultWikiMacroManagerTest method generateWikiMacro.
private DefaultWikiMacro generateWikiMacro(WikiMacroVisibility visibility) throws Exception {
DocumentReference wikiMacroDocReference = new DocumentReference("wiki", Arrays.asList("space"), "space");
WikiMacroDescriptor descriptor = new WikiMacroDescriptor(new MacroId("testwikimacro"), "Test Wiki Macro", "Description", "Test", visibility, new DefaultContentDescriptor(), Collections.<WikiMacroParameterDescriptor>emptyList());
XDOM xdom = new XDOM(Arrays.asList(new ParagraphBlock(Arrays.<Block>asList(new WordBlock("test")))));
DefaultWikiMacro wikiMacro = new DefaultWikiMacro(wikiMacroDocReference, authorReference, true, descriptor, xdom, Syntax.XWIKI_2_0, this.mocker);
return wikiMacro;
}
Aggregations