/** Tests that listeners are fired when a TrackBack is rejected. */
public void testListenersFiredWhenTrackBackRejected() throws Exception {
final StringBuffer buf = new StringBuffer("123");
final TrackBack trackBack =
blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
blogEntry.addTrackBack(trackBack);
trackBack.setPending();
service.putBlogEntry(blogEntry);
TrackBackListener listener =
new TrackBackListener() {
public void trackBackAdded(TrackBackEvent event) {}
public void trackBackRemoved(TrackBackEvent event) {}
public void trackBackApproved(TrackBackEvent event) {}
public void trackBackRejected(TrackBackEvent event) {
assertEquals(trackBack, event.getSource());
buf.reverse();
}
};
blog.getEventListenerList().addTrackBackListener(listener);
trackBack.setRejected();
service.putBlogEntry(blogEntry);
assertEquals("321", buf.toString());
}
/** Tests that listeners are fired when a blog entry is unpublished. */
public void testListenersFiredWhenBlogEntryUnpublished() throws Exception {
final StringBuffer buf = new StringBuffer("123");
blogEntry.setPublished(true);
service.putBlogEntry(blogEntry);
BlogEntryListener listener =
new BlogEntryListener() {
public void blogEntryAdded(BlogEntryEvent event) {
fail();
}
public void blogEntryRemoved(BlogEntryEvent event) {
fail();
}
public void blogEntryChanged(BlogEntryEvent event) {
fail();
}
public void blogEntryPublished(BlogEntryEvent event) {
fail();
}
public void blogEntryUnpublished(BlogEntryEvent event) {
assertEquals(blogEntry, event.getSource());
buf.reverse();
}
};
blog.getEventListenerList().addBlogEntryListener(listener);
blogEntry.setPublished(false);
service.putBlogEntry(blogEntry);
assertEquals("321", buf.toString());
}
/** Tests that listeners are fired when a comment is added. */
public void testListenersFiredWhenCommentAdded() throws Exception {
final StringBuffer buf = new StringBuffer("123");
final Comment comment =
blogEntry.createComment(
"title", "body", "author", "email", "website", "avatar", "127.0.0.1");
CommentListener listener =
new CommentListener() {
public void commentAdded(CommentEvent event) {
assertEquals(comment, event.getSource());
buf.reverse();
}
public void commentRemoved(CommentEvent event) {
fail();
}
public void commentApproved(CommentEvent event) {
fail();
}
public void commentRejected(CommentEvent event) {
fail();
}
};
blog.getEventListenerList().addCommentListener(listener);
service.putBlogEntry(blogEntry);
blogEntry.addComment(comment);
service.putBlogEntry(blogEntry);
assertEquals("321", buf.toString());
}
@Before
public void init() throws DataDuplicatedException, DataNotFoundException {
this.memberService = new MemberServiceImpl();
memberService.registerMember(testMember1);
memberService.registerMember(testMember2);
this.blogService = new BlogServiceImpl();
blogService.createBlog(testMember1, "first_blog");
blogService.createBlog(testMember2, "second_blog");
blogService.createBlog(testMember1, "third_blog");
}
@After
public void end() throws DataNotFoundException {
blogService.removeBlog(testMember1);
blogService.removeBlog(testMember2);
memberService.removeMember(testMember1);
memberService.removeMember(testMember2);
}
/** Tests that comment listeners are fired when a blog entry is removed. */
public void testListenersFiredForCommentsWhenBlogEntryRemoved() throws Exception {
final Comment comment1 =
blogEntry.createComment(
"title", "body", "author", "email", "website", "avatar", "127.0.0.1");
final Comment comment2 =
blogEntry.createComment(
"title", "body", "author", "email", "website", "avatar", "127.0.0.1");
final Comment comment3 =
blogEntry.createComment(
"title", "body", "author", "email", "website", "avatar", "127.0.0.1");
blogEntry.addComment(comment1);
blogEntry.addComment(comment2);
service.putBlogEntry(blogEntry);
comment3.setParent(comment2);
blogEntry.addComment(comment3);
service.putBlogEntry(blogEntry);
final List comments = new ArrayList();
CommentListener listener =
new CommentListener() {
public void commentAdded(CommentEvent event) {
fail();
}
public void commentRemoved(CommentEvent event) {
comments.add(event.getSource());
}
public void commentApproved(CommentEvent event) {
fail();
}
public void commentRejected(CommentEvent event) {
fail();
}
};
blog.getEventListenerList().addCommentListener(listener);
service.removeBlogEntry(blogEntry);
assertEquals(comment1, comments.get(0));
assertEquals(comment2, comments.get(1));
assertEquals(comment3, comments.get(2));
}
@RequestMapping(
value = "",
method = {GET, HEAD})
public String listPublishedPosts(Model model, @RequestParam(defaultValue = "1") int page) {
Pageable pageRequest = PageableFactory.forLists(page);
Page<Post> result = service.getPublishedPosts(pageRequest);
return renderListOfPosts(result, model, "All Posts");
}
@CacheEvict(value = "users", allEntries = true)
public List<UserInvitation> inviteUsers(
UserInvitationCreateRequest form, BindingResult result, AuthorizedUser authorizedUser)
throws MessagingException {
String[] recipients = StringUtils.commaDelimitedListToStringArray(form.getInvitees());
LocalDateTime now = LocalDateTime.now();
List<UserInvitation> invitations = new ArrayList<>();
for (String recipient : recipients) {
UserInvitation invitation = new UserInvitation();
invitation.setEmail(recipient);
invitation.setMessage(form.getMessage());
invitation.setExpiredAt(now.plusHours(72));
invitation.setCreatedAt(now);
invitation.setCreatedBy(authorizedUser.toString());
invitation.setUpdatedAt(now);
invitation.setUpdatedBy(authorizedUser.toString());
invitation = userInvitationRepository.saveAndFlush(invitation);
invitations.add(invitation);
}
Blog blog = blogService.readBlogById(Blog.DEFAULT_ID);
for (UserInvitation invitation : invitations) {
String websiteTitle = blog.getTitle(LocaleContextHolder.getLocale().getLanguage());
String signupLink =
ServletUriComponentsBuilder.fromCurrentContextPath()
.path("/_admin/signup")
.queryParam("token", invitation.getToken())
.buildAndExpand()
.toString();
final Context ctx = new Context(LocaleContextHolder.getLocale());
ctx.setVariable("websiteTitle", websiteTitle);
ctx.setVariable("authorizedUser", authorizedUser);
ctx.setVariable("signupLink", signupLink);
ctx.setVariable("invitation", invitation);
final MimeMessage mimeMessage = mailSender.createMimeMessage();
final MimeMessageHelper message =
new MimeMessageHelper(mimeMessage, true, "UTF-8"); // true = multipart
message.setSubject(
MessageFormat.format(
messageSourceAccessor.getMessage(
"InvitationMessageTitle", LocaleContextHolder.getLocale()),
authorizedUser.toString(),
websiteTitle));
message.setFrom(authorizedUser.getEmail());
message.setTo(invitation.getEmail());
final String htmlContent = templateEngine.process("user-invite", ctx);
message.setText(htmlContent, true); // true = isHtml
mailSender.send(mimeMessage);
}
return invitations;
}
public PasswordResetToken createPasswordResetToken(PasswordResetTokenCreateRequest request) {
User user = userRepository.findByEmail(request.getEmail());
if (user == null) {
throw new EmailNotFoundException();
}
LocalDateTime now = LocalDateTime.now();
PasswordResetToken passwordResetToken = new PasswordResetToken();
passwordResetToken.setUser(user);
passwordResetToken.setEmail(user.getEmail());
passwordResetToken.setExpiredAt(now.plusHours(24));
passwordResetToken.setCreatedAt(now);
passwordResetToken.setCreatedBy(user.toString());
passwordResetToken.setUpdatedAt(now);
passwordResetToken.setUpdatedBy(user.toString());
passwordResetToken = passwordResetTokenRepository.saveAndFlush(passwordResetToken);
try {
Blog blog = blogService.readBlogById(Blog.DEFAULT_ID);
String blogTitle = blog.getTitle(LocaleContextHolder.getLocale().getLanguage());
ServletUriComponentsBuilder builder = ServletUriComponentsBuilder.fromCurrentContextPath();
if (blog.isMultiLanguage()) {
builder.path("/{language}");
}
builder.path("/password-reset");
builder.path("/{token}");
Map<String, Object> urlVariables = new LinkedHashMap<>();
urlVariables.put("language", request.getLanguage());
urlVariables.put("token", passwordResetToken.getToken());
String resetLink = builder.buildAndExpand(urlVariables).toString();
Context ctx = new Context(LocaleContextHolder.getLocale());
ctx.setVariable("passwordResetToken", passwordResetToken);
ctx.setVariable("resetLink", resetLink);
MimeMessage mimeMessage = mailSender.createMimeMessage();
MimeMessageHelper message =
new MimeMessageHelper(mimeMessage, true, "UTF-8"); // true = multipart
message.setSubject(
MessageFormat.format(
messageSourceAccessor.getMessage(
"PasswordResetSubject", LocaleContextHolder.getLocale()),
blogTitle));
message.setFrom(mailProperties.getProperties().get("mail.from"));
message.setTo(passwordResetToken.getEmail());
String htmlContent = templateEngine.process("password-reset", ctx);
message.setText(htmlContent, true); // true = isHtml
mailSender.send(mimeMessage);
} catch (MessagingException e) {
throw new ServiceException(e);
}
return passwordResetToken;
}
@RequestMapping(
value = "/{year:\\d+}/{month:\\d+}/{day:\\d+}/{slug}",
method = {GET, HEAD})
public String showPost(
@PathVariable String year,
@PathVariable String month,
@PathVariable String day,
@PathVariable String slug,
Model model) {
String publicSlug = String.format("%s/%s/%s/%s", year, month, day, slug);
Post post = service.getPublishedPost(publicSlug);
model.addAttribute("post", PostView.of(post, dateFactory));
model.addAttribute("categories", PostCategory.values());
model.addAttribute("activeCategory", post.getCategory().getDisplayName());
model.addAttribute("disqusShortname", service.getDisqusShortname());
return "blog/show";
}
private String renderListOfPosts(Page<Post> page, Model model, String activeCategory) {
Page<PostView> postViewPage = PostView.pageOf(page, dateFactory);
List<PostView> posts = postViewPage.getContent();
model.addAttribute("activeCategory", activeCategory);
model.addAttribute("categories", PostCategory.values());
model.addAttribute("posts", posts);
model.addAttribute("paginationInfo", new PaginationInfo(postViewPage));
model.addAttribute("disqusShortname", service.getDisqusShortname());
return "blog/index";
}
public void testNestedCommentsAreUnindexedWhenParentDeleted() throws Exception {
BlogService service = new BlogService();
Comment comment2 =
blogEntry.createComment(
"Title",
"Body",
"Author",
"*****@*****.**",
"http://www.google.com",
"http://graph.facebook.com/user/picture",
"127.0.0.1");
Comment comment3 =
blogEntry.createComment(
"Title",
"Body",
"Author",
"*****@*****.**",
"http://www.google.com",
"http://graph.facebook.com/user/picture",
"127.0.0.1");
service.putBlogEntry(blogEntry);
blogEntry.addComment(comment);
comment2.setParent(comment);
blogEntry.addComment(comment2);
service.putBlogEntry(blogEntry);
comment3.setParent(comment);
blogEntry.addComment(comment3);
service.putBlogEntry(blogEntry);
assertTrue(blog.getResponseIndex().getPendingResponses().contains(comment.getGuid()));
assertTrue(blog.getResponseIndex().getPendingResponses().contains(comment2.getGuid()));
assertTrue(blog.getResponseIndex().getPendingResponses().contains(comment3.getGuid()));
blogEntry.removeComment(comment.getId());
service.putBlogEntry(blogEntry);
assertFalse(blog.getResponseIndex().getPendingResponses().contains(comment.getGuid()));
assertFalse(blog.getResponseIndex().getPendingResponses().contains(comment2.getGuid()));
assertFalse(blog.getResponseIndex().getPendingResponses().contains(comment3.getGuid()));
}
/**
* Peforms the processing associated with this action.
*
* @param request the HttpServletRequest instance
* @param response the HttpServletResponse instance
* @return the name of the next view
*/
public View process(HttpServletRequest request, HttpServletResponse response)
throws ServletException {
Blog blog = (Blog) getModel().get(Constants.BLOG_KEY);
String id = request.getParameter("entry");
String confirm = request.getParameter("confirm");
String submit = request.getParameter("submit");
BlogService service = new BlogService();
BlogEntry blogEntry = null;
try {
blogEntry = service.getBlogEntry(blog, id);
} catch (BlogServiceException e) {
throw new ServletException(e);
}
if (blogEntry == null) {
return new NotFoundView();
}
if (submit.equals("Edit")) {
return new ForwardView("/editBlogEntry.secureaction?entry=" + id);
} else if (submit.equals("Publish") || submit.equals("Unpublish")) {
getModel().put(Constants.BLOG_ENTRY_KEY, blogEntry);
return new PublishBlogEntryView();
} else if (submit.equals("Clone")) {
return new ForwardView("/addBlogEntry.secureaction?entryToClone=" + blogEntry.getId());
} else if (confirm != null && confirm.equals("true")) {
if (submit.equalsIgnoreCase("Remove")) {
try {
service.removeBlogEntry(blogEntry);
blog.info(
"Blog entry \"" + StringUtils.transformHTML(blogEntry.getTitle()) + "\" removed.");
} catch (BlogServiceException be) {
throw new ServletException(be);
}
return new ForwardView("/viewHomePage.action");
}
}
return new RedirectView(blogEntry.getLocalPermalink());
}
@RequestMapping(
value = "/category/{category}",
method = {GET, HEAD})
public String listPublishedPostsForCategory(
@PathVariable("category") PostCategory category,
Model model,
@RequestParam(defaultValue = "1", value = "page") int page) {
Pageable pageRequest = PageableFactory.forLists(page);
Page<Post> result = service.getPublishedPosts(category, pageRequest);
return renderListOfPosts(result, model, category.getDisplayName());
}
@CacheEvict(value = "users", allEntries = true)
public User updatePassword(PasswordUpdateRequest request, PasswordResetToken passwordResetToken) {
User user = userRepository.findByIdForUpdate(request.getUserId());
if (user == null) {
throw new IllegalArgumentException("The user does not exist");
}
PasswordEncoder passwordEncoder = new StandardPasswordEncoder();
user.setLoginPassword(passwordEncoder.encode(request.getPassword()));
user.setUpdatedAt(LocalDateTime.now());
user.setUpdatedBy(passwordResetToken.getUser().toString());
user = userRepository.saveAndFlush(user);
passwordResetTokenRepository.delete(passwordResetToken);
try {
Blog blog = blogService.readBlogById(Blog.DEFAULT_ID);
String blogTitle = blog.getTitle(LocaleContextHolder.getLocale().getLanguage());
ServletUriComponentsBuilder builder = ServletUriComponentsBuilder.fromCurrentContextPath();
if (blog.isMultiLanguage()) {
builder.path("/{language}");
}
builder.path("/login");
Map<String, Object> urlVariables = new LinkedHashMap<>();
urlVariables.put("language", request.getLanguage());
urlVariables.put("token", passwordResetToken.getToken());
String loginLink = builder.buildAndExpand(urlVariables).toString();
Context ctx = new Context(LocaleContextHolder.getLocale());
ctx.setVariable("passwordResetToken", passwordResetToken);
ctx.setVariable("resetLink", loginLink);
MimeMessage mimeMessage = mailSender.createMimeMessage();
MimeMessageHelper message =
new MimeMessageHelper(mimeMessage, true, "UTF-8"); // true = multipart
message.setSubject(
MessageFormat.format(
messageSourceAccessor.getMessage(
"PasswordChangedSubject", LocaleContextHolder.getLocale()),
blogTitle));
message.setFrom(mailProperties.getProperties().get("mail.from"));
message.setTo(passwordResetToken.getEmail());
String htmlContent = templateEngine.process("password-changed", ctx);
message.setText(htmlContent, true); // true = isHtml
mailSender.send(mimeMessage);
} catch (MessagingException e) {
throw new ServiceException(e);
}
return user;
}
/** Tests that TrackBack listeners are fired when a blog entry is removed. */
public void testListenersFiredForTrackBacksWhenBlogEntryRemoved() throws Exception {
final TrackBack trackBack1 =
blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
final TrackBack trackBack2 =
blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
final TrackBack trackBack3 =
blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
blogEntry.addTrackBack(trackBack1);
blogEntry.addTrackBack(trackBack2);
blogEntry.addTrackBack(trackBack3);
service.putBlogEntry(blogEntry);
final List trackBacks = new ArrayList();
TrackBackListener listener =
new TrackBackListener() {
public void trackBackAdded(TrackBackEvent event) {
fail();
}
public void trackBackRemoved(TrackBackEvent event) {
trackBacks.add(event.getSource());
}
public void trackBackApproved(TrackBackEvent event) {
fail();
}
public void trackBackRejected(TrackBackEvent event) {
fail();
}
};
blog.getEventListenerList().addTrackBackListener(listener);
service.removeBlogEntry(blogEntry);
assertEquals(trackBack1, trackBacks.get(0));
assertEquals(trackBack2, trackBacks.get(1));
assertEquals(trackBack3, trackBacks.get(2));
}
@Test
public void createTmpPost() {
blogService.createPost(
"test",
"Unit Test",
"Short Description",
"Full Description",
"en",
"unit-test",
"malware_bytes",
"success");
System.out.println("Creating Post...");
}
@RequestMapping(
value = "/{year:\\d+}",
method = {GET, HEAD})
public String listPublishedPostsForYear(
@PathVariable int year,
@RequestParam(defaultValue = "1", value = "page") int page,
Model model) {
Pageable pageRequest = PageableFactory.forLists(page);
Page<Post> result = service.getPublishedPostsByDate(year, pageRequest);
model.addAttribute("title", String.format("Archive for %d", year));
return renderListOfPosts(result, model, "All Posts");
}
@RequestMapping(
value = "/{year:\\d+}/{month:\\d+}",
method = {GET, HEAD})
public String listPublishedPostsForYearAndMonth(
@PathVariable int year,
@PathVariable int month,
@RequestParam(defaultValue = "1", value = "page") int page,
Model model) {
Pageable pageRequest = PageableFactory.forLists(page);
Page<Post> result = service.getPublishedPostsByDate(year, month, pageRequest);
YearMonth yearMonth = new YearMonth(year, month);
model.addAttribute("title", "Archive for " + yearMonth.toString("MMMM yyyy"));
return renderListOfPosts(result, model, "All Posts");
}
