Add processor for updated Sones
[Sone.git] / src / main / java / net / pterodactylus / sone / core / Preferences.java
1 /*
2  * Sone - Preferences.java - Copyright © 2013–2016 David Roden
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 package net.pterodactylus.sone.core;
19
20 import static com.google.common.base.Predicates.equalTo;
21 import static java.lang.Integer.MAX_VALUE;
22 import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS;
23 import static net.pterodactylus.sone.utils.IntegerRangePredicate.range;
24
25 import net.pterodactylus.sone.core.event.InsertionDelayChangedEvent;
26 import net.pterodactylus.sone.fcp.FcpInterface;
27 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired;
28 import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent;
29 import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent;
30 import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged;
31 import net.pterodactylus.sone.utils.DefaultOption;
32 import net.pterodactylus.sone.utils.Option;
33 import net.pterodactylus.util.config.Configuration;
34 import net.pterodactylus.util.config.ConfigurationException;
35
36 import com.google.common.base.Predicates;
37 import com.google.common.eventbus.EventBus;
38
39 /**
40  * Convenience interface for external classes that want to access the core’s
41  * configuration.
42  */
43 public class Preferences {
44
45         private final EventBus eventBus;
46         private final Option<Integer> insertionDelay =
47                         new DefaultOption<Integer>(60, range(0, MAX_VALUE));
48         private final Option<Integer> postsPerPage =
49                         new DefaultOption<Integer>(10, range(1, MAX_VALUE));
50         private final Option<Integer> imagesPerPage =
51                         new DefaultOption<Integer>(9, range(1, MAX_VALUE));
52         private final Option<Integer> charactersPerPost =
53                         new DefaultOption<Integer>(400, Predicates.<Integer>or(
54                                         range(50, MAX_VALUE), equalTo(-1)));
55         private final Option<Integer> postCutOffLength =
56                         new DefaultOption<Integer>(200, range(50, MAX_VALUE));
57         private final Option<Boolean> requireFullAccess =
58                         new DefaultOption<Boolean>(false);
59         private final Option<Integer> positiveTrust =
60                         new DefaultOption<Integer>(75, range(0, 100));
61         private final Option<Integer> negativeTrust =
62                         new DefaultOption<Integer>(-25, range(-100, 100));
63         private final Option<String> trustComment =
64                         new DefaultOption<String>("Set from Sone Web Interface");
65         private final Option<Boolean> activateFcpInterface =
66                         new DefaultOption<Boolean>(false);
67         private final Option<FullAccessRequired> fcpFullAccessRequired =
68                         new DefaultOption<FullAccessRequired>(ALWAYS);
69
70         public Preferences(EventBus eventBus) {
71                 this.eventBus = eventBus;
72         }
73
74         /**
75          * Returns the insertion delay.
76          *
77          * @return The insertion delay
78          */
79         public int getInsertionDelay() {
80                 return insertionDelay.get();
81         }
82
83         /**
84          * Validates the given insertion delay.
85          *
86          * @param insertionDelay
87          *            The insertion delay to validate
88          * @return {@code true} if the given insertion delay was valid,
89          *         {@code false} otherwise
90          */
91         public boolean validateInsertionDelay(Integer insertionDelay) {
92                 return this.insertionDelay.validate(insertionDelay);
93         }
94
95         /**
96          * Sets the insertion delay
97          *
98          * @param insertionDelay
99          *            The new insertion delay, or {@code null} to restore it to
100          *            the default value
101          * @return This preferences
102          */
103         public Preferences setInsertionDelay(Integer insertionDelay) {
104                 this.insertionDelay.set(insertionDelay);
105                 eventBus.post(new InsertionDelayChangedEvent(getInsertionDelay()));
106                 return this;
107         }
108
109         /**
110          * Returns the number of posts to show per page.
111          *
112          * @return The number of posts to show per page
113          */
114         public int getPostsPerPage() {
115                 return postsPerPage.get();
116         }
117
118         /**
119          * Validates the number of posts per page.
120          *
121          * @param postsPerPage
122          *            The number of posts per page
123          * @return {@code true} if the number of posts per page was valid,
124          *         {@code false} otherwise
125          */
126         public boolean validatePostsPerPage(Integer postsPerPage) {
127                 return this.postsPerPage.validate(postsPerPage);
128         }
129
130         /**
131          * Sets the number of posts to show per page.
132          *
133          * @param postsPerPage
134          *            The number of posts to show per page
135          * @return This preferences object
136          */
137         public Preferences setPostsPerPage(Integer postsPerPage) {
138                 this.postsPerPage.set(postsPerPage);
139                 return this;
140         }
141
142         /**
143          * Returns the number of images to show per page.
144          *
145          * @return The number of images to show per page
146          */
147         public int getImagesPerPage() {
148                 return imagesPerPage.get();
149         }
150
151         /**
152          * Validates the number of images per page.
153          *
154          * @param imagesPerPage
155          *            The number of images per page
156          * @return {@code true} if the number of images per page was valid,
157          *         {@code false} otherwise
158          */
159         public boolean validateImagesPerPage(Integer imagesPerPage) {
160                 return this.imagesPerPage.validate(imagesPerPage);
161         }
162
163         /**
164          * Sets the number of images per page.
165          *
166          * @param imagesPerPage
167          *            The number of images per page
168          * @return This preferences object
169          */
170         public Preferences setImagesPerPage(Integer imagesPerPage) {
171                 this.imagesPerPage.set(imagesPerPage);
172                 return this;
173         }
174
175         /**
176          * Returns the number of characters per post, or <code>-1</code> if the
177          * posts should not be cut off.
178          *
179          * @return The numbers of characters per post
180          */
181         public int getCharactersPerPost() {
182                 return charactersPerPost.get();
183         }
184
185         /**
186          * Validates the number of characters per post.
187          *
188          * @param charactersPerPost
189          *            The number of characters per post
190          * @return {@code true} if the number of characters per post was valid,
191          *         {@code false} otherwise
192          */
193         public boolean validateCharactersPerPost(Integer charactersPerPost) {
194                 return this.charactersPerPost.validate(charactersPerPost);
195         }
196
197         /**
198          * Sets the number of characters per post.
199          *
200          * @param charactersPerPost
201          *            The number of characters per post, or <code>-1</code> to
202          *            not cut off the posts
203          * @return This preferences objects
204          */
205         public Preferences setCharactersPerPost(Integer charactersPerPost) {
206                 this.charactersPerPost.set(charactersPerPost);
207                 return this;
208         }
209
210         /**
211          * Returns the number of characters the shortened post should have.
212          *
213          * @return The number of characters of the snippet
214          */
215         public int getPostCutOffLength() {
216                 return postCutOffLength.get();
217         }
218
219         /**
220          * Validates the number of characters after which to cut off the post.
221          *
222          * @param postCutOffLength
223          *            The number of characters of the snippet
224          * @return {@code true} if the number of characters of the snippet is
225          *         valid, {@code false} otherwise
226          */
227         public boolean validatePostCutOffLength(Integer postCutOffLength) {
228                 return this.postCutOffLength.validate(postCutOffLength);
229         }
230
231         /**
232          * Sets the number of characters the shortened post should have.
233          *
234          * @param postCutOffLength
235          *            The number of characters of the snippet
236          * @return This preferences
237          */
238         public Preferences setPostCutOffLength(Integer postCutOffLength) {
239                 this.postCutOffLength.set(postCutOffLength);
240                 return this;
241         }
242
243         /**
244          * Returns whether Sone requires full access to be even visible.
245          *
246          * @return {@code true} if Sone requires full access, {@code false}
247          *         otherwise
248          */
249         public boolean isRequireFullAccess() {
250                 return requireFullAccess.get();
251         }
252
253         /**
254          * Sets whether Sone requires full access to be even visible.
255          *
256          * @param requireFullAccess
257          *            {@code true} if Sone requires full access, {@code false}
258          *            otherwise
259          */
260         public void setRequireFullAccess(Boolean requireFullAccess) {
261                 this.requireFullAccess.set(requireFullAccess);
262         }
263
264         /**
265          * Returns the positive trust.
266          *
267          * @return The positive trust
268          */
269         public int getPositiveTrust() {
270                 return positiveTrust.get();
271         }
272
273         /**
274          * Validates the positive trust.
275          *
276          * @param positiveTrust
277          *            The positive trust to validate
278          * @return {@code true} if the positive trust was valid, {@code false}
279          *         otherwise
280          */
281         public boolean validatePositiveTrust(Integer positiveTrust) {
282                 return this.positiveTrust.validate(positiveTrust);
283         }
284
285         /**
286          * Sets the positive trust.
287          *
288          * @param positiveTrust
289          *            The new positive trust, or {@code null} to restore it to
290          *            the default vlaue
291          * @return This preferences
292          */
293         public Preferences setPositiveTrust(Integer positiveTrust) {
294                 this.positiveTrust.set(positiveTrust);
295                 return this;
296         }
297
298         /**
299          * Returns the negative trust.
300          *
301          * @return The negative trust
302          */
303         public int getNegativeTrust() {
304                 return negativeTrust.get();
305         }
306
307         /**
308          * Validates the negative trust.
309          *
310          * @param negativeTrust
311          *            The negative trust to validate
312          * @return {@code true} if the negative trust was valid, {@code false}
313          *         otherwise
314          */
315         public boolean validateNegativeTrust(Integer negativeTrust) {
316                 return this.negativeTrust.validate(negativeTrust);
317         }
318
319         /**
320          * Sets the negative trust.
321          *
322          * @param negativeTrust
323          *            The negative trust, or {@code null} to restore it to the
324          *            default value
325          * @return The preferences
326          */
327         public Preferences setNegativeTrust(Integer negativeTrust) {
328                 this.negativeTrust.set(negativeTrust);
329                 return this;
330         }
331
332         /**
333          * Returns the trust comment. This is the comment that is set in the web
334          * of trust when a trust value is assigned to an identity.
335          *
336          * @return The trust comment
337          */
338         public String getTrustComment() {
339                 return trustComment.get();
340         }
341
342         /**
343          * Sets the trust comment.
344          *
345          * @param trustComment
346          *            The trust comment, or {@code null} to restore it to the
347          *            default value
348          * @return This preferences
349          */
350         public Preferences setTrustComment(String trustComment) {
351                 this.trustComment.set(trustComment);
352                 return this;
353         }
354
355         /**
356          * Returns whether the {@link FcpInterface FCP interface} is currently
357          * active.
358          *
359          * @see FcpInterface#setActive(boolean)
360          * @return {@code true} if the FCP interface is currently active,
361          *         {@code false} otherwise
362          */
363         public boolean isFcpInterfaceActive() {
364                 return activateFcpInterface.get();
365         }
366
367         /**
368          * Sets whether the {@link FcpInterface FCP interface} is currently
369          * active.
370          *
371          * @see FcpInterface#setActive(boolean)
372          * @param fcpInterfaceActive
373          *            {@code true} to activate the FCP interface, {@code false}
374          *            to deactivate the FCP interface
375          * @return This preferences object
376          */
377         public Preferences setFcpInterfaceActive(Boolean fcpInterfaceActive) {
378                 this.activateFcpInterface.set(fcpInterfaceActive);
379                 if (isFcpInterfaceActive()) {
380                         eventBus.post(new FcpInterfaceActivatedEvent());
381                 } else {
382                         eventBus.post(new FcpInterfaceDeactivatedEvent());
383                 }
384                 return this;
385         }
386
387         /**
388          * Returns the action level for which full access to the FCP interface
389          * is required.
390          *
391          * @return The action level for which full access to the FCP interface
392          *         is required
393          */
394         public FullAccessRequired getFcpFullAccessRequired() {
395                 return fcpFullAccessRequired.get();
396         }
397
398         /**
399          * Sets the action level for which full access to the FCP interface is
400          * required
401          *
402          * @param fcpFullAccessRequired
403          *            The action level
404          * @return This preferences
405          */
406         public Preferences setFcpFullAccessRequired(
407                         FullAccessRequired fcpFullAccessRequired) {
408                 this.fcpFullAccessRequired.set(fcpFullAccessRequired);
409                 eventBus.post(new FullAccessRequiredChanged(getFcpFullAccessRequired()));
410                 return this;
411         }
412
413         public void saveTo(Configuration configuration) throws ConfigurationException {
414                 configuration.getIntValue("Option/ConfigurationVersion").setValue(0);
415                 configuration.getIntValue("Option/InsertionDelay").setValue(insertionDelay.getReal());
416                 configuration.getIntValue("Option/PostsPerPage").setValue(postsPerPage.getReal());
417                 configuration.getIntValue("Option/ImagesPerPage").setValue(imagesPerPage.getReal());
418                 configuration.getIntValue("Option/CharactersPerPost").setValue(charactersPerPost.getReal());
419                 configuration.getIntValue("Option/PostCutOffLength").setValue(postCutOffLength.getReal());
420                 configuration.getBooleanValue("Option/RequireFullAccess").setValue(requireFullAccess.getReal());
421                 configuration.getIntValue("Option/PositiveTrust").setValue(positiveTrust.getReal());
422                 configuration.getIntValue("Option/NegativeTrust").setValue(negativeTrust.getReal());
423                 configuration.getStringValue("Option/TrustComment").setValue(trustComment.getReal());
424                 configuration.getBooleanValue("Option/ActivateFcpInterface").setValue(activateFcpInterface.getReal());
425                 configuration.getIntValue("Option/FcpFullAccessRequired").setValue(toInt(fcpFullAccessRequired.getReal()));
426         }
427
428         private Integer toInt(FullAccessRequired fullAccessRequired) {
429                 return (fullAccessRequired == null) ? null : fullAccessRequired.ordinal();
430         }
431
432 }