feat: finishing webhook payment gateway, with sender email

Author: mpsalunggg

app/app.go

@@ -4,9 +4,9 @@ import (
 	blogPost "github.com/hammer-code/lms-be/app/blog_post"
 	"github.com/hammer-code/lms-be/app/middlewares"
 	newsletters "github.com/hammer-code/lms-be/app/newsletters"
-	testingTransaction "github.com/hammer-code/lms-be/app/testing_transaction/delivery/http"
-	testingTransactionRepo "github.com/hammer-code/lms-be/app/testing_transaction/repository"
-	testingTransactionUC "github.com/hammer-code/lms-be/app/testing_transaction/usecase"
+	transactionEvent "github.com/hammer-code/lms-be/app/transaction_events/delivery/http"
+	transactionEventRepo "github.com/hammer-code/lms-be/app/transaction_events/repository"
+	transactionEventUC "github.com/hammer-code/lms-be/app/transaction_events/usecase"
 	users "github.com/hammer-code/lms-be/app/users"
 	"github.com/hammer-code/lms-be/config"
 	"github.com/hammer-code/lms-be/domain"
@@ -20,13 +20,13 @@ import (
 )
 
 type App struct {
-	Middleware                 domain.Middleware
-	UserHandler                domain.UserHandler
-	NewLetterHandler           domain.NewslettterHandler
-	EventHandler               domain.EventHandler
-	ImageHandler               domain.ImageHandler
-	BlogPostHandler            domain.BlogPostHandler
-	TestingTransactionHandler  domain.TestingTransactionHandler
+	Middleware              domain.Middleware
+	UserHandler             domain.UserHandler
+	NewLetterHandler        domain.NewslettterHandler
+	EventHandler            domain.EventHandler
+	ImageHandler            domain.ImageHandler
+	BlogPostHandler         domain.BlogPostHandler
+	TransactionEventHandler domain.TransactionEventHandler
 }
 
 func InitApp(
@@ -50,7 +50,7 @@ func InitApp(
 	eventRepo := events.InitRepository(dbTx)
 	imgRepo := images.InitRepository(dbTx)
 	blogPostRepo := blogPost.InitRepository(dbTx)
-	testingTransactionRepository := testingTransactionRepo.NewRepository(db)
+	transactionEventRepository := transactionEventRepo.NewRepository(db)
 
 	// Middlewares
 	middleware := middlewares.InitMiddleware(jwtInstance, userRepo)
@@ -61,23 +61,23 @@ func InitApp(
 	eventUC := events.InitUsecase(cfg, eventRepo, imgRepo, dbTx)
 	imgUc := images.InitUsecase(imgRepo, dbTx)
 	blogPostUc := blogPost.InitUseCase(blogPostRepo, jwtInstance)
-	testingTransactionUsecase := testingTransactionUC.NewUsecase(testingTransactionRepository, xenditClient)
+	transactionEventUsecase := transactionEventUC.NewUsecase(transactionEventRepository, eventRepo, xenditClient, cfg)
 
 	// handler
 	userHandler := users.InitHandler(userUsecase)
 	newsletterHandler := newsletters.InitHandler(newsletterUC, middleware)
 	eventHandler := events.InitHandler(eventUC)
 	ImageHandler := images.InitHandler(imgUc)
 	blogPostHandler := blogPost.InitHandler(blogPostUc)
-	testingTransactionHandler := testingTransaction.NewHandler(testingTransactionUsecase)
+	transactionEventHandler := transactionEvent.NewHandler(transactionEventUsecase, cfg)
 
 	return App{
-		UserHandler:               userHandler,
-		NewLetterHandler:          newsletterHandler,
-		Middleware:                middleware,
-		EventHandler:              eventHandler,
-		ImageHandler:              ImageHandler,
-		BlogPostHandler:           blogPostHandler,
-		TestingTransactionHandler: testingTransactionHandler,
+		UserHandler:             userHandler,
+		NewLetterHandler:        newsletterHandler,
+		Middleware:              middleware,
+		EventHandler:            eventHandler,
+		ImageHandler:            ImageHandler,
+		BlogPostHandler:         blogPostHandler,
+		TransactionEventHandler: transactionEventHandler,
 	}
 }

app/events/repository/get_registration_event.go

@@ -9,7 +9,7 @@ import (
 func (repo *repository) GetRegistrationEvent(ctx context.Context, orderNo string) (data domain.RegistrationEvent, err error) {
 	db := repo.db.DB(ctx).Model(&domain.RegistrationEvent{})
 
-	err = db.Where("order_no = ?", orderNo).Find(&data).Error
+	err = db.Preload("User").Where("order_no = ?", orderNo).Find(&data).Error
 	if err != nil {
 		return
 	}
@@ -20,15 +20,15 @@ func (repo *repository) GetRegistrationEvent(ctx context.Context, orderNo string
 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
+	err = db.Preload("User").Where("id = ?", id).Find(&data).Error
 	if err != nil {
 		return
 	}
 
 	return data, err
 }
 
-func (repo *repository) GetRegistrationEventUserByStatus(ctx context.Context, eventID uint, userID uint, statuses []string) (data []domain.RegistrationEvent, err error) {
+func (repo *repository) GetRegistrationEventUserByStatus(ctx context.Context, eventID uint, userID string, statuses []string) (data []domain.RegistrationEvent, err error) {
 	db := repo.db.DB(ctx).Model(&domain.RegistrationEvent{})
 
 	err = db.Where("event_id = ?", eventID).Where("user_id = ?", userID).Where("status IN (?)", statuses).Find(&data).Error

app/events/repository/list_registration.go

@@ -10,7 +10,15 @@ func (repo *repository) ListRegistration(ctx context.Context, filter domain.Even
 	db := repo.db.DB(ctx).Model(&domain.RegistrationEvent{}).
 		Preload("Event").
 		Preload("Event.Tags").
-		Preload("Event.Speakers")
+		Preload("Event.Speakers").
+		Preload("User").
+		Preload("Transaction")
+
+	// Filter by user email (only show registrations for the logged-in user)
+	if email != "" {
+		db = db.Joins("JOIN users ON users.id = CAST(registration_events.user_id AS INTEGER)").
+			Where("users.email = ?", email)
+	}
 
 	if filter.Status != "" {
 		db = db.Where("registration_events.status = ?", filter.Status)

app/events/usecase/create_registration_event.go

@@ -23,7 +23,7 @@ func (uc usecase) CreateRegistrationEvent(ctx context.Context, payload domain.Re
 	// get user data from context
 	userData := ctx.Value(contextkey.UserKey).(domain.User)
 
-	registrations, err := uc.repository.GetRegistrationEventUserByStatus(ctx, payload.EventID, uint(userData.ID), []string{constants.PENDING, constants.SUCCESS})
+	registrations, err := uc.repository.GetRegistrationEventUserByStatus(ctx, payload.EventID, strconv.Itoa(userData.ID), []string{constants.PENDING, constants.SUCCESS})
 	if err != nil {
 		err = utils.NewInternalServerError(ctx, err)
 		return domain.RegisterEventResponse{}, err

app/events/usecase/list_registration_event.go

@@ -23,12 +23,17 @@ func (uc usecase) ListRegistration(ctx context.Context, filter domain.EventFilte
 
 	for i, data := range datas {
 		datas[i].ImageProofPayment = fmt.Sprintf("%s/api/v1/public/storage/images/%s", baseURL, data.ImageProofPayment)
-		
+
 		// Update event image URL
 		if datas[i].Event.Image != "" {
 			datas[i].Event.Image = fmt.Sprintf("%s/api/v1/public/storage/images/%s", baseURL, datas[i].Event.Image)
 		}
+
+		if data.Transaction != nil && data.Transaction.InvoiceURL != nil {
+			datas[i].PaymentURL = *data.Transaction.InvoiceURL
+			datas[i].TransactionNo = *&data.Transaction.TransactionNo
+		}
 	}
-	
+
 	return datas, domain.NewPagination(tData, filter.FilterPagination), err
 }