1. Project Clover database Tue Dec 20 2016 21:24:09 CET
  2. Package org.xwiki.filter.instance.internal.input

File InstanceInputFilterStream.java

 

Coverage histogram

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

Code metrics

8
61
9
1
238
161
14
0.23
6.78
9
1.56

Classes

Class Line # Actions
InstanceInputFilterStream 57 61 0% 14 8
0.897435989.7%
 

Contributing tests

This file is covered by 1 test. .

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.filter.instance.internal.input;
21   
22    import java.io.IOException;
23    import java.util.List;
24   
25    import javax.inject.Inject;
26    import javax.inject.Named;
27    import javax.inject.Provider;
28   
29    import org.slf4j.Logger;
30    import org.xwiki.component.annotation.Component;
31    import org.xwiki.component.annotation.InstantiationStrategy;
32    import org.xwiki.component.descriptor.ComponentInstantiationStrategy;
33    import org.xwiki.component.manager.ComponentLookupException;
34    import org.xwiki.component.manager.ComponentManager;
35    import org.xwiki.filter.FilterEventParameters;
36    import org.xwiki.filter.FilterException;
37    import org.xwiki.filter.event.model.WikiDocumentFilter;
38    import org.xwiki.filter.input.AbstractBeanInputFilterStream;
39    import org.xwiki.filter.instance.input.InstanceInputEventGenerator;
40    import org.xwiki.filter.instance.input.InstanceInputProperties;
41    import org.xwiki.filter.instance.internal.InstanceFilter;
42    import org.xwiki.filter.instance.internal.InstanceModel;
43    import org.xwiki.filter.instance.internal.InstanceUtils;
44    import org.xwiki.logging.marker.TranslationMarker;
45    import org.xwiki.model.reference.DocumentReference;
46    import org.xwiki.model.reference.EntityReferenceTreeNode;
47    import org.xwiki.model.reference.SpaceReference;
48    import org.xwiki.model.reference.WikiReference;
49   
50    /**
51    * @version $Id: 7cf545d63d8faadb0a1166242aa2a064dac09702 $
52    * @since 6.2M1
53    */
54    @Component
55    @Named(InstanceUtils.ROLEHINT)
56    @InstantiationStrategy(ComponentInstantiationStrategy.PER_LOOKUP)
 
57    public class InstanceInputFilterStream extends AbstractBeanInputFilterStream<InstanceInputProperties, InstanceFilter>
58    {
59    private static final TranslationMarker LOG_DOCUMENT_SKIPPED = new TranslationMarker(
60    "filter.instance.log.document.skipped", WikiDocumentFilter.LOG_DOCUMENT_SKIPPED);
61   
62    @Inject
63    private InstanceModel instanceModel;
64   
65    @Inject
66    @Named("context")
67    private Provider<ComponentManager> componentManager;
68   
69    @Inject
70    private Logger logger;
71   
72    private List<InstanceInputEventGenerator> eventGenerators;
73   
 
74  1 toggle @Override
75    public void setProperties(InstanceInputProperties properties) throws FilterException
76    {
77  1 super.setProperties(properties);
78   
79  1 try {
80  1 this.eventGenerators = this.componentManager.get().getInstanceList(InstanceInputEventGenerator.class);
81    } catch (ComponentLookupException e) {
82  0 throw new FilterException(
83    "Failed to get regsitered instance of OutputInstanceFilterStreamFactory components", e);
84    }
85   
86  1 for (InstanceInputEventGenerator eventGenerator : this.eventGenerators) {
87  1 eventGenerator.setProperties(this.properties);
88    }
89    }
90   
 
91  1 toggle private boolean isWikiEnabled(WikiReference wikiReference)
92    {
93  1 return this.properties.getEntities() == null || this.properties.getEntities().matches(wikiReference);
94    }
95   
 
96  2 toggle private boolean isSpaceEnabled(SpaceReference spaceReference)
97    {
98  2 return this.properties.getEntities() == null || this.properties.getEntities().matches(spaceReference);
99    }
100   
 
101  3 toggle private boolean isDocumentEnabled(DocumentReference documentReference)
102    {
103  3 return this.properties.getEntities() == null || this.properties.getEntities().matches(documentReference);
104    }
105   
 
106  1 toggle @Override
107    public void close() throws IOException
108    {
109    // Nothing do close
110    }
111   
 
112  1 toggle @Override
113    protected void read(Object filter, InstanceFilter proxyFilter) throws FilterException
114    {
115  1 FilterEventParameters parameters = new FilterEventParameters();
116   
117  1 for (InstanceInputEventGenerator generator : this.eventGenerators) {
118  1 generator.setWikiFarmParameters(parameters);
119    }
120   
121  1 proxyFilter.beginWikiFarm(parameters);
122   
123  1 for (InstanceInputEventGenerator generator : this.eventGenerators) {
124  1 generator.setFilter(filter);
125  1 generator.beginWikiFarm(parameters);
126    }
127   
128  1 for (WikiReference wikiReference : this.instanceModel.getWikiReferences()) {
129  1 if (isWikiEnabled(wikiReference)) {
130  1 writeWiki(wikiReference, filter, proxyFilter);
131    }
132    }
133   
134  1 for (InstanceInputEventGenerator generator : this.eventGenerators) {
135  1 generator.endWikiFarm(parameters);
136    }
137   
138  1 proxyFilter.endWikiFarm(parameters);
139    }
140   
 
141  1 toggle private void writeWiki(WikiReference wikiReference, Object filter, InstanceFilter proxyFilter)
142    throws FilterException
143    {
144  1 FilterEventParameters parameters = new FilterEventParameters();
145   
146  1 for (InstanceInputEventGenerator generator : this.eventGenerators) {
147  1 generator.setWikiParameters(wikiReference.getName(), parameters);
148    }
149   
150  1 proxyFilter.beginWiki(wikiReference.getName(), parameters);
151   
152  1 for (InstanceInputEventGenerator generator : this.eventGenerators) {
153  1 generator.beginWiki(wikiReference.getName(), parameters);
154    }
155   
156    // TODO: improve with a new space related API to get space level by space level instead of all of them at the
157    // same time
158  1 EntityReferenceTreeNode spaces = this.instanceModel.getSpaceReferences(wikiReference);
159  1 for (EntityReferenceTreeNode node : spaces.getChildren()) {
160  2 if (isSpaceEnabled((SpaceReference) node.getReference())) {
161  2 writeSpace(node, filter, proxyFilter);
162    }
163    }
164   
165  1 for (InstanceInputEventGenerator generator : this.eventGenerators) {
166  1 generator.endWiki(wikiReference.getName(), parameters);
167    }
168   
169  1 proxyFilter.endWiki(wikiReference.getName(), parameters);
170    }
171   
 
172  3 toggle private void writeSpace(EntityReferenceTreeNode node, Object filter, InstanceFilter proxyFilter)
173    throws FilterException
174    {
175  3 SpaceReference spaceReference = (SpaceReference) node.getReference();
176   
177  3 FilterEventParameters parameters = new FilterEventParameters();
178   
179    // Get begin/end space parameters
180  3 for (InstanceInputEventGenerator generator : this.eventGenerators) {
181  3 generator.setWikiSpaceParameters(spaceReference.getName(), parameters);
182    }
183   
184    // Begin space
185  3 proxyFilter.beginWikiSpace(spaceReference.getName(), parameters);
186   
187    // Extend begin space
188  3 for (InstanceInputEventGenerator generator : this.eventGenerators) {
189  3 generator.beginWikiSpace(spaceReference.getName(), parameters);
190    }
191   
192    // Write documents
193  3 for (DocumentReference documentReference : this.instanceModel.getDocumentReferences(spaceReference)) {
194  3 if (isDocumentEnabled(documentReference)) {
195  3 writeDocument(documentReference, filter, proxyFilter);
196    } else {
197  0 if (this.properties.isVerbose()) {
198  0 this.logger.info(LOG_DOCUMENT_SKIPPED, "Skipped document [{}]", documentReference);
199    }
200    }
201    }
202   
203    // Write nested spaces
204  3 for (EntityReferenceTreeNode child : node.getChildren()) {
205  1 writeSpace(child, filter, proxyFilter);
206    }
207   
208    // Extend end space
209  3 for (InstanceInputEventGenerator generator : this.eventGenerators) {
210  3 generator.endWikiSpace(spaceReference.getName(), parameters);
211    }
212   
213    // End space
214  3 proxyFilter.endWikiSpace(spaceReference.getName(), parameters);
215    }
216   
 
217  3 toggle private void writeDocument(DocumentReference documentReference, Object filter, InstanceFilter proxyFilter)
218    throws FilterException
219    {
220  3 FilterEventParameters parameters = new FilterEventParameters();
221   
222  3 for (InstanceInputEventGenerator generator : this.eventGenerators) {
223  3 generator.setWikiDocumentParameters(documentReference.getName(), parameters);
224    }
225   
226  3 proxyFilter.beginWikiDocument(documentReference.getName(), parameters);
227   
228  3 for (InstanceInputEventGenerator generator : this.eventGenerators) {
229  3 generator.beginWikiDocument(documentReference.getName(), parameters);
230    }
231   
232  3 for (InstanceInputEventGenerator generator : this.eventGenerators) {
233  3 generator.endWikiDocument(documentReference.getName(), parameters);
234    }
235   
236  3 proxyFilter.endWikiDocument(documentReference.getName(), parameters);
237    }
238    }