develop <- feat/app/article/#71

src/main/java/app/db/ArticleRepository.java

@@ -0,0 +1,11 @@
+package app.db;
+
+import app.model.Article;
+import database.ConnectionManager;
+import database.CrudRepository;
+
+public class ArticleRepository extends CrudRepository<Article> {
+    public ArticleRepository(ConnectionManager connectionManager) {
+        super(connectionManager, Article.class);
+    }
+}

src/main/java/app/db/CommentRepository.java

@@ -0,0 +1,11 @@
+package app.db;
+
+import app.model.Comment;
+import database.ConnectionManager;
+import database.CrudRepository;
+
+public class CommentRepository extends CrudRepository<Comment> {
+    public CommentRepository(ConnectionManager connectionManager) {
+        super(connectionManager, Comment.class);
+    }
+}

src/main/java/app/handler/ArticleLikeIncreaseHandler.java

@@ -0,0 +1,29 @@
+package app.handler;
+
+import app.db.ArticleRepository;
+import app.model.Article;
+import exception.ErrorCode;
+import exception.ServiceException;
+import http.HttpMethod;
+import web.dispatch.argument.QueryParameters;
+import web.handler.SingleArgHandler;
+import web.response.HandlerResponse;
+import web.response.RedirectResponse;
+
+public class ArticleLikeIncreaseHandler extends SingleArgHandler<QueryParameters> {
+    private final ArticleRepository articleRepository;
+    public ArticleLikeIncreaseHandler(ArticleRepository articleRepository) {
+        super(HttpMethod.POST, "/like");
+        this.articleRepository = articleRepository;
+    }
+
+    @Override
+    public HandlerResponse handle(QueryParameters params) {
+        Article article = articleRepository.findById(
+                Long.parseLong(params.getValidQueryValue("articleId"))).orElseThrow(
+                        () -> new ServiceException(ErrorCode.NO_SUCH_RESOURCE));
+        article.increaseLikeCount();
+        articleRepository.update(article);
+        return RedirectResponse.to("/?articleId=" + article.getId());
+    }
+}

src/main/java/app/handler/CreateArticleWithPost.java

@@ -0,0 +1,79 @@
+package app.handler;
+
+import app.db.ArticleRepository;
+import app.model.Article;
+import config.DatabaseConfig;
+import exception.ErrorCode;
+import exception.ErrorException;
+import exception.ServiceException;
+import http.HttpMethod;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import web.dispatch.argument.MultipartFile;
+import web.dispatch.argument.MultipartForm;
+import web.filter.authentication.AuthenticationInfo;
+import web.handler.DoubleArgHandler;
+import web.response.HandlerResponse;
+import web.response.RedirectResponse;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+
+import static config.DatabaseConfig.ARTICLE_IMG_DIR;
+import static exception.ErrorCode.UNSUPPORTED_IMAGE_TYPE;
+
+public class CreateArticleWithPost extends DoubleArgHandler<MultipartForm, AuthenticationInfo> {
+    private static final Logger log = LoggerFactory.getLogger(CreateArticleWithPost.class);
+    private final ArticleRepository articleRepository;
+
+    public CreateArticleWithPost(ArticleRepository articleRepository) {
+        super(HttpMethod.POST, "/article/create");
+        this.articleRepository = articleRepository;
+    }
+
+    @Override
+    public HandlerResponse handle(MultipartForm multiform, AuthenticationInfo authInfo) {
+        MultipartFile multipartFile = multiform.getFile("file").orElseThrow(
+                () -> new ErrorException("No file in multiform"));
+        Long userId = authInfo.getUserId().orElseThrow(
+                () -> new ServiceException(ErrorCode.UNAUTHORIZED));
+
+        String extension = extractExtension(multipartFile);
+
+        Article saved = articleRepository.save(
+                new Article(
+                        authInfo.getUserId().get(),
+                        multiform.getField("content")
+                                .orElse("")));
+
+        Path filePath = Paths.get(ARTICLE_IMG_DIR)
+                .resolve(saved.getId().toString());
+
+        try {
+            Files.write(filePath,
+                    multipartFile.bytes(),
+                    StandardOpenOption.CREATE,
+                    StandardOpenOption.TRUNCATE_EXISTING);
+        } catch (IOException e){
+            log.error(e.fillInStackTrace().toString());
+            throw new ErrorException("error");
+        }
+        log.info("Article id[{}] created by {}({})",
+                saved.getId(),
+                userId,
+                authInfo.getAttribute("nickname"));
+        return RedirectResponse.to("/");
+    }
+
+    private static String extractExtension(MultipartFile multipartFile) {
+        return switch(multipartFile.contentType()){
+            case "image/png" -> ".png";
+            case "image/jpg" -> ".jpg";
+            case "image/jpeg" -> ".jpeg";
+            default -> throw new ServiceException(UNSUPPORTED_IMAGE_TYPE);
+        };
+    }
+}

src/main/java/app/handler/CreateCommentWithPost.java

@@ -0,0 +1,38 @@
+package app.handler;
+
+import app.db.CommentRepository;
+import app.model.Comment;
+import exception.ErrorCode;
+import exception.ServiceException;
+import http.HttpMethod;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import web.dispatch.argument.QueryParameters;
+import web.filter.authentication.AuthenticationInfo;
+import web.handler.DoubleArgHandler;
+import web.response.HandlerResponse;
+import web.response.RedirectResponse;
+
+public class CreateCommentWithPost extends DoubleArgHandler<QueryParameters, AuthenticationInfo> {
+    private static final Logger log = LoggerFactory.getLogger(CreateCommentWithPost.class);
+    private final CommentRepository commentRepository;
+    public CreateCommentWithPost(CommentRepository commentRepository) {
+        super(HttpMethod.POST, "/comment/create");
+        this.commentRepository = commentRepository;
+    }
+
+    @Override
+    public HandlerResponse handle(QueryParameters params, AuthenticationInfo authInfo) {
+        String content = params.getValidQueryValue("content");
+        Long articleId = Long.parseLong(
+                params.getValidQueryValue("articleId"));
+        Long userId = authInfo.getUserId()
+                .orElseThrow(
+                        () -> new ServiceException(ErrorCode.UNAUTHORIZED));
+        commentRepository.save(new Comment(articleId, userId, content));
+
+        log.info("{}->{} - comment created", userId, articleId);
+
+        return RedirectResponse.to("/?articleId=" + articleId);
+    }
+}

src/main/java/app/handler/GetCommentCreateForm.java

@@ -0,0 +1,21 @@
+package app.handler;
+
+import http.HttpMethod;
+import http.HttpStatus;
+import web.dispatch.argument.QueryParameters;
+import web.handler.SingleArgHandler;
+import web.response.DynamicViewResponse;
+import web.response.HandlerResponse;
+
+public class GetCommentCreateForm extends SingleArgHandler<QueryParameters> {
+    public GetCommentCreateForm() {
+        super(HttpMethod.GET, "/comment");
+    }
+
+    @Override
+    public HandlerResponse handle(QueryParameters arg) {
+        DynamicViewResponse response = DynamicViewResponse.of(HttpStatus.OK, "/comment/index.html");
+        response.addModel("articleId", arg.getValidQueryValue("articleId"));
+        return response;
+    }
+}

src/main/java/app/handler/HomeHandler.java

@@ -1,20 +1,96 @@
 package app.handler;
 
+import app.db.ArticleRepository;
+import app.db.CommentRepository;
+import app.db.UserRepository;
+import app.model.Article;
+import app.model.Comment;
+import app.model.User;
+import exception.ErrorCode;
+import exception.ErrorException;
+import exception.ServiceException;
 import http.HttpMethod;
 import http.HttpStatus;
-import http.request.HttpRequest;
+import web.dispatch.argument.QueryParameters;
 import web.handler.SingleArgHandler;
 import web.response.DynamicViewResponse;
 import web.response.HandlerResponse;
 
-public class HomeHandler extends SingleArgHandler<HttpRequest> {
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
-    public HomeHandler() {
+public class HomeHandler extends SingleArgHandler<QueryParameters> {
+    private final ArticleRepository articleRepository;
+    private final UserRepository userRepository;
+    private final CommentRepository commentRepository;
+
+    public HomeHandler(ArticleRepository articleRepository, UserRepository userRepository, CommentRepository commentRepository) {
         super(HttpMethod.GET, "/");
+        this.articleRepository = articleRepository;
+        this.userRepository = userRepository;
+        this.commentRepository = commentRepository;
     }
 
     @Override
-    public HandlerResponse handle(HttpRequest request) {
-        return DynamicViewResponse.of(HttpStatus.OK, "/index.html");
+    public HandlerResponse handle(QueryParameters params) {
+        Article article;
+        List<Article> articleList = articleRepository.findAll();
+        DynamicViewResponse response =
+                DynamicViewResponse.of(HttpStatus.OK, "/index.html");
+        if (params.getQueryValue("articleId").isPresent()) {
+            article = articleRepository.findById(
+                    Long.parseLong(params.getQueryValue("articleId").get()))
+                    .orElseThrow(
+                            () -> new ServiceException(ErrorCode.NO_SUCH_RESOURCE));
+        } else {
+            if (articleList.isEmpty()) {
+                response.addModel("article", null);
+                return response;
+            }
+            article = articleList.get(articleList.size() - 1);
+        }
+        User writer = userRepository.findById(article.getWriterId())
+                .orElseThrow(
+                        ()-> new ErrorException("Writer not exists"));
+
+        List<Comment> commentList = commentRepository.findByColumn("articleId", article.getId());
+        response.addModel("commentCount", commentList.size());
+        if (params.getQueryValue("fullComments").isEmpty()
+                || params.getQueryValue("fullComments").get().equals("false")) {
+            if(commentList.size()>3) {
+                response.addModel("hasMoreComments", true);
+                response.addModel("additionalComments", commentList.size()-3);
+                commentList = commentList.subList(0, 3);
+            } else{
+                response.addModel("hasMoreComments", false);
+            }
+        }
+
+        response.addModel("article", article);
+        response.addModel("writerNickname", writer.getNickname());
+        response.addModel("commentList", toCommentDtoList(commentList));
+        response.addModel("next", article.getId() < articleList.size()
+                            ? article.getId() + 1 : false);
+        response.addModel("prev", article.getId() > 1
+                            ? article.getId()-1 : false);
+
+        return response;
+    }
+
+    private List<Map<String, Object>> toCommentDtoList(List<Comment> commentList){
+        List<Map<String, Object>> commentDtoList = new ArrayList<>();
+        for (Comment comment : commentList) {
+            Map<String, Object> commentDto = new HashMap<>();
+            commentDto.put("writerId", comment.getWriterId());
+            commentDto.put("content", comment.getContent());
+            String nickname = userRepository.findById(comment.getWriterId()).orElseThrow(
+                            () -> new ErrorException("Comment Writer Id Not Exists"))
+                    .getNickname();
+            commentDto.put("nickname", nickname);
+            commentDtoList.add(commentDto);
+        }
+        return commentDtoList;
     }
 }

src/main/java/app/handler/LoginWithPost.java

@@ -1,6 +1,7 @@
 package app.handler;
 
 import app.db.Database;
+import app.db.UserRepository;
 import app.model.User;
 import config.VariableConfig;
 import exception.ErrorCode;
@@ -14,25 +15,32 @@
 import web.session.SessionEntity;
 import web.session.SessionStorage;
 
+import java.util.List;
+
 public class LoginWithPost extends SingleArgHandler<QueryParameters> {
+    private static final String EMAIL = "email";
+    private static final String PASSWORD = "password";
+
+
     private final SessionStorage sessionManager;
+    private final UserRepository userRepository;
 
-    public LoginWithPost(SessionStorage sessionManager) {
+    public LoginWithPost(SessionStorage sessionManager, UserRepository userRepository) {
         super(HttpMethod.POST, "/user/login");
         this.sessionManager = sessionManager;
+        this.userRepository = userRepository;
     }
 
     @Override
     public HandlerResponse handle(QueryParameters params) {
-        String email = params.getQueryValue("email")
-                .orElseThrow(() -> new ServiceException(ErrorCode.LOGIN_FAILED, "email required"));
+        String email = getRequired(params, EMAIL);
+        String password = getRequired(params, PASSWORD);
 
-        String password = params.getQueryValue("password")
-                .orElseThrow(() -> new ServiceException(ErrorCode.LOGIN_FAILED, "password required"));
-
-        User user = Database.findUserByEmail(email)
-                .orElseThrow(() -> new ServiceException(ErrorCode.LOGIN_FAILED));
+        List<User> userList = userRepository.findByColumn(EMAIL, email);
+        if(userList.isEmpty())
+            throw new ServiceException(ErrorCode.EMAIL_NOT_FOUND, "회원가입을 하시겠습니까?");
 
+        User user = userList.get(0);
         if (!user.getPassword().equals(password)) {
             throw new ServiceException(ErrorCode.LOGIN_FAILED);
         }
@@ -52,4 +60,9 @@ public HandlerResponse handle(QueryParameters params) {
         );
         return response;
     }
+
+    private String getRequired(QueryParameters params, String key) {
+        return params.getQueryValue(key)
+                .orElseThrow(() -> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, key + " required"));
+    }
 }

src/main/java/app/handler/MypageHandler.java

@@ -0,0 +1,37 @@
+package app.handler;
+
+import exception.ErrorException;
+import http.HttpMethod;
+import http.HttpStatus;
+import web.filter.authentication.AuthenticationInfo;
+import web.handler.SingleArgHandler;
+import web.response.DynamicViewResponse;
+import web.response.HandlerResponse;
+
+import java.io.File;
+
+import static config.DatabaseConfig.BASIC_PROFILE_IMG;
+import static config.DatabaseConfig.PROFILE_IMG_DIR;
+
+public class MypageHandler extends SingleArgHandler<AuthenticationInfo> {
+    public MypageHandler() {
+        super(HttpMethod.GET, "/mypage");
+    }
+
+    @Override
+    public HandlerResponse handle(AuthenticationInfo info) {
+        DynamicViewResponse response = DynamicViewResponse.of(HttpStatus.OK, "/mypage/index.html");
+        Long userId = info.getUserId().orElseThrow(
+                () -> new ErrorException("MypageHandler::User id must exists"));
+
+        File requestedFile = new File(PROFILE_IMG_DIR + "/" + userId);
+        if (requestedFile.exists() && requestedFile.isFile()){
+            response.addModel("profileImageUrl", "/mypage/img/" + userId);
+        } else{
+            response.addModel("profileImageUrl", BASIC_PROFILE_IMG);
+        }
+        response.addModel("defaultProfileImageUrl", BASIC_PROFILE_IMG);
+
+        return response;
+    }
+}