1. Project Clover database Tue Dec 20 2016 21:24:09 CET
  2. Package org.xwiki.wiki.internal.descriptor.builder

File DefaultWikiDescriptorBuilder.java

 

Coverage histogram

../../../../../../img/srcFileCovDistChart9.png
38% of files have more coverage

Code metrics

22
74
8
1
266
176
23
0.31
9.25
8
2.88

Classes

Class Line # Actions
DefaultWikiDescriptorBuilder 61 74 0% 23 10
0.9038461490.4%
 

Contributing tests

This file is covered by 3 tests. .

Source view

1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.wiki.internal.descriptor.builder;
21   
22    import java.util.ArrayList;
23    import java.util.List;
24   
25    import javax.inject.Inject;
26    import javax.inject.Named;
27    import javax.inject.Provider;
28    import javax.inject.Singleton;
29   
30    import org.apache.commons.lang3.StringUtils;
31    import org.slf4j.Logger;
32    import org.xwiki.component.annotation.Component;
33    import org.xwiki.model.EntityType;
34    import org.xwiki.model.reference.DocumentReference;
35    import org.xwiki.model.reference.DocumentReferenceResolver;
36    import org.xwiki.model.reference.EntityReference;
37    import org.xwiki.model.reference.EntityReferenceSerializer;
38    import org.xwiki.model.reference.WikiReference;
39    import org.xwiki.wiki.descriptor.WikiDescriptor;
40    import org.xwiki.wiki.internal.descriptor.DefaultWikiDescriptor;
41    import org.xwiki.wiki.internal.descriptor.document.WikiDescriptorDocumentHelper;
42    import org.xwiki.wiki.internal.descriptor.document.XWikiServerClassDocumentInitializer;
43    import org.xwiki.wiki.internal.descriptor.properties.WikiPropertyGroupManager;
44    import org.xwiki.wiki.manager.WikiManagerException;
45    import org.xwiki.wiki.properties.WikiPropertyGroupException;
46   
47    import com.xpn.xwiki.XWiki;
48    import com.xpn.xwiki.XWikiContext;
49    import com.xpn.xwiki.XWikiException;
50    import com.xpn.xwiki.doc.XWikiDocument;
51    import com.xpn.xwiki.objects.BaseObject;
52   
53    /**
54    * Default implementation for {@link org.xwiki.wiki.internal.descriptor.builder.WikiDescriptorBuilder}.
55    *
56    * @version $Id: 1ee4d4677d857696645f96246ba9bc2e68aba838 $
57    * @since 5.3M2
58    */
59    @Component
60    @Singleton
 
61    public class DefaultWikiDescriptorBuilder implements WikiDescriptorBuilder
62    {
63    /**
64    * Page prefix for all descriptors.
65    */
66    static final String VALID_PAGE_PREFIX = "XWikiServer";
67   
68    /**
69    * XWikiContext provider.
70    */
71    @Inject
72    private Provider<XWikiContext> xcontextProvider;
73   
74    /**
75    * Reference serializer.
76    */
77    @Inject
78    private EntityReferenceSerializer<String> referenceSerializer;
79   
80    @Inject
81    private DocumentReferenceResolver<String> referenceResolver;
82   
83    @Inject
84    @Named("user")
85    private DocumentReferenceResolver<String> userReferenceResolver;
86   
87    @Inject
88    private Provider<WikiPropertyGroupManager> wikiPropertyGroupManagerProvider;
89   
90    @Inject
91    private WikiDescriptorDocumentHelper wikiDescriptorDocumentHelper;
92   
93    @Inject
94    private Logger logger;
95   
 
96  115 toggle private String getFullReference(String userId, String wikiId)
97    {
98  115 String result = null;
99   
100  115 if (!StringUtils.isBlank(userId)) {
101  106 DocumentReference userReference = userReferenceResolver.resolve(userId, new WikiReference(wikiId));
102  106 result = referenceSerializer.serialize(userReference);
103    }
104   
105  115 return result;
106    }
107   
 
108  108 toggle @Override
109    public DefaultWikiDescriptor buildDescriptorObject(List<BaseObject> serverClassObjects, XWikiDocument document)
110    {
111  108 List<BaseObject> normalizedServerClassObjects = normalizeServerClassObjects(serverClassObjects);
112  108 BaseObject mainServerClassObject = normalizedServerClassObjects.remove(0);
113  108 DefaultWikiDescriptor descriptor = extractWikiDescriptor(mainServerClassObject, document);
114   
115  108 if (descriptor != null) {
116    // Create WikiAlias instances for the other XWikiServerClass objects
117  107 for (BaseObject serverClassObject : normalizedServerClassObjects) {
118  2 if (serverClassObject != null) {
119  2 String descriptorAlias = extractWikiAlias(serverClassObject);
120  2 descriptor.addAlias(descriptorAlias);
121    }
122    }
123   
124    // load properties
125  107 descriptor.setMainPageReference(referenceResolver.resolve(mainServerClassObject
126    .getStringValue(XWikiServerClassDocumentInitializer.FIELD_HOMEPAGE)));
127  107 descriptor.setPrettyName(mainServerClassObject
128    .getStringValue(XWikiServerClassDocumentInitializer.FIELD_WIKIPRETTYNAME));
129  107 descriptor.setOwnerId(getFullReference(
130    mainServerClassObject.getStringValue(XWikiServerClassDocumentInitializer.FIELD_OWNER),
131    descriptor.getId()));
132  107 descriptor.setDescription(mainServerClassObject
133    .getStringValue(XWikiServerClassDocumentInitializer.FIELD_DESCRIPTION));
134   
135    // load the property groups
136  107 try {
137  107 WikiPropertyGroupManager wikiPropertyGroupManager = wikiPropertyGroupManagerProvider.get();
138  107 wikiPropertyGroupManager.loadForDescriptor(descriptor);
139    } catch (WikiPropertyGroupException e) {
140  1 logger.error("Failed to load wiki property groups for wiki [{}].", descriptor.getId(), e);
141    }
142    }
143   
144  108 return descriptor;
145    }
146   
 
147  108 toggle private List<BaseObject> normalizeServerClassObjects(List<BaseObject> serverClassObjects)
148    {
149    // Remove null entries. Nulls can happen due to how the serverClassObjects parameter has been retrieved. If it
150    // was retrieved using the XWikiDocument#getXObjects() then it can have holes in it with null values.
151  108 List<BaseObject> result = new ArrayList<>();
152  108 for (BaseObject serverClassObject : serverClassObjects) {
153  112 if (serverClassObject != null) {
154  110 result.add(serverClassObject);
155    }
156    }
157  108 return result;
158    }
159   
 
160  108 toggle private DefaultWikiDescriptor extractWikiDescriptor(BaseObject serverClassObject, XWikiDocument document)
161    {
162  108 DefaultWikiDescriptor descriptor = null;
163   
164    // If the server property is empty then consider we have an invalid Wiki
165  108 String serverProperty = extractWikiAlias(serverClassObject);
166  108 if (!StringUtils.isBlank(serverProperty)) {
167    // If the page name doesn't start with "XWikiServer" then consider we have an invalid Wiki
168  107 String wikiId = extractWikiId(document);
169  107 if (wikiId != null) {
170  107 descriptor = new DefaultWikiDescriptor(wikiId, serverProperty);
171    }
172    }
173   
174  108 return descriptor;
175    }
176   
 
177  110 toggle private String extractWikiAlias(BaseObject serverClassObject)
178    {
179  110 return serverClassObject.getStringValue(XWikiServerClassDocumentInitializer.FIELD_SERVER);
180    }
181   
 
182  107 toggle private String extractWikiId(XWikiDocument document)
183    {
184  107 String wikiId = null;
185  107 String pageName = document.getDocumentReference().getName();
186  107 if (pageName.startsWith(VALID_PAGE_PREFIX)) {
187  107 wikiId = StringUtils.removeStart(pageName, VALID_PAGE_PREFIX).toLowerCase();
188    }
189  107 return wikiId;
190    }
191   
 
192  8 toggle @Override
193    public XWikiDocument save(WikiDescriptor descriptor) throws WikiDescriptorBuilderException
194    {
195  8 XWikiContext context = xcontextProvider.get();
196  8 XWiki xwiki = context.getWiki();
197  8 XWikiDocument descriptorDoc = null;
198   
199  8 try {
200    // Create the descriptor document
201  8 descriptorDoc = wikiDescriptorDocumentHelper.getDocumentFromWikiId(descriptor.getId());
202   
203    // Create the server class object
204  8 BaseObject obj = descriptorDoc.getXObject(DefaultWikiDescriptor.SERVER_CLASS, true, context);
205  8 obj.set(XWikiServerClassDocumentInitializer.FIELD_SERVER, descriptor.getDefaultAlias(), context);
206  8 obj.set(XWikiServerClassDocumentInitializer.FIELD_HOMEPAGE,
207    referenceSerializer.serialize(descriptor.getMainPageReference()), context);
208  8 obj.set(XWikiServerClassDocumentInitializer.FIELD_OWNER,
209    getFullReference(descriptor.getOwnerId(), descriptor.getId()), context);
210  8 obj.set(XWikiServerClassDocumentInitializer.FIELD_WIKIPRETTYNAME, descriptor.getPrettyName(), context);
211  8 obj.set(XWikiServerClassDocumentInitializer.FIELD_DESCRIPTION, descriptor.getDescription(), context);
212   
213    // Create the aliases
214  8 List<String> aliases = descriptor.getAliases();
215  8 for (int i = 1; i < aliases.size(); ++i) {
216  0 String alias = aliases.get(i);
217  0 BaseObject objAlias = descriptorDoc.getXObject(DefaultWikiDescriptor.SERVER_CLASS,
218    XWikiServerClassDocumentInitializer.FIELD_SERVER, alias, true);
219  0 objAlias.set(XWikiServerClassDocumentInitializer.FIELD_SERVER, alias, context);
220    }
221   
222    // Set the meta-data (creator, hidden flag, parent, etc...)
223  8 setDescriptorDocMetadata(descriptorDoc);
224   
225    // Save the document
226  8 xwiki.saveDocument(descriptorDoc, context);
227   
228    // Save the property groups
229  8 WikiPropertyGroupManager wikiPropertyGroupManager = wikiPropertyGroupManagerProvider.get();
230  8 wikiPropertyGroupManager.saveForDescriptor(descriptor);
231   
232    } catch (WikiManagerException e) {
233  0 throw new WikiDescriptorBuilderException("Unable to load the descriptor document", e);
234    } catch (XWikiException e) {
235  0 throw new WikiDescriptorBuilderException("Unable to save the descriptor document", e);
236    } catch (WikiPropertyGroupException e) {
237  0 throw new WikiDescriptorBuilderException("Unable to save the property groups", e);
238    }
239   
240  8 return descriptorDoc;
241    }
242   
 
243  8 toggle private void setDescriptorDocMetadata(XWikiDocument descriptorDoc)
244    {
245  8 XWikiContext context = xcontextProvider.get();
246   
247    // Set the document as hidden
248  8 descriptorDoc.setHidden(true);
249   
250    // The document must have a creator
251  8 if (descriptorDoc.getCreatorReference() == null) {
252  4 descriptorDoc.setCreatorReference(context.getUserReference());
253    }
254    // The document must have an author
255  8 if (descriptorDoc.getAuthorReference() == null) {
256  4 descriptorDoc.setAuthorReference(context.getUserReference());
257    }
258   
259    // Set the document parent
260  8 if (descriptorDoc.getParentReference() == null) {
261  4 EntityReference parentReference = new EntityReference("WebHome", EntityType.DOCUMENT);
262  4 parentReference.appendParent(new EntityReference("WikiManager", EntityType.SPACE));
263  4 descriptorDoc.setParentReference(parentReference);
264    }
265    }
266    }