feat: add feedbacks and update article comments

app/database/entity/article_comments.entity.go

@@ -3,13 +3,17 @@ package entity
 import "time"
 
 type ArticleComments struct {
-	ID          uint      `json:"id" gorm:"primaryKey;type:int4;autoIncrement"`
+	ID          uint       `json:"id" gorm:"primaryKey;type:int4;autoIncrement"`
-	Message     string    `json:"message" gorm:"type:varchar"`
+	Message     string     `json:"message" gorm:"type:varchar"`
-	ArticleId   uint      `json:"article_id" gorm:"type:int4"`
+	ArticleId   uint       `json:"article_id" gorm:"type:int4"`
-	CommentFrom *uint     `json:"comment_from" gorm:"type:int4"`
+	CommentFrom *uint      `json:"comment_from" gorm:"type:int4"`
-	ParentId    *int      `json:"parent_id" gorm:"type:int4"`
+	ParentId    *int       `json:"parent_id" gorm:"type:int4"`
-	IsPublic    bool      `json:"is_public" gorm:"type:bool"`
+	IsPublic    bool       `json:"is_public" gorm:"type:bool;default:false"`
-	IsActive    bool      `json:"is_active" gorm:"type:bool"`
+	StatusId    int        `json:"status_id" gorm:"type:int4;default:0"`
-	CreatedAt   time.Time `json:"created_at" gorm:"default:now()"`
+	ApprovedAt  *time.Time `json:"approved_at" gorm:"type:timestamp"`
-	UpdatedAt   time.Time `json:"updated_at" gorm:"default:now()"`
+	IsActive    bool       `json:"is_active" gorm:"type:bool"`
+	CreatedAt   time.Time  `json:"created_at" gorm:"default:now()"`
+	UpdatedAt   time.Time  `json:"updated_at" gorm:"default:now()"`
 }
+
+// statusId => 0: waiting, 1: accepted, 2: replied, 3: rejected

app/database/entity/feedbacks.entity.go

@@ -0,0 +1,18 @@
+package entity
+
+import "time"
+
+type Feedbacks struct {
+	ID               uint       `json:"id" gorm:"primaryKey;type:int4;autoIncrement"`
+	Message          string     `json:"message" gorm:"type:varchar"`
+	CommentFromName  string     `json:"comment_from_name" gorm:"type:varchar"`
+	CommentFromEmail string     `json:"comment_from_email" gorm:"type:varchar"`
+	StatusId         int        `json:"status_id" gorm:"type:int4;default:0"`
+	ApprovedAt       *time.Time `json:"approved_at" gorm:"type:timestamp"`
+	ReplyMessage     *string    `json:"reply_message" gorm:"type:varchar"`
+	IsActive         bool       `json:"is_active" gorm:"type:bool"`
+	CreatedAt        time.Time  `json:"created_at" gorm:"default:now()"`
+	UpdatedAt        time.Time  `json:"updated_at" gorm:"default:now()"`
+}
+
+// statusId => 0: waiting, 1: accepted, 2: replied, 3: nothing

app/database/index.database.go

@@ -95,6 +95,8 @@ func Models() []interface{} {
 		entity.Cities{},
 		entity.CustomStaticPages{},
 		entity.Districts{},
+		entity.Feedbacks{},
+		entity.ForgotPasswords{},
 		entity.Magazines{},
 		entity.MagazineFiles{},
 		entity.MasterMenus{},
@@ -102,7 +104,6 @@ func Models() []interface{} {
 		entity.MasterStatuses{},
 		entity.MasterApprovalStatuses{},
 		entity.Provinces{},
-		entity.ForgotPasswords{},
 		entity.RegistrationOtps{},
 		entity.UserLevels{},
 		entity.UserRoles{},

app/module/article_comments/article_comments.module.go

@@ -49,5 +49,6 @@ func (_i *ArticleCommentsRouter) RegisterArticleCommentsRoutes() {
 		router.Post("/", articleCommentsController.Save)
 		router.Put("/:id", articleCommentsController.Update)
 		router.Delete("/:id", articleCommentsController.Delete)
+		router.Post("/approval", articleCommentsController.Approval)
 	})
 }

app/module/article_comments/controller/article_comments.controller.go

@@ -22,6 +22,7 @@ type ArticleCommentsController interface {
 	Save(c *fiber.Ctx) error
 	Update(c *fiber.Ctx) error
 	Delete(c *fiber.Ctx) error
+	Approval(c *fiber.Ctx) error
 }
 
 func NewArticleCommentsController(articleCommentsService service.ArticleCommentsService, log zerolog.Logger) ArticleCommentsController {
@@ -193,3 +194,31 @@ func (_i *articleCommentsController) Delete(c *fiber.Ctx) error {
 		Messages: utilRes.Messages{"ArticleComments successfully deleted"},
 	})
 }
+
+// Approval ArticleComments
+// @Summary      Approval ArticleComments
+// @Description  API for Approval ArticleComments
+// @Tags         ArticleComments
+// @Security     Bearer
+// @Param 	     payload body request.ArticleCommentsApprovalRequest true "Required payload"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /article-comments/approval [post]
+func (_i *articleCommentsController) Approval(c *fiber.Ctx) error {
+	req := new(request.ArticleCommentsApprovalRequest)
+	if err := utilVal.ParseAndValidate(c, req); err != nil {
+		return err
+	}
+
+	err := _i.articleCommentsService.Approval(req.ID, *req)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"ArticleComments successfully reviewed"},
+	})
+}

app/module/article_comments/request/article_comments.request.go

@@ -32,6 +32,7 @@ func (req ArticleCommentsCreateRequest) ToEntity() *entity.ArticleComments {
 		Message:   req.Message,
 		ArticleId: req.ArticleId,
 		ParentId:  req.ParentId,
+		StatusId:  0,
 	}
 }
 
@@ -53,6 +54,20 @@ func (req ArticleCommentsUpdateRequest) ToEntity() *entity.ArticleComments {
 	}
 }
 
+type ArticleCommentsApprovalRequest struct {
+	ID       uint `json:"id" validate:"required"`
+	StatusId int  `json:"statusId" validate:"required"`
+}
+
+func (req ArticleCommentsApprovalRequest) ToEntity() *entity.ArticleComments {
+	approvedNow := time.Now()
+	return &entity.ArticleComments{
+		ID:         req.ID,
+		StatusId:   req.StatusId,
+		ApprovedAt: &approvedNow,
+	}
+}
+
 type ArticleCommentsQueryRequestContext struct {
 	Message     string `json:"message"`
 	ArticleId   string `json:"articleId"`

app/module/article_comments/service/article_comments.service.go

@@ -27,6 +27,7 @@ type ArticleCommentsService interface {
 	Save(req request.ArticleCommentsCreateRequest, authToken string) (articleComments *entity.ArticleComments, err error)
 	Update(id uint, req request.ArticleCommentsUpdateRequest) (err error)
 	Delete(id uint) error
+	Approval(id uint, req request.ArticleCommentsApprovalRequest) (err error)
 }
 
 // NewArticleCommentsService init ArticleCommentsService
@@ -88,3 +89,16 @@ func (_i *articleCommentsService) Delete(id uint) error {
 	result.IsActive = false
 	return _i.Repo.Update(id, result)
 }
+
+func (_i *articleCommentsService) Approval(id uint, req request.ArticleCommentsApprovalRequest) (err error) {
+	_i.Log.Info().Interface("data", req).Msg("")
+	newReq := req.ToEntity()
+
+	if newReq.StatusId == 1 || newReq.StatusId == 2 {
+		newReq.IsPublic = true
+	} else {
+		newReq.IsPublic = false
+	}
+
+	return _i.Repo.Update(id, newReq)
+}

app/module/feedbacks/controller/controller.go

@@ -0,0 +1,16 @@
+package controller
+
+import (
+	"github.com/rs/zerolog"
+	"go-humas-be/app/module/feedbacks/service"
+)
+
+type Controller struct {
+	Feedbacks FeedbacksController
+}
+
+func NewController(FeedbacksService service.FeedbacksService, log zerolog.Logger) *Controller {
+	return &Controller{
+		Feedbacks: NewFeedbacksController(FeedbacksService, log),
+	}
+}

app/module/feedbacks/controller/feedbacks.controller.go

@@ -0,0 +1,194 @@
+package controller
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"github.com/rs/zerolog"
+	"go-humas-be/app/module/feedbacks/request"
+	"go-humas-be/app/module/feedbacks/service"
+	"go-humas-be/utils/paginator"
+	utilRes "go-humas-be/utils/response"
+	utilVal "go-humas-be/utils/validator"
+	"strconv"
+)
+
+type feedbacksController struct {
+	feedbacksService service.FeedbacksService
+	Log              zerolog.Logger
+}
+
+type FeedbacksController interface {
+	All(c *fiber.Ctx) error
+	Show(c *fiber.Ctx) error
+	Save(c *fiber.Ctx) error
+	Update(c *fiber.Ctx) error
+	Delete(c *fiber.Ctx) error
+}
+
+func NewFeedbacksController(feedbacksService service.FeedbacksService, log zerolog.Logger) FeedbacksController {
+	return &feedbacksController{
+		feedbacksService: feedbacksService,
+		Log:              log,
+	}
+}
+
+// All get all Feedbacks
+// @Summary      Get all Feedbacks
+// @Description  API for getting all Feedbacks
+// @Tags         Feedbacks
+// @Security     Bearer
+// @Param 	     req query request.FeedbacksQueryRequest false "query parameters"
+// @Param 	     req query paginator.Pagination false "pagination parameters"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /feedbacks [get]
+func (_i *feedbacksController) All(c *fiber.Ctx) error {
+	paginate, err := paginator.Paginate(c)
+	if err != nil {
+		return err
+	}
+
+	reqContext := request.FeedbacksQueryRequestContext{
+		Message:          c.Query("message"),
+		CommentFromName:  c.Query("commentFromName"),
+		CommentFromEmail: c.Query("commentFromEmail"),
+		StatusId:         c.Query("statusId"),
+	}
+	req := reqContext.ToParamRequest()
+	req.Pagination = paginate
+
+	feedbacksData, paging, err := _i.feedbacksService.All(req)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"Feedbacks list successfully retrieved"},
+		Data:     feedbacksData,
+		Meta:     paging,
+	})
+}
+
+// Show get one Feedbacks
+// @Summary      Get one Feedbacks
+// @Description  API for getting one Feedbacks
+// @Tags         Feedbacks
+// @Security     Bearer
+// @Param        id path int true "Feedbacks ID"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /feedbacks/{id} [get]
+func (_i *feedbacksController) Show(c *fiber.Ctx) error {
+	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	feedbacksData, err := _i.feedbacksService.Show(uint(id))
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"Feedbacks successfully retrieved"},
+		Data:     feedbacksData,
+	})
+}
+
+// Save create Feedbacks
+// @Summary      Create Feedbacks
+// @Description  API for create Feedbacks
+// @Tags         Feedbacks
+// @Security     Bearer
+// @Param        Authorization header string true "Insert your access token" default(Bearer <Add access token here>)
+// @Param 	     payload body request.FeedbacksCreateRequest true "Required payload"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /feedbacks [post]
+func (_i *feedbacksController) Save(c *fiber.Ctx) error {
+	req := new(request.FeedbacksCreateRequest)
+	if err := utilVal.ParseAndValidate(c, req); err != nil {
+		return err
+	}
+
+	authToken := c.Get("Authorization")
+	dataResult, err := _i.feedbacksService.Save(*req, authToken)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"Feedbacks successfully created"},
+		Data:     dataResult,
+	})
+}
+
+// Update update Feedbacks
+// @Summary      update Feedbacks
+// @Description  API for update Feedbacks
+// @Tags         Feedbacks
+// @Security     Bearer
+// @Param 	     payload body request.FeedbacksUpdateRequest true "Required payload"
+// @Param        id path int true "Feedbacks ID"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /feedbacks/{id} [put]
+func (_i *feedbacksController) Update(c *fiber.Ctx) error {
+	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	req := new(request.FeedbacksUpdateRequest)
+	if err := utilVal.ParseAndValidate(c, req); err != nil {
+		return err
+	}
+
+	err = _i.feedbacksService.Update(uint(id), *req)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"Feedbacks successfully updated"},
+	})
+}
+
+// Delete delete Feedbacks
+// @Summary      delete Feedbacks
+// @Description  API for delete Feedbacks
+// @Tags         Feedbacks
+// @Security     Bearer
+// @Param        id path int true "Feedbacks ID"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /feedbacks/{id} [delete]
+func (_i *feedbacksController) Delete(c *fiber.Ctx) error {
+	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	err = _i.feedbacksService.Delete(uint(id))
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"Feedbacks successfully deleted"},
+	})
+}

app/module/feedbacks/feedbacks.module.go

@@ -0,0 +1,53 @@
+package feedbacks
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"go-humas-be/app/module/feedbacks/controller"
+	"go-humas-be/app/module/feedbacks/repository"
+	"go-humas-be/app/module/feedbacks/service"
+	"go.uber.org/fx"
+)
+
+// struct of FeedbacksRouter
+type FeedbacksRouter struct {
+	App        fiber.Router
+	Controller *controller.Controller
+}
+
+// register bulky of Feedbacks module
+var NewFeedbacksModule = fx.Options(
+	// register repository of Feedbacks module
+	fx.Provide(repository.NewFeedbacksRepository),
+
+	// register service of Feedbacks module
+	fx.Provide(service.NewFeedbacksService),
+
+	// register controller of Feedbacks module
+	fx.Provide(controller.NewController),
+
+	// register router of Feedbacks module
+	fx.Provide(NewFeedbacksRouter),
+)
+
+// init FeedbacksRouter
+func NewFeedbacksRouter(fiber *fiber.App, controller *controller.Controller) *FeedbacksRouter {
+	return &FeedbacksRouter{
+		App:        fiber,
+		Controller: controller,
+	}
+}
+
+// register routes of Feedbacks module
+func (_i *FeedbacksRouter) RegisterFeedbacksRoutes() {
+	// define controllers
+	feedbacksController := _i.Controller.Feedbacks
+
+	// define routes
+	_i.App.Route("/feedbacks", func(router fiber.Router) {
+		router.Get("/", feedbacksController.All)
+		router.Get("/:id", feedbacksController.Show)
+		router.Post("/", feedbacksController.Save)
+		router.Put("/:id", feedbacksController.Update)
+		router.Delete("/:id", feedbacksController.Delete)
+	})
+}

app/module/feedbacks/mapper/feedbacks.mapper.go

@@ -0,0 +1,24 @@
+package mapper
+
+import (
+	"go-humas-be/app/database/entity"
+	res "go-humas-be/app/module/feedbacks/response"
+)
+
+func FeedbacksResponseMapper(feedbacksReq *entity.Feedbacks) (feedbacksRes *res.FeedbacksResponse) {
+	if feedbacksReq != nil {
+		feedbacksRes = &res.FeedbacksResponse{
+			ID:               feedbacksReq.ID,
+			Message:          feedbacksReq.Message,
+			CommentFromName:  feedbacksReq.CommentFromName,
+			CommentFromEmail: feedbacksReq.CommentFromEmail,
+			StatusId:         feedbacksReq.StatusId,
+			ApprovedAt:       feedbacksReq.ApprovedAt,
+			ReplyMessage:     feedbacksReq.ReplyMessage,
+			IsActive:         feedbacksReq.IsActive,
+			CreatedAt:        feedbacksReq.CreatedAt,
+			UpdatedAt:        feedbacksReq.UpdatedAt,
+		}
+	}
+	return feedbacksRes
+}

app/module/feedbacks/repository/feedbacks.repository.go

@@ -0,0 +1,101 @@
+package repository
+
+import (
+	"fmt"
+	"github.com/rs/zerolog"
+	"go-humas-be/app/database"
+	"go-humas-be/app/database/entity"
+	"go-humas-be/app/module/feedbacks/request"
+	"go-humas-be/utils/paginator"
+	"strings"
+)
+
+type feedbacksRepository struct {
+	DB  *database.Database
+	Log zerolog.Logger
+}
+
+// FeedbacksRepository define interface of IFeedbacksRepository
+type FeedbacksRepository interface {
+	GetAll(req request.FeedbacksQueryRequest) (feedbackss []*entity.Feedbacks, paging paginator.Pagination, err error)
+	FindOne(id uint) (feedbacks *entity.Feedbacks, err error)
+	Create(feedbacks *entity.Feedbacks) (feedbacksReturn *entity.Feedbacks, err error)
+	Update(id uint, feedbacks *entity.Feedbacks) (err error)
+	Delete(id uint) (err error)
+}
+
+func NewFeedbacksRepository(db *database.Database, logger zerolog.Logger) FeedbacksRepository {
+	return &feedbacksRepository{
+		DB:  db,
+		Log: logger,
+	}
+}
+
+// implement interface of IFeedbacksRepository
+func (_i *feedbacksRepository) GetAll(req request.FeedbacksQueryRequest) (feedbackss []*entity.Feedbacks, paging paginator.Pagination, err error) {
+	var count int64
+
+	query := _i.DB.DB.Model(&entity.Feedbacks{})
+	query = query.Where("is_active = ?", true)
+
+	if req.Message != nil && *req.Message != "" {
+		message := strings.ToLower(*req.Message)
+		query = query.Where("LOWER(message) LIKE ?", "%"+strings.ToLower(message)+"%")
+	}
+	if req.CommentFromName != nil && *req.CommentFromName != "" {
+		commentFromName := strings.ToLower(*req.CommentFromName)
+		query = query.Where("LOWER(comment_from_name) LIKE ?", "%"+strings.ToLower(commentFromName)+"%")
+	}
+	if req.CommentFromEmail != nil && *req.CommentFromEmail != "" {
+		commentFromEmail := strings.ToLower(*req.CommentFromEmail)
+		query = query.Where("LOWER(comment_from_email) LIKE ?", "%"+strings.ToLower(commentFromEmail)+"%")
+	}
+	if req.StatusId != nil {
+		query = query.Where("status_id = ?", req.StatusId)
+	}
+
+	query.Count(&count)
+
+	if req.Pagination.SortBy != "" {
+		direction := "ASC"
+		if req.Pagination.Sort == "desc" {
+			direction = "DESC"
+		}
+		query.Order(fmt.Sprintf("%s %s", req.Pagination.SortBy, direction))
+	}
+
+	req.Pagination.Count = count
+	req.Pagination = paginator.Paging(req.Pagination)
+
+	err = query.Offset(req.Pagination.Offset).Limit(req.Pagination.Limit).Find(&feedbackss).Error
+	if err != nil {
+		return
+	}
+
+	paging = *req.Pagination
+
+	return
+}
+
+func (_i *feedbacksRepository) FindOne(id uint) (feedbacks *entity.Feedbacks, err error) {
+	if err := _i.DB.DB.First(&feedbacks, id).Error; err != nil {
+		return nil, err
+	}
+
+	return feedbacks, nil
+}
+
+func (_i *feedbacksRepository) Create(feedbacks *entity.Feedbacks) (feedbacksReturn *entity.Feedbacks, err error) {
+	result := _i.DB.DB.Create(feedbacks)
+	return feedbacks, result.Error
+}
+
+func (_i *feedbacksRepository) Update(id uint, feedbacks *entity.Feedbacks) (err error) {
+	return _i.DB.DB.Model(&entity.Feedbacks{}).
+		Where(&entity.Feedbacks{ID: id}).
+		Updates(feedbacks).Error
+}
+
+func (_i *feedbacksRepository) Delete(id uint) error {
+	return _i.DB.DB.Delete(&entity.Feedbacks{}, id).Error
+}

app/module/feedbacks/request/feedbacks.request.go

@@ -0,0 +1,81 @@
+package request
+
+import (
+	"go-humas-be/app/database/entity"
+	"go-humas-be/utils/paginator"
+	"strconv"
+	"time"
+)
+
+type FeedbacksGeneric interface {
+	ToEntity()
+}
+
+type FeedbacksQueryRequest struct {
+	Message          *string               `json:"message"`
+	CommentFromName  *string               `json:"commentFromName"`
+	CommentFromEmail *string               `json:"commentFromEmail"`
+	StatusId         *int                  `json:"statusId"`
+	Pagination       *paginator.Pagination `json:"pagination"`
+}
+
+type FeedbacksCreateRequest struct {
+	Message          string `json:"message" validate:"required"`
+	CommentFromName  string `json:"commentFromName" validate:"required"`
+	CommentFromEmail string `json:"commentFromEmail" validate:"required"`
+}
+
+func (req FeedbacksCreateRequest) ToEntity() *entity.Feedbacks {
+	return &entity.Feedbacks{
+		Message:          req.Message,
+		CommentFromName:  req.CommentFromName,
+		CommentFromEmail: req.CommentFromEmail,
+		StatusId:         0,
+	}
+}
+
+type FeedbacksUpdateRequest struct {
+	ID               uint   `json:"id" validate:"required"`
+	Message          string `json:"message" validate:"required"`
+	CommentFromName  string `json:"commentFromName" validate:"required"`
+	CommentFromEmail string `json:"commentFromEmail" validate:"required"`
+}
+
+func (req FeedbacksUpdateRequest) ToEntity() *entity.Feedbacks {
+	return &entity.Feedbacks{
+		ID:               req.ID,
+		Message:          req.Message,
+		CommentFromName:  req.CommentFromName,
+		CommentFromEmail: req.CommentFromEmail,
+		UpdatedAt:        time.Now(),
+	}
+}
+
+type FeedbacksQueryRequestContext struct {
+	Message          string `json:"message"`
+	CommentFromName  string `json:"commentFromName"`
+	CommentFromEmail string `json:"commentFromEmail"`
+	StatusId         string `json:"statusId"`
+}
+
+func (req FeedbacksQueryRequestContext) ToParamRequest() FeedbacksQueryRequest {
+	var request FeedbacksQueryRequest
+
+	if message := req.Message; message != "" {
+		request.Message = &message
+	}
+	if commentFromName := req.CommentFromName; commentFromName != "" {
+		request.CommentFromName = &commentFromName
+	}
+	if commentFromEmail := req.CommentFromEmail; commentFromEmail != "" {
+		request.CommentFromEmail = &commentFromEmail
+	}
+	if statusIdStr := req.StatusId; statusIdStr != "" {
+		statusId, err := strconv.Atoi(statusIdStr)
+		if err == nil {
+			request.StatusId = &statusId
+		}
+	}
+
+	return request
+}

app/module/feedbacks/response/feedbacks.response.go

@@ -0,0 +1,16 @@
+package response
+
+import "time"
+
+type FeedbacksResponse struct {
+	ID               uint       `json:"id"`
+	Message          string     `json:"message"`
+	CommentFromName  string     `json:"commentFromName"`
+	CommentFromEmail string     `json:"commentFromEmail"`
+	StatusId         int        `json:"statusId"`
+	ApprovedAt       *time.Time `json:"approvedAt"`
+	ReplyMessage     *string    `json:"replyMessage"`
+	IsActive         bool       `json:"isActive"`
+	CreatedAt        time.Time  `json:"createdAt"`
+	UpdatedAt        time.Time  `json:"updatedAt"`
+}

app/module/feedbacks/service/feedbacks.service.go

@@ -0,0 +1,80 @@
+package service
+
+import (
+	"github.com/rs/zerolog"
+	"go-humas-be/app/database/entity"
+	"go-humas-be/app/module/feedbacks/mapper"
+	"go-humas-be/app/module/feedbacks/repository"
+	"go-humas-be/app/module/feedbacks/request"
+	"go-humas-be/app/module/feedbacks/response"
+	usersRepository "go-humas-be/app/module/users/repository"
+	"go-humas-be/utils/paginator"
+)
+
+// FeedbacksService
+type feedbacksService struct {
+	Repo      repository.FeedbacksRepository
+	UsersRepo usersRepository.UsersRepository
+	Log       zerolog.Logger
+}
+
+// FeedbacksService define interface of IFeedbacksService
+type FeedbacksService interface {
+	All(req request.FeedbacksQueryRequest) (feedbacks []*response.FeedbacksResponse, paging paginator.Pagination, err error)
+	Show(id uint) (feedbacks *response.FeedbacksResponse, err error)
+	Save(req request.FeedbacksCreateRequest, authToken string) (feedbacks *entity.Feedbacks, err error)
+	Update(id uint, req request.FeedbacksUpdateRequest) (err error)
+	Delete(id uint) error
+}
+
+// NewFeedbacksService init FeedbacksService
+func NewFeedbacksService(repo repository.FeedbacksRepository, log zerolog.Logger, usersRepo usersRepository.UsersRepository) FeedbacksService {
+
+	return &feedbacksService{
+		Repo:      repo,
+		Log:       log,
+		UsersRepo: usersRepo,
+	}
+}
+
+// All implement interface of FeedbacksService
+func (_i *feedbacksService) All(req request.FeedbacksQueryRequest) (feedbackss []*response.FeedbacksResponse, paging paginator.Pagination, err error) {
+	results, paging, err := _i.Repo.GetAll(req)
+	if err != nil {
+		return
+	}
+
+	for _, result := range results {
+		feedbackss = append(feedbackss, mapper.FeedbacksResponseMapper(result))
+	}
+
+	return
+}
+
+func (_i *feedbacksService) Show(id uint) (feedbacks *response.FeedbacksResponse, err error) {
+	result, err := _i.Repo.FindOne(id)
+	if err != nil {
+		return nil, err
+	}
+
+	return mapper.FeedbacksResponseMapper(result), nil
+}
+
+func (_i *feedbacksService) Save(req request.FeedbacksCreateRequest, authToken string) (feedbacks *entity.Feedbacks, err error) {
+	_i.Log.Info().Interface("data", req).Msg("")
+	return _i.Repo.Create(req.ToEntity())
+}
+
+func (_i *feedbacksService) Update(id uint, req request.FeedbacksUpdateRequest) (err error) {
+	_i.Log.Info().Interface("data", req).Msg("")
+	return _i.Repo.Update(id, req.ToEntity())
+}
+
+func (_i *feedbacksService) Delete(id uint) error {
+	result, err := _i.Repo.FindOne(id)
+	if err != nil {
+		return err
+	}
+	result.IsActive = false
+	return _i.Repo.Update(id, result)
+}

app/router/api.go

@@ -14,6 +14,7 @@ import (
 	"go-humas-be/app/module/cities"
 	"go-humas-be/app/module/custom_static_pages"
 	"go-humas-be/app/module/districts"
+	"go-humas-be/app/module/feedbacks"
 	"go-humas-be/app/module/magazine_files"
 	"go-humas-be/app/module/magazines"
 	"go-humas-be/app/module/master_menus"
@@ -42,6 +43,7 @@ type Router struct {
 	CitiesRouter                 *cities.CitiesRouter
 	CustomStaticPagesRouter      *custom_static_pages.CustomStaticPagesRouter
 	DistrictsRouter              *districts.DistrictsRouter
+	FeedbacksRouter              *feedbacks.FeedbacksRouter
 	MagazineFilesRouter          *magazine_files.MagazineFilesRouter
 	MagazinesRouter              *magazines.MagazinesRouter
 	MasterMenusRouter            *master_menus.MasterMenusRouter
@@ -68,6 +70,7 @@ func NewRouter(
 	citiesRouter *cities.CitiesRouter,
 	customStaticPagesRouter *custom_static_pages.CustomStaticPagesRouter,
 	districtsRouter *districts.DistrictsRouter,
+	feedbacksRouter *feedbacks.FeedbacksRouter,
 	magazineFilesRouter *magazine_files.MagazineFilesRouter,
 	magazinesRouter *magazines.MagazinesRouter,
 	masterMenuRouter *master_menus.MasterMenusRouter,
@@ -92,6 +95,7 @@ func NewRouter(
 		CitiesRouter:                 citiesRouter,
 		CustomStaticPagesRouter:      customStaticPagesRouter,
 		DistrictsRouter:              districtsRouter,
+		FeedbacksRouter:              feedbacksRouter,
 		MagazineFilesRouter:          magazineFilesRouter,
 		MagazinesRouter:              magazinesRouter,
 		MasterMenusRouter:            masterMenuRouter,
@@ -126,6 +130,7 @@ func (r *Router) Register() {
 	r.CitiesRouter.RegisterCitiesRoutes()
 	r.CustomStaticPagesRouter.RegisterCustomStaticPagesRoutes()
 	r.DistrictsRouter.RegisterDistrictsRoutes()
+	r.FeedbacksRouter.RegisterFeedbacksRoutes()
 	r.MagazinesRouter.RegisterMagazinesRoutes()
 	r.MagazineFilesRouter.RegisterMagazineFilesRoutes()
 	r.MasterMenusRouter.RegisterMasterMenusRoutes()

docs/swagger/docs.go

@@ -1596,6 +1596,57 @@ const docTemplate = `{
                 }
             }
         },
+        "/article-comments/approval": {
+            "post": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for Approval ArticleComments",
+                "tags": [
+                    "ArticleComments"
+                ],
+                "summary": "Approval ArticleComments",
+                "parameters": [
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.ArticleCommentsApprovalRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
         "/article-comments/{id}": {
             "get": {
                 "security": [
@@ -4092,6 +4143,317 @@ const docTemplate = `{
                 }
             }
         },
+        "/feedbacks": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting all Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "Get all Feedbacks",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "name": "commentFromEmail",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "commentFromName",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "message",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "statusId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "count",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "limit",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "nextPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "page",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "previousPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sort",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sortBy",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "totalPage",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "post": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for create Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "Create Feedbacks",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "default": "Bearer \u003cAdd access token here\u003e",
+                        "description": "Insert your access token",
+                        "name": "Authorization",
+                        "in": "header",
+                        "required": true
+                    },
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.FeedbacksCreateRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
+        "/feedbacks/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting one Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "Get one Feedbacks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Feedbacks ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for update Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "update Feedbacks",
+                "parameters": [
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.FeedbacksUpdateRequest"
+                        }
+                    },
+                    {
+                        "type": "integer",
+                        "description": "Feedbacks ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for delete Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "delete Feedbacks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Feedbacks ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
         "/magazine-files": {
             "get": {
                 "security": [
@@ -8134,6 +8496,21 @@ const docTemplate = `{
                 }
             }
         },
+        "request.ArticleCommentsApprovalRequest": {
+            "type": "object",
+            "required": [
+                "id",
+                "statusId"
+            ],
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "statusId": {
+                    "type": "integer"
+                }
+            }
+        },
         "request.ArticleCommentsCreateRequest": {
             "type": "object",
             "required": [
@@ -8507,6 +8884,48 @@ const docTemplate = `{
                 }
             }
         },
+        "request.FeedbacksCreateRequest": {
+            "type": "object",
+            "required": [
+                "commentFromEmail",
+                "commentFromName",
+                "message"
+            ],
+            "properties": {
+                "commentFromEmail": {
+                    "type": "string"
+                },
+                "commentFromName": {
+                    "type": "string"
+                },
+                "message": {
+                    "type": "string"
+                }
+            }
+        },
+        "request.FeedbacksUpdateRequest": {
+            "type": "object",
+            "required": [
+                "commentFromEmail",
+                "commentFromName",
+                "id",
+                "message"
+            ],
+            "properties": {
+                "commentFromEmail": {
+                    "type": "string"
+                },
+                "commentFromName": {
+                    "type": "string"
+                },
+                "id": {
+                    "type": "integer"
+                },
+                "message": {
+                    "type": "string"
+                }
+            }
+        },
         "request.MagazinesCreateRequest": {
             "type": "object",
             "required": [

docs/swagger/swagger.json

@@ -1585,6 +1585,57 @@
                 }
             }
         },
+        "/article-comments/approval": {
+            "post": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for Approval ArticleComments",
+                "tags": [
+                    "ArticleComments"
+                ],
+                "summary": "Approval ArticleComments",
+                "parameters": [
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.ArticleCommentsApprovalRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
         "/article-comments/{id}": {
             "get": {
                 "security": [
@@ -4081,6 +4132,317 @@
                 }
             }
         },
+        "/feedbacks": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting all Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "Get all Feedbacks",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "name": "commentFromEmail",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "commentFromName",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "message",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "statusId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "count",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "limit",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "nextPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "page",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "previousPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sort",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sortBy",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "totalPage",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "post": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for create Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "Create Feedbacks",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "default": "Bearer \u003cAdd access token here\u003e",
+                        "description": "Insert your access token",
+                        "name": "Authorization",
+                        "in": "header",
+                        "required": true
+                    },
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.FeedbacksCreateRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
+        "/feedbacks/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting one Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "Get one Feedbacks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Feedbacks ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for update Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "update Feedbacks",
+                "parameters": [
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.FeedbacksUpdateRequest"
+                        }
+                    },
+                    {
+                        "type": "integer",
+                        "description": "Feedbacks ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for delete Feedbacks",
+                "tags": [
+                    "Feedbacks"
+                ],
+                "summary": "delete Feedbacks",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "Feedbacks ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
         "/magazine-files": {
             "get": {
                 "security": [
@@ -8123,6 +8485,21 @@
                 }
             }
         },
+        "request.ArticleCommentsApprovalRequest": {
+            "type": "object",
+            "required": [
+                "id",
+                "statusId"
+            ],
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "statusId": {
+                    "type": "integer"
+                }
+            }
+        },
         "request.ArticleCommentsCreateRequest": {
             "type": "object",
             "required": [
@@ -8496,6 +8873,48 @@
                 }
             }
         },
+        "request.FeedbacksCreateRequest": {
+            "type": "object",
+            "required": [
+                "commentFromEmail",
+                "commentFromName",
+                "message"
+            ],
+            "properties": {
+                "commentFromEmail": {
+                    "type": "string"
+                },
+                "commentFromName": {
+                    "type": "string"
+                },
+                "message": {
+                    "type": "string"
+                }
+            }
+        },
+        "request.FeedbacksUpdateRequest": {
+            "type": "object",
+            "required": [
+                "commentFromEmail",
+                "commentFromName",
+                "id",
+                "message"
+            ],
+            "properties": {
+                "commentFromEmail": {
+                    "type": "string"
+                },
+                "commentFromName": {
+                    "type": "string"
+                },
+                "id": {
+                    "type": "integer"
+                },
+                "message": {
+                    "type": "string"
+                }
+            }
+        },
         "request.MagazinesCreateRequest": {
             "type": "object",
             "required": [

docs/swagger/swagger.yaml

@@ -129,6 +129,16 @@ definitions:
     - statusId
     - title
     type: object
+  request.ArticleCommentsApprovalRequest:
+    properties:
+      id:
+        type: integer
+      statusId:
+        type: integer
+    required:
+    - id
+    - statusId
+    type: object
   request.ArticleCommentsCreateRequest:
     properties:
       articleId:
@@ -388,6 +398,35 @@ definitions:
     - slug
     - title
     type: object
+  request.FeedbacksCreateRequest:
+    properties:
+      commentFromEmail:
+        type: string
+      commentFromName:
+        type: string
+      message:
+        type: string
+    required:
+    - commentFromEmail
+    - commentFromName
+    - message
+    type: object
+  request.FeedbacksUpdateRequest:
+    properties:
+      commentFromEmail:
+        type: string
+      commentFromName:
+        type: string
+      id:
+        type: integer
+      message:
+        type: string
+    required:
+    - commentFromEmail
+    - commentFromName
+    - id
+    - message
+    type: object
   request.MagazinesCreateRequest:
     properties:
       createdById:
@@ -1928,6 +1967,38 @@ paths:
       summary: update ArticleComments
       tags:
       - ArticleComments
+  /article-comments/approval:
+    post:
+      description: API for Approval ArticleComments
+      parameters:
+      - description: Required payload
+        in: body
+        name: payload
+        required: true
+        schema:
+          $ref: '#/definitions/request.ArticleCommentsApprovalRequest'
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Approval ArticleComments
+      tags:
+      - ArticleComments
   /article-files:
     get:
       description: API for getting all ArticleFiles
@@ -3410,6 +3481,202 @@ paths:
       summary: Update Districts
       tags:
       - Untags
+  /feedbacks:
+    get:
+      description: API for getting all Feedbacks
+      parameters:
+      - in: query
+        name: commentFromEmail
+        type: string
+      - in: query
+        name: commentFromName
+        type: string
+      - in: query
+        name: message
+        type: string
+      - in: query
+        name: statusId
+        type: integer
+      - in: query
+        name: count
+        type: integer
+      - in: query
+        name: limit
+        type: integer
+      - in: query
+        name: nextPage
+        type: integer
+      - in: query
+        name: page
+        type: integer
+      - in: query
+        name: previousPage
+        type: integer
+      - in: query
+        name: sort
+        type: string
+      - in: query
+        name: sortBy
+        type: string
+      - in: query
+        name: totalPage
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Get all Feedbacks
+      tags:
+      - Feedbacks
+    post:
+      description: API for create Feedbacks
+      parameters:
+      - default: Bearer <Add access token here>
+        description: Insert your access token
+        in: header
+        name: Authorization
+        required: true
+        type: string
+      - description: Required payload
+        in: body
+        name: payload
+        required: true
+        schema:
+          $ref: '#/definitions/request.FeedbacksCreateRequest'
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Create Feedbacks
+      tags:
+      - Feedbacks
+  /feedbacks/{id}:
+    delete:
+      description: API for delete Feedbacks
+      parameters:
+      - description: Feedbacks ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: delete Feedbacks
+      tags:
+      - Feedbacks
+    get:
+      description: API for getting one Feedbacks
+      parameters:
+      - description: Feedbacks ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Get one Feedbacks
+      tags:
+      - Feedbacks
+    put:
+      description: API for update Feedbacks
+      parameters:
+      - description: Required payload
+        in: body
+        name: payload
+        required: true
+        schema:
+          $ref: '#/definitions/request.FeedbacksUpdateRequest'
+      - description: Feedbacks ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: update Feedbacks
+      tags:
+      - Feedbacks
   /magazine-files:
     get:
       description: API for getting all MagazineFiles

main.go

@@ -15,6 +15,7 @@ import (
 	"go-humas-be/app/module/cities"
 	"go-humas-be/app/module/custom_static_pages"
 	"go-humas-be/app/module/districts"
+	"go-humas-be/app/module/feedbacks"
 	"go-humas-be/app/module/magazine_files"
 	"go-humas-be/app/module/magazines"
 	"go-humas-be/app/module/master_menus"
@@ -67,6 +68,7 @@ func main() {
 		cities.NewCitiesModule,
 		custom_static_pages.NewCustomStaticPagesModule,
 		districts.NewDistrictsModule,
+		feedbacks.NewFeedbacksModule,
 		magazines.NewMagazinesModule,
 		magazine_files.NewMagazineFilesModule,
 		master_menus.NewMasterMenusModule,