Be 17/refactor blog post

app/app.go

@@ -60,7 +60,7 @@ func InitApp(
 	newsletterUC := newsletters.InitUsecase(cfg, newsletterRepo, dbTx, jwt.NewJwt(cfg.JWT_SECRET_KEY))
 	eventUC := events.InitUsecase(cfg, eventRepo, imgRepo, dbTx)
 	imgUc := images.InitUsecase(imgRepo, dbTx)
-	blogPostUc := blogPost.InitUseCase(blogPostRepo, jwtInstance)
+	blogPostUc := blogPost.InitUseCase(blogPostRepo, dbTx)
 	transactionEventUsecase := transactionEventUC.NewUsecase(transactionEventRepository, eventRepo, xenditClient, cfg)
 
 	// handler

app/blog_post/blogPost.go

@@ -6,15 +6,14 @@ import (
 	blog_post_usecase "github.com/hammer-code/lms-be/app/blog_post/usecase"
 	"github.com/hammer-code/lms-be/domain"
 	"github.com/hammer-code/lms-be/pkg/db"
-	"github.com/hammer-code/lms-be/pkg/jwt"
 )
 
 func InitRepository(db db.DatabaseTransaction) domain.BlogPostRepository {
 	return blog_post_repo.NewRepository(db)
 }
 
-func InitUseCase(repository domain.BlogPostRepository, jwt jwt.JWT) domain.BlogPostUsecase {
-	return blog_post_usecase.NewUsecase(repository, jwt)
+func InitUseCase(repository domain.BlogPostRepository, db db.DatabaseTransaction) domain.BlogPostUsecase {
+	return blog_post_usecase.NewUsecase(repository, db)
 }
 
 func InitHandler(usecase domain.BlogPostUsecase) domain.BlogPostHandler {

app/blog_post/delivery/http/create_blog_post.go

@@ -0,0 +1,43 @@
+package http
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+
+	"github.com/hammer-code/lms-be/domain"
+	contextkey "github.com/hammer-code/lms-be/pkg/context_key"
+	"github.com/hammer-code/lms-be/utils"
+)
+
+// CreateBlogPost implements domain.BlogPostHandler.
+func (h Handler) CreateBlogPost(w http.ResponseWriter, r *http.Request) {
+	bodyBytes, err := io.ReadAll(r.Body)
+	if err != nil {
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	user := r.Context().Value(contextkey.UserKey).(domain.User)
+
+	BlogPost := domain.BlogPost{}
+	if err = json.Unmarshal(bodyBytes, &BlogPost); err != nil {
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	err = h.usecase.CreateBlogPost(r.Context(), BlogPost, user)
+	if err != nil {
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:    http.StatusCreated,
+		Message: "Blog post created successfully",
+	}, w)
+
+}

app/blog_post/delivery/http/delete_blog_posts.go

@@ -0,0 +1,43 @@
+package http
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gorilla/mux"
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/utils"
+	"github.com/sirupsen/logrus"
+)
+
+// DeleteBlogPost implements domain.BlogPostHandler.
+func (h Handler) DeleteBlogPost(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	idString := vars["id"]
+
+	value, err := strconv.ParseUint(idString, 10, 32)
+	if err != nil {
+		logrus.Error("failed to convert string to uint: ", err)
+		utils.Response(domain.HttpResponse{
+			Code:    500,
+			Message: err.Error(),
+		}, w)
+		return
+	}
+
+	err = h.usecase.DeleteBlogPost(r.Context(), uint(value))
+	if err != nil {
+		logrus.Error("failed to delete event : ", err)
+		utils.Response(domain.HttpResponse{
+			Code:    500,
+			Message: err.Error(),
+		}, w)
+		return
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:    200,
+		Message: "success",
+		Data:    nil,
+	}, w)
+}

app/blog_post/delivery/http/get_all_blogs.go

@@ -0,0 +1,73 @@
+package http
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/utils"
+	"github.com/sirupsen/logrus"
+)
+
+// GetAllBlogPosts implements domain.BlogPostHandler.
+func (h Handler) GetAllBlogPosts(w http.ResponseWriter, r *http.Request) {
+	// Ambil parameter pagination dari request
+	pagination, err := domain.GetPaginationFromCtx(r)
+	if err != nil {
+		logrus.Error("failed to parse pagination parameters: ", err)
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "Invalid pagination parameters",
+		}, w)
+		return
+	}
+
+	// Panggil usecase dengan parameter pagination
+	data, paginationResponse, err := h.usecase.GetAllBlogPosts(r.Context(), pagination)
+	if err != nil {
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	type response struct {
+		Id          int           `json:"id" gorm:"primaryKey"`
+		Title       string        `json:"title"`
+		Excerpt     string        `json:"excerpt"`
+		Author      domain.Author `json:"author" gorm:"foreignKey:AuthorID;references:UserId"`
+		AuthorID    int           `json:"author_id" gorm:"column:author_id"`
+		Tags        []string      `json:"tags" gorm:"-"`
+		Category    string        `json:"category"`
+		Status      string        `json:"status" gorm:"type:enum('draft', 'published', 'archived')"`
+		Slug        string        `json:"slug"`
+		PublishedAt *time.Time    `json:"published_at"`
+		UpdatedAt   *time.Time    `json:"updated_at"`
+		CreatedAt   *time.Time    `json:"created_at"`
+	}
+
+	responseDTO := []response{}
+	for _, post := range data {
+		resp := response{
+			Id:          post.Id,
+			Title:       post.Title,
+			Excerpt:     post.Excerpt,
+			Author:      post.Author,
+			AuthorID:    post.AuthorID,
+			Tags:        post.Tags,
+			Category:    post.Category,
+			Status:      post.Status,
+			Slug:        post.Slug,
+			PublishedAt: post.PublishedAt,
+			UpdatedAt:   post.UpdatedAt,
+			CreatedAt:   post.CreatedAt,
+		}
+		responseDTO = append(responseDTO, resp)
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:       http.StatusOK,
+		Message:    "Blog posts retrieved successfully",
+		Data:       responseDTO,
+		Pagination: &paginationResponse,
+	}, w)
+}

app/blog_post/delivery/http/get_detail_blog.go

@@ -0,0 +1,34 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/utils"
+)
+
+// GetDetailBlogPost implements domain.BlogPostHandler.
+func (h Handler) GetDetailBlogPost(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	slug := vars["slug"]
+
+	if slug == "" {
+		resp := utils.CustomErrorResponse(utils.NewBadRequestError(r.Context(), "Slug is required", nil))
+		utils.Response(resp, w)
+		return
+	}
+
+	resp, err := h.usecase.GetDetailBlogPost(r.Context(), slug, 0)
+	if err != nil {
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:    http.StatusOK,
+		Message: "Blog post retrieved successfully",
+		Data:    resp,
+	}, w)
+}