tagsArray = extractTags(tags);
245 |
246 | // substitute some for the paragraph breaks
247 | post = post.replaceAll("\\r?\\n", "
");
248 |
249 | String permalink = blogPostDAO.addPost(title, post, tagsArray, username);
250 |
251 | // now redirect to the blog permalink
252 | response.redirect("/post/" + permalink);
253 | }
254 | }
255 | });
256 |
257 | get(new FreemarkerBasedRoute("/welcome", "welcome.ftl") {
258 | @Override
259 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
260 |
261 | String cookie = getSessionCookie(request);
262 | String username = sessionDAO.findUserNameBySessionId(cookie);
263 |
264 | if (username == null) {
265 | System.out.println("welcome() can't identify the user, redirecting to signup");
266 | response.redirect("/signup");
267 |
268 | }
269 | else {
270 | SimpleHash root = new SimpleHash();
271 |
272 | root.put("username", username);
273 |
274 | template.process(root, writer);
275 | }
276 | }
277 | });
278 |
279 | // process a new comment
280 | post(new FreemarkerBasedRoute("/newcomment", "entry_template.ftl") {
281 | @Override
282 | protected void doHandle(Request request, Response response, Writer writer)
283 | throws IOException, TemplateException {
284 | String name = StringEscapeUtils.escapeHtml4(request.queryParams("commentName"));
285 | String email = StringEscapeUtils.escapeHtml4(request.queryParams("commentEmail"));
286 | String body = StringEscapeUtils.escapeHtml4(request.queryParams("commentBody"));
287 | String permalink = request.queryParams("permalink");
288 |
289 | Document post = blogPostDAO.findByPermalink(permalink);
290 | if (post == null) {
291 | response.redirect("/post_not_found");
292 | }
293 | // check that comment is good
294 | else if (name.equals("") || body.equals("")) {
295 | // bounce this back to the user for correction
296 | SimpleHash root = new SimpleHash();
297 | SimpleHash comment = new SimpleHash();
298 |
299 | comment.put("name", name);
300 | comment.put("email", email);
301 | comment.put("body", body);
302 | root.put("comment", comment);
303 | root.put("post", post);
304 | root.put("errors", "Post must contain your name and an actual comment");
305 |
306 | template.process(root, writer);
307 | }
308 | else {
309 | blogPostDAO.addPostComment(name, email, body, permalink);
310 | response.redirect("/post/" + permalink);
311 | }
312 | }
313 | });
314 |
315 | // present the login page
316 | get(new FreemarkerBasedRoute("/login", "login.ftl") {
317 | @Override
318 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
319 | SimpleHash root = new SimpleHash();
320 |
321 | root.put("username", "");
322 | root.put("login_error", "");
323 |
324 | template.process(root, writer);
325 | }
326 | });
327 |
328 | // process output coming from login form. On success redirect folks to the welcome page
329 | // on failure, just return an error and let them try again.
330 | post(new FreemarkerBasedRoute("/login", "login.ftl") {
331 | @Override
332 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
333 |
334 | String username = request.queryParams("username");
335 | String password = request.queryParams("password");
336 |
337 | System.out.println("Login: User submitted: " + username + " " + password);
338 |
339 | Document user = userDAO.validateLogin(username, password);
340 |
341 | if (user != null) {
342 |
343 | // valid user, let's log them in
344 | String sessionID = sessionDAO.startSession(user.get("_id").toString());
345 |
346 | if (sessionID == null) {
347 | response.redirect("/internal_error");
348 | }
349 | else {
350 | // set the cookie for the user's browser
351 | response.raw().addCookie(new Cookie("session", sessionID));
352 |
353 | response.redirect("/welcome");
354 | }
355 | }
356 | else {
357 | SimpleHash root = new SimpleHash();
358 |
359 |
360 | root.put("username", StringEscapeUtils.escapeHtml4(username));
361 | root.put("password", "");
362 | root.put("login_error", "Invalid Login");
363 | template.process(root, writer);
364 | }
365 | }
366 | });
367 |
368 | // Show the posts filed under a certain tag
369 | get(new FreemarkerBasedRoute("/tag/:thetag", "blog_template.ftl") {
370 | @Override
371 | protected void doHandle(Request request, Response response, Writer writer)
372 | throws IOException, TemplateException {
373 |
374 | String username = sessionDAO.findUserNameBySessionId(getSessionCookie(request));
375 | SimpleHash root = new SimpleHash();
376 |
377 | String tag = StringEscapeUtils.escapeHtml4(request.params(":thetag"));
378 | List posts = blogPostDAO.findByTagDateDescending(tag);
379 |
380 | root.put("myposts", posts);
381 | if (username != null) {
382 | root.put("username", username);
383 | }
384 |
385 | template.process(root, writer);
386 | }
387 | });
388 |
389 | // will allow a user to click Like on a post
390 | post(new FreemarkerBasedRoute("/like", "entry_template.ftl") {
391 | @Override
392 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
393 |
394 | String permalink = request.queryParams("permalink");
395 | String commentOrdinalStr = request.queryParams("comment_ordinal");
396 |
397 |
398 | // look up the post in question
399 |
400 | int ordinal = Integer.parseInt(commentOrdinalStr);
401 |
402 | // TODO: check return or have checkSession throw
403 | String username = sessionDAO.findUserNameBySessionId(getSessionCookie(request));
404 | Document post = blogPostDAO.findByPermalink(permalink);
405 |
406 | // if post not found, redirect to post not found error
407 | if (post == null) {
408 | response.redirect("/post_not_found");
409 | }
410 | else {
411 | blogPostDAO.likePost(permalink, ordinal);
412 |
413 | response.redirect("/post/" + permalink);
414 | }
415 | }
416 | });
417 |
418 | // tells the user that the URL is dead
419 | get(new FreemarkerBasedRoute("/post_not_found", "post_not_found.ftl") {
420 | @Override
421 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
422 | SimpleHash root = new SimpleHash();
423 | template.process(root, writer);
424 | }
425 | });
426 |
427 | // allows the user to logout of the blog
428 | get(new FreemarkerBasedRoute("/logout", "signup.ftl") {
429 | @Override
430 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
431 |
432 | String sessionID = getSessionCookie(request);
433 |
434 | if (sessionID == null) {
435 | // no session to end
436 | response.redirect("/login");
437 | }
438 | else {
439 | // deletes from session table
440 | sessionDAO.endSession(sessionID);
441 |
442 | // this should delete the cookie
443 | Cookie c = getSessionCookieActual(request);
444 | c.setMaxAge(0);
445 |
446 | response.raw().addCookie(c);
447 |
448 | response.redirect("/login");
449 | }
450 | }
451 | });
452 |
453 |
454 | // used to process internal errors
455 | get(new FreemarkerBasedRoute("/internal_error", "error_template.ftl") {
456 | @Override
457 | protected void doHandle(Request request, Response response, Writer writer) throws IOException, TemplateException {
458 | SimpleHash root = new SimpleHash();
459 |
460 | root.put("error", "System has encountered an error.");
461 | template.process(root, writer);
462 | }
463 | });
464 | }
465 |
466 | // helper function to get session cookie as string
467 | private String getSessionCookie(final Request request) {
468 | if (request.raw().getCookies() == null) {
469 | return null;
470 | }
471 | for (Cookie cookie : request.raw().getCookies()) {
472 | if (cookie.getName().equals("session")) {
473 | return cookie.getValue();
474 | }
475 | }
476 | return null;
477 | }
478 |
479 | // helper function to get session cookie as string
480 | private Cookie getSessionCookieActual(final Request request) {
481 | if (request.raw().getCookies() == null) {
482 | return null;
483 | }
484 | for (Cookie cookie : request.raw().getCookies()) {
485 | if (cookie.getName().equals("session")) {
486 | return cookie;
487 | }
488 | }
489 | return null;
490 | }
491 |
492 | // tags the tags string and put it into an array
493 | private ArrayList extractTags(String tags) {
494 |
495 | tags = tags.replaceAll("\\s", "");
496 | String tagArray[] = tags.split(",");
497 |
498 | // let's clean it up, removing the empty string and removing dups
499 | ArrayList cleaned = new ArrayList();
500 | for (String tag : tagArray) {
501 | if (!tag.equals("") && !cleaned.contains(tag)) {
502 | cleaned.add(tag);
503 | }
504 | }
505 |
506 | return cleaned;
507 | }
508 |
509 | // validates that the registration form has been filled out right and username conforms
510 | public boolean validateSignup(String username, String password, String verify, String email,
511 | HashMap errors) {
512 | String USER_RE = "^[a-zA-Z0-9_-]{3,20}$";
513 | String PASS_RE = "^.{3,20}$";
514 | String EMAIL_RE = "^[\\S]+@[\\S]+\\.[\\S]+$";
515 |
516 | errors.put("username_error", "");
517 | errors.put("password_error", "");
518 | errors.put("verify_error", "");
519 | errors.put("email_error", "");
520 |
521 | if (!username.matches(USER_RE)) {
522 | errors.put("username_error", "invalid username. try just letters and numbers");
523 | return false;
524 | }
525 |
526 | if (!password.matches(PASS_RE)) {
527 | errors.put("password_error", "invalid password.");
528 | return false;
529 | }
530 |
531 |
532 | if (!password.equals(verify)) {
533 | errors.put("verify_error", "password must match");
534 | return false;
535 | }
536 |
537 | if (!email.equals("")) {
538 | if (!email.matches(EMAIL_RE)) {
539 | errors.put("email_error", "Invalid Email Address");
540 | return false;
541 | }
542 | }
543 |
544 | return true;
545 | }
546 |
547 | private Configuration createFreemarkerConfiguration() {
548 | Configuration retVal = new Configuration();
549 | retVal.setClassForTemplateLoading(BlogController.class, "/freemarker");
550 | return retVal;
551 | }
552 | }
553 |
--------------------------------------------------------------------------------
/src/main/java/BlogPostDAO.java:
--------------------------------------------------------------------------------
1 |
2 | import com.mongodb.BasicDBObject;
3 | import com.mongodb.client.MongoCollection;
4 | import com.mongodb.client.MongoDatabase;
5 | import org.bson.Document;
6 |
7 | import java.util.ArrayList;
8 | import java.util.Date;
9 | import java.util.List;
10 |
11 | import static com.mongodb.client.model.Filters.eq;
12 | import static com.mongodb.client.model.Sorts.descending;
13 |
14 | public class BlogPostDAO {
15 | private final MongoCollection postsCollection;
16 |
17 | public BlogPostDAO(final MongoDatabase blogDatabase) {
18 | postsCollection = blogDatabase.getCollection("posts");
19 | }
20 |
21 | public Document findByPermalink(String permalink) {
22 | Document post = postsCollection.find(eq("permalink", permalink)).first();
23 |
24 | // fix up if a post has no likes
25 | if (post != null) {
26 | List comments = (List) post.get("comments");
27 | for (Document comment : comments) {
28 | if (!comment.containsKey("num_likes")) {
29 | comment.put("num_likes", 0);
30 | }
31 | }
32 | }
33 | return post;
34 | }
35 |
36 | public List findByDateDescending(int limit) {
37 | return postsCollection.find().sort(descending("date"))
38 | .limit(limit)
39 | .into(new ArrayList());
40 | }
41 |
42 | public List findByTagDateDescending(final String tag) {
43 | return postsCollection.find(eq("tags", tag))
44 | .sort(descending("date"))
45 | .limit(10)
46 | .into(new ArrayList());
47 | }
48 |
49 | public String addPost(String title, String body, List tags, String username) {
50 | String permalink = title.replaceAll("\\s", "_"); // whitespace becomes _
51 | permalink = permalink.replaceAll("\\W", ""); // get rid of non alphanumeric
52 | permalink = permalink.toLowerCase();
53 |
54 | Document post = new Document("title", title)
55 | .append("author", username)
56 | .append("body", body)
57 | .append("permalink", permalink)
58 | .append("tags", tags)
59 | .append("comments", new ArrayList())
60 | .append("date", new Date());
61 |
62 | postsCollection.insertOne(post);
63 |
64 | return permalink;
65 | }
66 |
67 | public void addPostComment(final String name, final String email, final String body, final String permalink) {
68 | Document comment = new Document("author", name)
69 | .append("body", body);
70 |
71 | if (email != null && !email.isEmpty()) {
72 | comment.append("email", email);
73 | }
74 |
75 | postsCollection.updateOne(eq("permalink", permalink),
76 | new Document("$push", new Document("comments", comment)));
77 | }
78 |
79 | public void likePost(final String permalink, final int ordinal) {
80 |
81 | postsCollection.updateOne(new BasicDBObject("permalink", permalink), new BasicDBObject("$inc", new BasicDBObject("comments." + ordinal + ".num_likes", 1)));
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/src/main/java/SessionDAO.java:
--------------------------------------------------------------------------------
1 |
2 | import com.mongodb.client.MongoCollection;
3 | import com.mongodb.client.MongoDatabase;
4 | import org.bson.Document;
5 | import sun.misc.BASE64Encoder;
6 |
7 | import java.security.SecureRandom;
8 |
9 | import static com.mongodb.client.model.Filters.eq;
10 |
11 | public class SessionDAO {
12 | private final MongoCollection sessionsCollection;
13 |
14 | public SessionDAO(final MongoDatabase blogDatabase) {
15 | sessionsCollection = blogDatabase.getCollection("sessions");
16 | }
17 |
18 |
19 | public String findUserNameBySessionId(String sessionId) {
20 | Document session = getSession(sessionId);
21 |
22 | if (session == null) {
23 | return null;
24 | }
25 | else {
26 | return session.get("username").toString();
27 | }
28 | }
29 |
30 |
31 | // starts a new session in the sessions table
32 | public String startSession(String username) {
33 |
34 | // get 32 byte random number. that's a lot of bits.
35 | SecureRandom generator = new SecureRandom();
36 | byte randomBytes[] = new byte[32];
37 | generator.nextBytes(randomBytes);
38 |
39 | BASE64Encoder encoder = new BASE64Encoder();
40 |
41 | String sessionID = encoder.encode(randomBytes);
42 |
43 | // build the BSON object
44 | Document session = new Document("username", username)
45 | .append("_id", sessionID);
46 |
47 | sessionsCollection.insertOne(session);
48 |
49 | return session.getString("_id");
50 | }
51 |
52 | // ends the session by deleting it from the sesisons table
53 | public void endSession(String sessionID) {
54 | sessionsCollection.deleteOne(eq("_id", sessionID));
55 | }
56 |
57 | // retrieves the session from the sessions table
58 | public Document getSession(String sessionID) {
59 | return sessionsCollection.find(eq("_id", sessionID)).first();
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/main/java/UserDAO.java:
--------------------------------------------------------------------------------
1 |
2 | import com.mongodb.ErrorCategory;
3 | import com.mongodb.MongoWriteException;
4 | import com.mongodb.client.MongoCollection;
5 | import com.mongodb.client.MongoDatabase;
6 | import org.bson.Document;
7 | import sun.misc.BASE64Encoder;
8 |
9 | import java.io.UnsupportedEncodingException;
10 | import java.security.MessageDigest;
11 | import java.security.NoSuchAlgorithmException;
12 | import java.util.Random;
13 |
14 | import static com.mongodb.client.model.Filters.eq;
15 |
16 | public class UserDAO {
17 | private final MongoCollection usersCollection;
18 | private final ThreadLocal random = new ThreadLocal();
19 |
20 | public UserDAO(final MongoDatabase blogDatabase) {
21 | usersCollection = blogDatabase.getCollection("users");
22 | }
23 |
24 | // validates that username is unique and insert into db
25 | public boolean addUser(String username, String password, String email) {
26 |
27 | String passwordHash = makePasswordHash(password, Integer.toString(getRandom().nextInt()));
28 |
29 | Document user = new Document();
30 |
31 | user.append("_id", username).append("password", passwordHash);
32 |
33 | if (email != null && !email.equals("")) {
34 | // the provided email address
35 | user.append("email", email);
36 | }
37 |
38 | try {
39 | usersCollection.insertOne(user);
40 | return true;
41 | } catch (MongoWriteException e) {
42 | if (e.getError().getCategory().equals(ErrorCategory.DUPLICATE_KEY)) {
43 | System.out.println("Username already in use: " + username);
44 | return false;
45 | }
46 | throw e;
47 | }
48 | }
49 |
50 | public Document validateLogin(String username, String password) {
51 | Document user;
52 |
53 | user = usersCollection.find(eq("_id", username)).first();
54 |
55 | if (user == null) {
56 | return null;
57 | }
58 |
59 | String hashedAndSalted = user.get("password").toString();
60 |
61 | String salt = hashedAndSalted.split(",")[1];
62 |
63 | if (!hashedAndSalted.equals(makePasswordHash(password, salt))) {
64 | System.out.println("Submitted password is not a match");
65 | return null;
66 | }
67 |
68 | return user;
69 | }
70 |
71 |
72 | private String makePasswordHash(String password, String salt) {
73 | try {
74 | String saltedAndHashed = password + "," + salt;
75 | MessageDigest digest = MessageDigest.getInstance("MD5");
76 | digest.update(saltedAndHashed.getBytes());
77 | BASE64Encoder encoder = new BASE64Encoder();
78 | byte hashedBytes[] = (new String(digest.digest(), "UTF-8")).getBytes();
79 | return encoder.encode(hashedBytes) + "," + salt;
80 | } catch (NoSuchAlgorithmException e) {
81 | throw new RuntimeException("MD5 is not available", e);
82 | } catch (UnsupportedEncodingException e) {
83 | throw new RuntimeException("UTF-8 unavailable? Not a chance", e);
84 | }
85 | }
86 |
87 | private Random getRandom() {
88 | Random result = random.get();
89 | if (result == null) {
90 | result = new Random();
91 | random.set(result);
92 | }
93 | return result;
94 | }
95 | }
96 |
--------------------------------------------------------------------------------
/src/main/resources/freemarker/blog_template.ftl:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | My Blog
5 |
6 |
7 |
8 | <#if username??>
9 | Welcome ${username} Logout | New Post
10 |
11 |
12 |
13 |
14 |
My Blog
15 |
16 | <#if myposts?has_content>
17 | <#list myposts as post>
18 |
19 | Posted ${post["date"]?datetime} By ${post["author"]}
20 | Comments:
21 | <#if post["comments"]??>
22 | <#assign numComments = post["comments"]?size>
23 | <#else>
24 | <#assign numComments = 0>
25 |
26 |
27 | ${numComments}
28 |
29 | ${post["body"]!""}
30 |
31 |
32 |
33 | Filed Under:
34 | <#if post["tags"]??>
35 | <#list post["tags"] as tag>
36 | ${tag}
37 |
38 |
39 |
40 |
41 |
42 | <#else>
43 |
There are no posts yet. Please add a post!
44 |
45 |
46 |
47 |
48 |
--------------------------------------------------------------------------------
/src/main/resources/freemarker/entry_template.ftl:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 | Blog Post
6 |
7 |
8 |
9 | <#if username??>
10 | Welcome ${username} Logout | New Post
11 |
12 |
13 |
14 |
15 | Blog Home
16 |
17 |
${post["title"]}
18 | Posted ${post["date"]?datetime} By ${post["author"]}
19 |
20 | ${post["body"]}
21 |
22 | Filed Under:
23 | <#if post["tags"]??>
24 | <#list post["tags"] as tag>
25 | ${tag}
26 |
27 |
28 |
29 | Comments:
30 |
31 | <#if post["comments"]??>
32 | <#assign numComments = post["comments"]?size>
33 | <#else>
34 | <#assign numComments = 0>
35 |
36 | <#if (numComments > 0)>
37 | <#list 0 .. (numComments -1) as i>
38 |
43 |
44 | ${post["comments"][i]["body"]}
45 |
46 |
47 |
48 | Add a comment
49 |
50 |
61 |
62 |
63 |