feat(event-registraiton): list registration and path registration status

Author: AfandyW

app/events/delivery/http/event.go

@@ -11,6 +11,7 @@ import (
 	"github.com/hammer-code/lms-be/domain"
 	"github.com/hammer-code/lms-be/pkg/ngelog"
 	"github.com/hammer-code/lms-be/utils"
+	"github.com/sirupsen/logrus"
 )
 
 // @Summary Create Event
@@ -345,3 +346,82 @@ func (h Handler) GetEvents(w http.ResponseWriter, r *http.Request) {
 		Pagination: &pagination,
 	}, w)
 }
+
+func (h Handler) ListRegistrationByEvent(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	idString := vars["id"]
+
+	id, err := strconv.ParseUint(idString, 10, 32)
+	if err != nil {
+		ngelog.Error(r.Context(), "failed to convert string to uint", err)
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusInternalServerError,
+			Message: err.Error(),
+		}, w)
+		return
+	}
+
+	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
+	}
+
+	data, paginationResp, err := h.usecase.ListRegistrationByEvent(r.Context(), uint(id), pagination)
+	if err != nil {
+		ngelog.Error(r.Context(), "failed to get event by id", err)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:       http.StatusOK,
+		Message:    "success",
+		Data:       data,
+		Pagination: &paginationResp,
+	}, w)
+}
+
+func (h Handler) UpdateRegistrationStatus(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	idString := vars["id"]
+
+	id, err := strconv.ParseUint(idString, 10, 32)
+	if err != nil {
+		ngelog.Error(r.Context(), "failed to convert string to uint", err)
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "invalid registration id",
+		}, w)
+		return
+	}
+
+	// Parse payload
+	var req domain.UpdateRegistrationStatusRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "invalid request body",
+		}, w)
+		return
+	}
+
+	// Call usecase with new status
+	err = h.usecase.UpdateRegistrationStatus(r.Context(), uint(id), req)
+	if err != nil {
+		ngelog.Error(r.Context(), "failed to update registration status", err)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
+		return
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:    http.StatusOK,
+		Message: "status updated successfully",
+	}, w)
+}

app/events/repository/get_registration_event.go

@@ -16,3 +16,14 @@ func (repo *repository) GetRegistrationEvent(ctx context.Context, orderNo string
 
 	return data, err
 }
+
+func (repo *repository) GetRegistrationEventByID(ctx context.Context, id uint) (data domain.RegistrationEvent, err error) {
+	db := repo.db.DB(ctx).Model(&domain.RegistrationEvent{})
+
+	err = db.Where("id = ?", id).Find(&data).Error
+	if err != nil {
+		return
+	}
+
+	return data, err
+}

app/events/repository/list_registration_by_event.go

@@ -0,0 +1,43 @@
+package repository
+
+import (
+	"context"
+
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/sirupsen/logrus"
+)
+
+func (repo *repository) ListRegistrationByEvent(ctx context.Context, eventID uint, filterPagination domain.FilterPagination) (data []domain.RegistrationEvent, totalCount int64, err error) {
+	if err := repo.db.DB(ctx).Model(&domain.RegistrationEvent{}).Count(&totalCount).Error; err != nil {
+		logrus.Error("failed to count blog posts: ", err)
+		return nil, 0, err
+	}
+
+	offset := filterPagination.GetOffset()
+	limit := filterPagination.GetLimit()
+	orderBy := filterPagination.GetOrderBy()
+
+	db := repo.db.DB(ctx).
+		Model(&domain.RegistrationEvent{}).
+		Where("event_id = ?", eventID).
+		Preload("User")
+
+	if orderBy == "" {
+		orderBy = "created_at DESC"
+	}
+
+	db = db.Order(orderBy)
+
+	if limit > 0 {
+		db = db.Limit(limit)
+	}
+	if offset > 0 {
+		db = db.Offset(offset)
+	}
+
+	if err := db.Find(&data).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return data, totalCount, nil
+}

app/events/usecase/list_registration_by_event.go

@@ -0,0 +1,31 @@
+package usecase
+
+import (
+	"context"
+	"errors"
+
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/utils"
+)
+
+func (uc usecase) ListRegistrationByEvent(ctx context.Context, id uint, filterPagination domain.FilterPagination) (resp []domain.EventRegistrationDTO, pagination domain.Pagination, err error) {
+
+	registrations, totalCount, err := uc.repository.ListRegistrationByEvent(ctx, id, filterPagination)
+	if err != nil {
+		err = utils.NewInternalServerError(ctx, err)
+		return resp, pagination, err
+	}
+
+	if len(registrations) == 0 {
+		err = utils.NewNotFoundError(ctx, "registration event not found", errors.New("registration event not found"))
+		return resp, pagination, err
+	}
+
+	for _, registration := range registrations {
+		resp = append(resp, registration.ToRegistrationDTO())
+	}
+
+	pagination = domain.NewPagination(int(totalCount), filterPagination)
+
+	return
+}

app/events/usecase/update_registration_status.go

@@ -0,0 +1,39 @@
+package usecase
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/hammer-code/lms-be/domain"
+	contextkey "github.com/hammer-code/lms-be/pkg/context_key"
+	"github.com/hammer-code/lms-be/utils"
+	"gopkg.in/guregu/null.v4"
+)
+
+func (uc usecase) UpdateRegistrationStatus(ctx context.Context, id uint, payload domain.UpdateRegistrationStatusRequest) error {
+	registrations, err := uc.repository.GetRegistrationEventByID(ctx, id)
+	if err != nil {
+		err = utils.NewInternalServerError(ctx, err)
+		return err
+	}
+
+	if registrations.ID == 0 {
+		err = utils.NewNotFoundError(ctx, "registration event not found", errors.New("registration event not found"))
+		return err
+	}
+
+	userData := ctx.Value(contextkey.UserKey).(domain.User)
+
+	registrations.Status = payload.Status
+	registrations.UpdatedAt = null.TimeFrom(time.Now())
+	registrations.UpdatedByUserID = userData.ID
+
+	err = uc.repository.UpdateRegistrationEvent(ctx, registrations)
+	if err != nil {
+		err = utils.NewInternalServerError(ctx, err)
+		return err
+	}
+
+	return nil
+}

cmd/serve_http.go

@@ -190,11 +190,15 @@ func registerHandler(app app.App) *mux.Router {
 	protectedV1Route.HandleFunc("/blogs/{id}", app.BlogPostHandler.DeleteBlogPost).Methods(http.MethodDelete)
 
 	// Admin Route
+	protectedV1AdminRoute.HandleFunc("/events", app.EventHandler.CreateEvent).Methods(http.MethodPost)
 	protectedV1AdminRoute.HandleFunc("/events", app.EventHandler.GetEvents).Methods(http.MethodGet)
+	protectedV1AdminRoute.HandleFunc("/events/{id}", app.EventHandler.GetDetail).Methods(http.MethodGet)
 	protectedV1AdminRoute.HandleFunc("/events/{id}", app.EventHandler.UpdateEvent).Methods(http.MethodPut)
 	protectedV1AdminRoute.HandleFunc("/events/{id}", app.EventHandler.DeleteEvent).Methods(http.MethodDelete)
-	protectedV1AdminRoute.HandleFunc("/events", app.EventHandler.CreateEvent).Methods(http.MethodPost)
-	protectedV1AdminRoute.HandleFunc("/events/{id}", app.EventHandler.GetDetail).Methods(http.MethodGet)
+	protectedV1AdminRoute.HandleFunc("/events/{id}/registration", app.EventHandler.ListRegistrationByEvent).Methods(http.MethodGet)
+	protectedV1AdminRoute.HandleFunc("/events/registration/{id}/status", app.EventHandler.UpdateRegistrationStatus).Methods(http.MethodPatch)
+
+	// users
 	protectedV1AdminRoute.HandleFunc("/users", app.UserHandler.GetUsers).Methods(http.MethodGet)
 
 	protectedV1AdminRoute.HandleFunc("/images", app.ImageHandler.UploadImage).Methods(http.MethodPost)

domain/event.go

@@ -29,6 +29,8 @@ type EventRepository interface {
 	GetEventPay(ctx context.Context, orderNo string) (data EventPay, err error)
 	UpdateRegistrationEvent(ctx context.Context, event RegistrationEvent) error
 	UpdateEvent(ctx context.Context, event Event) error
+	ListRegistrationByEvent(ctx context.Context, eventID uint, pagination FilterPagination) (data []RegistrationEvent, totalCount int64, err error)
+	GetRegistrationEventByID(ctx context.Context, id uint) (data RegistrationEvent, err error)
 }
 
 type EventUsecase interface {
@@ -44,6 +46,8 @@ type EventUsecase interface {
 	ListRegistration(ctx context.Context, filter EventFilter) (resp []RegistrationEvent, pagination Pagination, err error)
 	ListEventPay(ctx context.Context, filter EventFilter) (data []EventPay, pagination Pagination, err error)
 	PayProcess(ctx context.Context, payload PayProcessPayload) error
+	ListRegistrationByEvent(ctx context.Context, eventID uint, filterPagination FilterPagination) (data []EventRegistrationDTO, pagination Pagination, err error)
+	UpdateRegistrationStatus(ctx context.Context, registrationID uint, payload UpdateRegistrationStatusRequest) error
 }
 
 type EventHandler interface {
@@ -60,6 +64,8 @@ type EventHandler interface {
 	ListEventPay(w http.ResponseWriter, r *http.Request)
 	PayProcess(w http.ResponseWriter, r *http.Request)
 	UpdateEvent(w http.ResponseWriter, r *http.Request)
+	ListRegistrationByEvent(w http.ResponseWriter, r *http.Request)
+	UpdateRegistrationStatus(w http.ResponseWriter, r *http.Request)
 }
 
 type Event struct {
@@ -197,7 +203,7 @@ type EventAdminDTO struct {
 	ReservationStartDate null.Time           `json:"reservation_start_date"`
 	ReservationEndDate   null.Time           `json:"reservation_end_date"`
 	// AdditionalLink       string              `json:"additional_link"`
-	SessionType          string              `json:"session_type"`
+	SessionType string `json:"session_type"`
 }
 
 type UpdateEvenPayload struct {
@@ -238,57 +244,12 @@ func (EventPay) TableName() string {
 	return "event_pays"
 }
 
-type RegisterEventPayload struct {
-	EventID           uint    `json:"event_id"`
-	UserID            string  `json:"user_id"`
-	Name              string  `json:"name"`
-	Email             string  `json:"email"`
-	PhoneNumber       string  `json:"phone_number"`
-	ImageProofPayment string  `json:"image_proof_payment"`
-	NetAmount         float64 `json:"net_amount"`
-}
-
-type RegistrationEvent struct {
-	ID                uint      `json:"id" gorm:"primarykey"`
-	OrderNo           string    `json:"order_no"`
-	EventID           uint      `json:"event_id"` // lock event
-	UserID            string    `json:"user_id"`  // lock user
-	ImageProofPayment string    `json:"image_proof_payment"`
-	PaymentDate       null.Time `json:"payment_date"`
-	Status            string    `json:"status"` // register, pay, approve/cancel/decline
-	UpToYou           string    `json:"-"`
-	CreatedByUserID   int       `json:"-"`
-	UpdatedByUserID   int       `json:"-"`
-	DeletedByUserID   int       `json:"-"`
-	CreatedAt         time.Time `json:"created_at"`
-	UpdatedAt         null.Time `json:"-"`
-	DeletedAt         null.Time `json:"-"`
-	Event             Event     `json:"event_detail" gorm:"foreignKey:EventID"`
-}
-
-func (RegistrationEvent) TableName() string {
-	return "registration_events"
-}
-
-type RegistrationEventDTO struct {
-	OrderNo string `json:"order_no"`
-}
-
-type RegisterEventResponse struct {
-	OrderNo string `json:"order_no"`
-}
-
 type EventPayPayload struct {
 	OrderNo           string  `json:"order_no"`
 	ImageProofPayment string  `json:"image_proof_payment"`
 	NetAmount         float64 `json:"net_amount"`
 }
 
-type RegisterStatusResponse struct {
-	OrderNo string `json:"order_no"`
-	Status  string `json:"string"`
-}
-
 type PayProcessPayload struct {
 	OrderNo string `json:"order_no"`
 	Status  string `json:"status"`
@@ -319,12 +280,12 @@ func (e Event) ToDTO() EventDTO {
 
 func (e Event) ToAdminDTO() EventAdminDTO {
 	id := int(e.ID)
-	
+
 	tags := make([]string, len(e.Tags))
 	for i, tag := range e.Tags {
 		tags[i] = tag.Tag
 	}
-	
+
 	speakers := make([]string, len(e.Speakers))
 	for i, speaker := range e.Speakers {
 		speakers[i] = speaker.Name
@@ -350,6 +311,6 @@ func (e Event) ToAdminDTO() EventAdminDTO {
 		ReservationStartDate: e.ReservationStartDate,
 		ReservationEndDate:   e.ReservationEndDate,
 		// AdditionalLink:       e.AdditionalLink,
-		SessionType:          e.SessionType,
+		SessionType: e.SessionType,
 	}
 }