Merge pull request #15 from one-project-one-month/ft/cms1-10

feat: added create page request and get page requests with pagination

Author: SwanHtetAungPhyo

backend/cms-sys/cmd/main.go

@@ -27,6 +27,7 @@ type DISection struct {
 	srv          service.AuthService
 	handler      handler.AuthHandle
 	ownerHandler handler.OwnerHandle
+	pageRequestHandler handler.PageRequestHandle
 }
 
 func main() {
@@ -63,7 +64,7 @@ func main() {
 		appLogger.WithError(err).Fatal("Failed to initialize database connection")
 	}
 
-	err := dbConnection.DB.AutoMigrate(&types.CMSWholeSysRole{}, &types.CMSUser{}, &types.CMSCusPurchase{}, &types.UserPageRequest{})
+	err := dbConnection.DB.AutoMigrate(&types.CMSWholeSysRole{}, &types.CMSUser{}, &types.CMSCusPurchase{}, &types.UserPageRequest{}, &types.Page{}, &types.PageRequest{})
 	if err != nil {
 		appLogger.WithError(err).Fatal("Failed to migrate database")
 		return
@@ -157,6 +158,7 @@ func main() {
 	di := DependencyInjectionSection(appLogger, dbConnection.DB)
 	routes.SetupRoutes(app, di.handler)
 	routes.SetupOwnerRoutes(app, di.ownerHandler)
+	routes.SetupPageRequestRoutes(app, di.pageRequestHandler)
 
 	port := utils.GetEnv("PORT", "8080")
 
@@ -197,10 +199,16 @@ func DependencyInjectionSection(logger *logrus.Logger, db *gorm.DB) *DISection {
 	ownerService := service.NewOwnerService(logger, ownerRepo, repo)
 	ownerHandler := handler.NewOwnerHandler(ownerService)
 
+	// Page Request
+	pageRequestRepo := repository.NewPageRequestRepository(logger, db)
+	pageRequestSrv := service.NewPageRequestService(logger, pageRequestRepo)
+	pageRequestHandler := handler.NewPageRequestHandler(pageRequestSrv)
+
 	return &DISection{
-		repo:         repo,
-		srv:          srv,
-		handler:      authHandler,
+		repo:    repo,
+		srv:     srv,
+		handler: authHandler,
 		ownerHandler: ownerHandler,
+		pageRequestHandler: pageRequestHandler,
 	}
 }

backend/cms-sys/internal/handler/page_request_handler.go

@@ -0,0 +1,70 @@
+package handler
+
+import (
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/service"
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/types"
+	"github.com/multi-tenants-cms-golang/cms-sys/pkg/utils"
+)
+
+type PageRequestHandle interface {
+	Create(c *fiber.Ctx) error
+	GetAll(c *fiber.Ctx) error
+}
+
+type PageRequestHandler struct {
+	service   service.PageRequestService
+	validator *validator.Validate
+}
+
+var _ PageRequestHandle = (*PageRequestHandler)(nil)
+
+func NewPageRequestHandler(service service.PageRequestService) PageRequestHandle {
+	return &PageRequestHandler{
+		service:   service,
+		validator: validator.New(),
+	}
+}
+
+func (h *PageRequestHandler) Create(c *fiber.Ctx) error {
+	var req types.CreatePageRequest
+	if err := c.BodyParser(&req); err != nil {
+		return utils.BadRequestResponse(c, "Invalid request body", err.Error())
+	}
+
+	if err := h.validator.Struct(req); err != nil {
+		return utils.BadRequestResponse(c, "Validation failed", err.Error())
+	}
+
+	pageRequestResponse, err := h.service.CreatePageRequest(req)
+	if err != nil {
+		return utils.InternalServerErrorResponse(c, "Failed to create page request", err.Error())
+	}
+
+	return utils.CreatedResponse(c, "Page request created", pageRequestResponse)
+}
+
+func (h *PageRequestHandler) GetAll(c *fiber.Ctx) error {
+	var req types.PaginateRequest
+	if err := c.QueryParser(&req); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": "Invalid query parameters",
+		})
+	}
+
+	if req.Page <= 0 {
+		req.Page = 1
+	}
+	if req.Limit <= 0 {
+		req.Limit = 10
+	}
+
+	pageRequests, pagination, err := h.service.GetAllPageRequests(&req)
+	if err != nil {
+		return utils.InternalServerErrorResponse(c, "Failed to get page requests", err.Error())
+	}
+
+	return utils.PaginatedSuccessResponse(c, "Page requests retrieved successfully", pageRequests, *pagination)
+}

backend/cms-sys/internal/mapper/page_request_mapper.go

@@ -0,0 +1,19 @@
+package mapper
+
+import (
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/types"
+	"github.com/multi-tenants-cms-golang/cms-sys/pkg/utils"
+)
+
+func ToPageRequestResponse(model *types.PageRequest) *types.PageRequestResponse {
+	return &types.PageRequestResponse{
+		ID:          model.RequestID,
+		OwnerID:     model.OwnerID,
+		RequestType: model.RequestType,
+		Title:       model.Title,
+		Description: utils.SafeString(model.Description),
+		PageUrl:     model.PageUrl,
+		LogoUrl:     model.LogoUrl,
+		CreatedAt:   model.CreatedAt,
+	}
+}

backend/cms-sys/internal/repository/page_request_repo.go

@@ -0,0 +1,53 @@
+package repository
+
+import (
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/types"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+)
+
+type PageRequestRepository interface {
+	CreatePageRequest(pageRequest *types.PageRequest) error
+	GetAllPageRequests(offset, limit int) ([]*types.PageRequest, error)
+	CountPageRequests() (int64, error)
+}
+
+type PageRequestRepositoryImpl struct {
+	logger *logrus.Logger
+	db     *gorm.DB
+}
+
+var _ PageRequestRepository = (*PageRequestRepositoryImpl)(nil)
+
+func NewPageRequestRepository(logger *logrus.Logger, db *gorm.DB) PageRequestRepository {
+	return &PageRequestRepositoryImpl{
+		logger: logger,
+		db:     db,
+	}
+}
+
+func (r *PageRequestRepositoryImpl) CreatePageRequest(pageRequest *types.PageRequest) error {
+	if err := r.db.Create(pageRequest).Error; err != nil {
+		r.logger.WithError(err).Error("Failed to create page request")
+		return err
+	}
+	return nil
+}
+
+func (r *PageRequestRepositoryImpl) GetAllPageRequests(offset, limit int) ([]*types.PageRequest, error) {
+	var pageRequests []*types.PageRequest
+	if err := r.db.Offset(offset).Limit(limit).Find(&pageRequests).Error; err != nil {
+		r.logger.WithError(err).Error("Failed to get all page requests")
+		return nil, err
+	}
+	return pageRequests, nil
+}
+
+func (r *PageRequestRepositoryImpl) CountPageRequests() (int64, error) {
+	var count int64
+	if err := r.db.Model(&types.PageRequest{}).Count(&count).Error; err != nil {
+		r.logger.WithError(err).Error("Failed to count page requests")
+		return 0, err
+	}
+	return count, nil
+}

backend/cms-sys/internal/routes/page_request_route.go

@@ -0,0 +1,12 @@
+package routes
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/handler"
+)
+
+func SetupPageRequestRoutes(app *fiber.App, handler handler.PageRequestHandle) {
+	pageRequest := app.Group("/page-request")
+	pageRequest.Post("/", handler.Create)
+	pageRequest.Get("/", handler.GetAll)
+}

backend/cms-sys/internal/service/auth_service.go

@@ -241,6 +241,7 @@ func (s *Service) UpdateUserProfile(id uuid.UUID, req types.UserUpdateRequest) (
 		CreatedAt: user.CreatedAt,
 		UpdatedAt: user.UpdatedAt,
 	}, nil
+}
 
 }
 func (s *Service) Logout(accessToken, refreshToken string) error {

backend/cms-sys/internal/service/page_request_service.go

@@ -0,0 +1,90 @@
+package service
+
+import (
+	"errors"
+	"math"
+	"github.com/google/uuid"
+	"strings"
+
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/repository"
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/types"
+	"github.com/multi-tenants-cms-golang/cms-sys/pkg/utils"
+	"github.com/multi-tenants-cms-golang/cms-sys/internal/mapper"
+	"github.com/sirupsen/logrus"
+	"time"
+)
+
+type PageRequestService interface {
+	CreatePageRequest(req types.CreatePageRequest) (*types.PageRequestResponse, error)
+	GetAllPageRequests(req *types.PaginateRequest) ([]*types.PageRequestResponse, *utils.Pagination, error)
+}
+
+type PageRequestServiceImpl struct {
+	logger *logrus.Logger
+	repo   repository.PageRequestRepository
+}
+
+var _ PageRequestService = (*PageRequestServiceImpl)(nil)
+
+func NewPageRequestService(logger *logrus.Logger, repo repository.PageRequestRepository) *PageRequestServiceImpl {
+	return &PageRequestServiceImpl{
+		logger: logger,
+		repo:   repo,
+	}
+}
+
+func (s *PageRequestServiceImpl) CreatePageRequest(req types.CreatePageRequest) (*types.PageRequestResponse, error) {
+	ownerUUID, err := uuid.Parse(strings.TrimSpace(req.OwnerID))
+	if err != nil {
+		return nil, errors.New("invalid owner ID format")
+	}
+
+	pageRequest := &types.PageRequest{
+		RequestID:   uuid.New(),
+		OwnerID:     ownerUUID,
+		RequestType: req.RequestType,
+		Title:       req.Title,
+		Description: &req.Description,
+		PageUrl:     req.PageUrl,
+		LogoUrl:     req.Logo, // ko swan will integrate with s3 later
+		CreatedAt:   time.Now(),
+		UpdatedAt:   time.Now(),
+	}
+
+	if err := s.repo.CreatePageRequest(pageRequest); err != nil {
+		s.logger.WithError(err).Error("Failed to create page request")
+		return nil, err
+	}
+
+	return mapper.ToPageRequestResponse(pageRequest), nil
+}
+
+func (s *PageRequestServiceImpl) GetAllPageRequests(req *types.PaginateRequest) ([]*types.PageRequestResponse, *utils.Pagination, error) {
+	total, err := s.repo.CountPageRequests()
+	if err != nil {
+		s.logger.WithError(err).Error("Failed to count page requests")
+		return nil, nil, err
+	}
+
+	offset := utils.CalculateOffset(req.Page, req.Limit)
+
+	pageRequests, err := s.repo.GetAllPageRequests(offset, req.Limit)
+	if err != nil {
+		s.logger.WithError(err).Error("Failed to get all page requests")
+		return nil, nil, err
+	}
+
+	var responses []*types.PageRequestResponse
+	for _, pr := range pageRequests {
+		responses = append(responses, mapper.ToPageRequestResponse(pr))
+	}
+
+	pagination := &utils.Pagination{
+		Page:       req.Page,
+		Limit:      req.Limit,
+		Total:      total,
+		TotalPages: int(math.Ceil(float64(total) / float64(req.Limit))),
+	}
+
+	return responses, pagination, nil
+}