59dcba96811a2ffd6e0fe1c9bdc93ae82fb73a47
[jSite.git] / src / main / java / de / todesbaum / jsite / application / Project.java
1 /*
2  * jSite - Project.java - Copyright © 2006–2014 David Roden
3  *
4  * This program is free software; you can redistribute it and/or modify it under
5  * the terms of the GNU General Public License as published by the Free Software
6  * Foundation; either version 2 of the License, or (at your option) any later
7  * version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12  * details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16  * Place - Suite 330, Boston, MA 02111-1307, USA.
17  */
18
19 package de.todesbaum.jsite.application;
20
21 import java.io.File;
22 import java.util.ArrayList;
23 import java.util.Collections;
24 import java.util.HashMap;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.Map.Entry;
28
29 import net.pterodactylus.util.io.MimeTypes;
30
31 /**
32  * Container for project information.
33  *
34  * @author David ‘Bombe’ Roden <bombe@freenetproject.org>
35  */
36 public class Project implements Comparable<Project> {
37
38         /** The name of the project. */
39         protected String name;
40
41         /** The description of the project. */
42         protected String description;
43
44         /** The insert URI of the project. */
45         protected String insertURI;
46
47         /** The request URI of the project. */
48         protected String requestURI;
49
50         /** The index file of the project. */
51         protected String indexFile;
52
53         /** The local path of the project. */
54         protected String localPath;
55
56         /** The remote path of the URI. */
57         protected String path;
58
59         /** The time of the last insertion. */
60         protected long lastInsertionTime;
61
62         /** The edition to insert to. */
63         protected int edition;
64
65         /** Whether to always force inserts. */
66         private boolean alwaysForceInserts;
67
68         /** Whether to ignore hidden directory. */
69         private boolean ignoreHiddenFiles;
70
71         /** Options for files. */
72         protected Map<String, FileOption> fileOptions = new HashMap<String, FileOption>();
73
74         /**
75          * Empty constructor.
76          */
77         public Project() {
78                 /* do nothing. */
79         }
80
81         /**
82          * Creates a new project from an existing one.
83          *
84          * @param project
85          *            The project to clone
86          */
87         public Project(Project project) {
88                 name = project.name;
89                 description = project.description;
90                 insertURI = project.insertURI;
91                 requestURI = project.requestURI;
92                 path = project.path;
93                 edition = project.edition;
94                 localPath = project.localPath;
95                 indexFile = project.indexFile;
96                 lastInsertionTime = project.lastInsertionTime;
97                 alwaysForceInserts = project.alwaysForceInserts;
98                 ignoreHiddenFiles = project.ignoreHiddenFiles;
99                 for (Entry<String, FileOption> fileOption : fileOptions.entrySet()) {
100                         fileOptions.put(fileOption.getKey(), new FileOption(fileOption.getValue()));
101                 }
102         }
103
104         /**
105          * Returns the name of the project.
106          *
107          * @return The name of the project
108          */
109         public String getName() {
110                 return name;
111         }
112
113         /**
114          * Sets the name of the project.
115          *
116          * @param name
117          *            The name of the project
118          */
119         public void setName(String name) {
120                 this.name = name;
121         }
122
123         /**
124          * Returns the description of the project.
125          *
126          * @return The description of the project
127          */
128         public String getDescription() {
129                 return description;
130         }
131
132         /**
133          * Sets the description of the project.
134          *
135          * @param description
136          *            The description of the project
137          */
138         public void setDescription(String description) {
139                 this.description = description;
140         }
141
142         /**
143          * Returns the local path of the project.
144          *
145          * @return The local path of the project
146          */
147         public String getLocalPath() {
148                 return localPath;
149         }
150
151         /**
152          * Sets the local path of the project.
153          *
154          * @param localPath
155          *            The local path of the project
156          */
157         public void setLocalPath(String localPath) {
158                 this.localPath = localPath;
159         }
160
161         /**
162          * Returns the name of the index file of the project, relative to the
163          * project’s local path.
164          *
165          * @return The name of the index file of the project
166          */
167         public String getIndexFile() {
168                 return indexFile;
169         }
170
171         /**
172          * Sets the name of the index file of the project, relative to the project’s
173          * local path.
174          *
175          * @param indexFile
176          *            The name of the index file of the project
177          */
178         public void setIndexFile(String indexFile) {
179                 this.indexFile = indexFile;
180         }
181
182         /**
183          * Returns the time the project was last inserted, in milliseconds since the
184          * epoch.
185          *
186          * @return The time of the last insertion
187          */
188         public long getLastInsertionTime() {
189                 return lastInsertionTime;
190         }
191
192         /**
193          * Sets the time the project was last inserted, in milliseconds since the
194          * last epoch.
195          *
196          * @param lastInserted
197          *            The time of the last insertion
198          */
199         public void setLastInsertionTime(long lastInserted) {
200                 lastInsertionTime = lastInserted;
201         }
202
203         /**
204          * Returns the remote path of the project. The remote path is the path that
205          * directly follows the request URI of the project.
206          *
207          * @return The remote path of the project
208          */
209         public String getPath() {
210                 return path;
211         }
212
213         /**
214          * Sets the remote path of the project. The remote path is the path that
215          * directly follows the request URI of the project.
216          *
217          * @param path
218          *            The remote path of the project
219          */
220         public void setPath(String path) {
221                 this.path = path;
222         }
223
224         /**
225          * Returns the insert URI of the project.
226          *
227          * @return The insert URI of the project
228          */
229         public String getInsertURI() {
230                 return insertURI;
231         }
232
233         /**
234          * Sets the insert URI of the project.
235          *
236          * @param insertURI
237          *            The insert URI of the project
238          */
239         public void setInsertURI(String insertURI) {
240                 this.insertURI = shortenURI(insertURI);
241         }
242
243         /**
244          * Returns the request URI of the project.
245          *
246          * @return The request URI of the project
247          */
248         public String getRequestURI() {
249                 return requestURI;
250         }
251
252         /**
253          * Sets the request URI of the project.
254          *
255          * @param requestURI
256          *            The request URI of the project
257          */
258         public void setRequestURI(String requestURI) {
259                 this.requestURI = shortenURI(requestURI);
260         }
261
262         /**
263          * Returns whether files for this project should always be inserted, even
264          * when unchanged.
265          *
266          * @return {@code true} to always force inserts on this project,
267          *         {@code false} otherwise
268          */
269         public boolean isAlwaysForceInsert() {
270                 return alwaysForceInserts;
271         }
272
273         /**
274          * Sets whether files for this project should always be inserted, even when
275          * unchanged.
276          *
277          * @param alwaysForceInsert
278          *            {@code true} to always force inserts on this project,
279          *            {@code false} otherwise
280          */
281         public void setAlwaysForceInsert(boolean alwaysForceInsert) {
282                 this.alwaysForceInserts = alwaysForceInsert;
283         }
284
285         /**
286          * Returns whether hidden files are ignored, i.e. not inserted.
287          *
288          * @return {@code true} if hidden files are not inserted, {@code false}
289          *         otherwise
290          */
291         public boolean isIgnoreHiddenFiles() {
292                 return ignoreHiddenFiles;
293         }
294
295         /**
296          * Sets whether hidden files are ignored, i.e. not inserted.
297          *
298          * @param ignoreHiddenFiles
299          *            {@code true} if hidden files are not inserted, {@code false}
300          *            otherwise
301          */
302         public void setIgnoreHiddenFiles(boolean ignoreHiddenFiles) {
303                 this.ignoreHiddenFiles = ignoreHiddenFiles;
304         }
305
306         /**
307          * {@inheritDoc}
308          * <p>
309          * This method returns the name of the project.
310          */
311         @Override
312         public String toString() {
313                 return name;
314         }
315
316         /**
317          * Shortens the given URI by removing scheme and key-type prefixes.
318          *
319          * @param uri
320          *            The URI to shorten
321          * @return The shortened URI
322          */
323         private static String shortenURI(String uri) {
324                 String shortUri = uri;
325                 if (shortUri.startsWith("freenet:")) {
326                         shortUri = shortUri.substring("freenet:".length());
327                 }
328                 if (shortUri.startsWith("SSK@")) {
329                         shortUri = shortUri.substring("SSK@".length());
330                 }
331                 if (shortUri.startsWith("USK@")) {
332                         shortUri = shortUri.substring("USK@".length());
333                 }
334                 if (shortUri.endsWith("/")) {
335                         shortUri = shortUri.substring(0, shortUri.length() - 1);
336                 }
337                 return shortUri;
338         }
339
340         /**
341          * Shortens the name of the given file by removing the local path of the
342          * project and leading file separators.
343          *
344          * @param file
345          *            The file whose name should be shortened
346          * @return The shortened name of the file
347          */
348         public String shortenFilename(File file) {
349                 String filename = file.getPath();
350                 if (filename.startsWith(localPath)) {
351                         filename = filename.substring(localPath.length());
352                         if (filename.startsWith(File.separator)) {
353                                 filename = filename.substring(1);
354                         }
355                 }
356                 return filename;
357         }
358
359         /**
360          * Returns the options for the file with the given name. If the file does
361          * not yet have any options, a new set of default options is created and
362          * returned.
363          *
364          * @param filename
365          *            The name of the file, relative to the project root
366          * @return The options for the file
367          */
368         public FileOption getFileOption(String filename) {
369                 FileOption fileOption = fileOptions.get(filename);
370                 String defaultMimeType = "application/octet-stream";
371                 if (fileOption == null) {
372                         List<String> suffixes = getSuffixes(filename);
373                         for (String suffix : suffixes) {
374                                 String mimeType = MimeTypes.getMimeType(suffix);
375                                 if (!mimeType.equals(defaultMimeType)) {
376                                         defaultMimeType = mimeType;
377                                         break;
378                                 }
379                         }
380                         fileOption = new FileOption(defaultMimeType);
381                 }
382                 fileOptions.put(filename, fileOption);
383                 return fileOption;
384         }
385
386         private List<String> getSuffixes(String filename) {
387                 List<String> suffixes = new ArrayList<>();
388                 int dot = filename.lastIndexOf(".");
389                 while (dot > -1) {
390                         String suffix = filename.substring(dot + 1);
391                         suffixes.add(0, suffix);
392                         dot = filename.lastIndexOf(".", dot - 1);
393                 }
394                 return suffixes;
395         }
396
397         /**
398          * Sets options for a file.
399          *
400          * @param filename
401          *            The filename to set the options for, relative to the project
402          *            root
403          * @param fileOption
404          *            The options to set for the file, or <code>null</code> to
405          *            remove the options for the file
406          */
407         public void setFileOption(String filename, FileOption fileOption) {
408                 if (fileOption != null) {
409                         fileOptions.put(filename, fileOption);
410                 } else {
411                         fileOptions.remove(filename);
412                 }
413         }
414
415         /**
416          * Returns all file options.
417          *
418          * @return All file options
419          */
420         public Map<String, FileOption> getFileOptions() {
421                 return Collections.unmodifiableMap(fileOptions);
422         }
423
424         /**
425          * Sets all file options.
426          *
427          * @param fileOptions
428          *            The file options
429          */
430         public void setFileOptions(Map<String, FileOption> fileOptions) {
431                 this.fileOptions.clear();
432                 this.fileOptions.putAll(fileOptions);
433         }
434
435         /**
436          * {@inheritDoc}
437          * <p>
438          * Projects are compared by their name only.
439          */
440         @Override
441         public int compareTo(Project project) {
442                 return name.compareToIgnoreCase(project.name);
443         }
444
445         /**
446          * Returns the edition of the project.
447          *
448          * @return The edition of the project
449          */
450         public int getEdition() {
451                 return edition;
452         }
453
454         /**
455          * Sets the edition of the project.
456          *
457          * @param edition
458          *            The edition to set
459          */
460         public void setEdition(int edition) {
461                 this.edition = edition;
462         }
463
464         /**
465          * Constructs the final request URI including the edition number.
466          *
467          * @param offset
468          *            The offset for the edition number
469          * @return The final request URI
470          */
471         public String getFinalRequestURI(int offset) {
472                 return "USK@" + requestURI + "/" + path + "/" + (edition + offset) + "/";
473         }
474
475         /**
476          * Performs some post-processing on the project after it was inserted
477          * successfully. At the moment it copies the current hashes of all file
478          * options to the last insert hashes, updating the hashes for the next
479          * insert.
480          */
481         public void onSuccessfulInsert() {
482                 for (Entry<String, FileOption> fileOptionEntry : fileOptions.entrySet()) {
483                         FileOption fileOption = fileOptionEntry.getValue();
484                         if ((fileOption.getCurrentHash() != null) && (fileOption.getCurrentHash().length() > 0) && (!fileOption.getCurrentHash().equals(fileOption.getLastInsertHash()) || fileOption.isForceInsert())) {
485                                 fileOption.setLastInsertEdition(edition);
486                                 fileOption.setLastInsertHash(fileOption.getCurrentHash());
487                                 fileOption.setLastInsertFilename(fileOption.getChangedName().orElse(fileOptionEntry.getKey()));
488                         }
489                         fileOption.setForceInsert(false);
490                 }
491         }
492
493 }