feat(image): add update image endpoint and logic

- Implemented UpdateImage handler for updating image files and metadata.
- Added repository and usecase logic for updating image records in the
database.
- Registered new PUT /images/{id} route for authenticated users.
- Updated domain interfaces to support image update operations.
- Refactored event and registration logic for consistency and bug fixes.

Author: Kocannn

app/events/repository/get_events.go

@@ -6,8 +6,11 @@ import (
 	"github.com/hammer-code/lms-be/domain"
 )
 
-func (repo *repository) GetEvents(ctx context.Context, filter domain.EventFilter) (tData int, data []domain.Event, err error) {
-	db := repo.db.DB(ctx).Model(&domain.Event{})
+func (repo *repository) GetEvents(ctx context.Context, filter domain.EventFilter) (tData int, dataDTO []domain.EventDTO, err error) {
+
+	data := []domain.Event{}
+
+	db := repo.db.DB(ctx).Model(&data)
 
 	var totalData int64
 
@@ -35,11 +38,39 @@ func (repo *repository) GetEvents(ctx context.Context, filter domain.EventFilter
 
 	err = db.Limit(filter.FilterPagination.GetLimit()).
 		Offset(filter.FilterPagination.GetOffset()).
-		Preload("Tags").Preload("Speakers").Find(&data).Error
+		Preload("Tags").Preload("Speakers").Preload("Author").Find(&data).Error
 	if err != nil {
 		return
 	}
 
-	return int(totalData), data, err
-}
+	if err == nil {
+		for _, d := range data {
+			dataDTO = append(dataDTO, domain.EventDTO{
+				ID:                   d.ID,
+				Title:                d.Title,
+				Description:          d.Description,
+				Slug:                 d.Slug,
+				Image:                d.Image,
+				Date:                 d.Date,
+				Type:                 d.Type,
+				Location:             d.Location,
+				Duration:             d.Duration,
+				Capacity:             d.Capacity,
+				Status:               d.Status,
+				Tags:                 d.Tags,
+				Speakers:             d.Speakers,
+				SessionType:          d.SessionType,
+				RegistrationLink:     d.RegistrationLink,
+				Price:                d.Price,
+				ReservationStartDate: d.ReservationStartDate,
+				ReservationEndDate:   d.ReservationEndDate,
+				Author:               d.Author.Username,
+				CreatedAt:            d.CreatedAt,
+				UpdatedAt:            d.UpdatedAt,
+				DeletedAt:            d.DeletedAt,
+			})
+		}
+	}
 
+	return int(totalData), dataDTO, err
+}

app/events/usecase/create_registration_event.go

@@ -52,7 +52,7 @@ func (uc usecase) CreateRegistrationEvent(ctx context.Context, payload domain.Re
 			err = utils.NewInternalServerError(ctx, err)
 			return domain.RegisterEventResponse{}, err
 		}
-	
+
 		if dataImage.IsUsed {
 			err = utils.NewNotFoundError(ctx, "image not exists", errors.New("image not exists"))
 			return domain.RegisterEventResponse{}, err
@@ -125,10 +125,8 @@ func (uc usecase) CreateRegistrationEvent(ctx context.Context, payload domain.Re
 
 	// is free event or not
 	status := "SUCCESS"
-	upToYou := "registration success"
 	if event.Price != 0.0 {
 		status = "PENDING"
-		upToYou = "new register"
 		emailPayload.SendEmail(ctx)
 	} else {
 		logrus.Info("free event, send email registration success")
@@ -151,19 +149,14 @@ func (uc usecase) CreateRegistrationEvent(ctx context.Context, payload domain.Re
 	}
 
 	err = uc.dbTX.StartTransaction(ctx, func(txCtx context.Context) error {
-		
 
 		rId, err := uc.repository.CreateRegistrationEvent(txCtx, domain.RegistrationEvent{
-			OrderNo:     orderNo,
-			UserID: 	 strconv.Itoa(userData.ID),
-			EventID:     event.ID,
-			Name:        userData.Username,
-			Email:       userData.Email,
-			PhoneNumber: payload.PhoneNumber,
-			Status:      status,
-			UpToYou:     upToYou,
+			OrderNo:           orderNo,
+			UserID:            strconv.Itoa(userData.ID),
+			EventID:           event.ID,
+			Status:            status,
 			ImageProofPayment: dataImage.FileName,
-			PaymentDate: null.NewTime(time.Now(), true),
+			PaymentDate:       null.NewTime(time.Now(), true),
 		})
 
 		if err != nil {
@@ -175,7 +168,7 @@ func (uc usecase) CreateRegistrationEvent(ctx context.Context, payload domain.Re
 			_, err = uc.repository.CreateEventPay(txCtx, domain.EventPay{
 				RegistrationEventID: rId,
 				EventID:             event.ID,
-				OrderNO: 		     orderNo,
+				OrderNO:             orderNo,
 				ImageProofPayment:   dataImage.FileName,
 				NetAmount:           payload.NetAmount,
 			})

app/events/usecase/get_events.go

@@ -9,7 +9,7 @@ import (
 	"github.com/hammer-code/lms-be/utils"
 )
 
-func (uc usecase) GetEvents(ctx context.Context, filter domain.EventFilter) (resp []domain.Event, pagination domain.Pagination, err error) {
+func (uc usecase) GetEvents(ctx context.Context, filter domain.EventFilter) (resp []domain.EventDTO, pagination domain.Pagination, err error) {
 	tData, datas, err := uc.repository.GetEvents(ctx, filter)
 	if err != nil {
 		err = utils.NewInternalServerError(ctx, err)

app/events/usecase/pay_process.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/hammer-code/lms-be/domain"
+	contextkey "github.com/hammer-code/lms-be/pkg/context_key"
 	"github.com/hammer-code/lms-be/pkg/email"
 	"github.com/hammer-code/lms-be/utils"
 	"github.com/sirupsen/logrus"
@@ -21,7 +22,8 @@ func (uc usecase) PayProcess(ctx context.Context, payload domain.PayProcessPaylo
 		return err
 	}
 
-	logrus.Info("registration event: ", rEvent)
+	userData := ctx.Value(contextkey.UserKey).(domain.User)
+
 	if rEvent.ID == 0 {
 		err = utils.NewNotFoundError(ctx, "registration order not found", errors.New("registration order not found"))
 		return err
@@ -48,7 +50,6 @@ func (uc usecase) PayProcess(ctx context.Context, payload domain.PayProcessPaylo
 
 	eventPay.Status = payload.Status
 	rEvent.Status = payload.Status
-	rEvent.UpToYou = payload.Note
 
 	err = uc.dbTX.StartTransaction(ctx, func(txCtx context.Context) error {
 		err = uc.repository.UpdateEventPay(txCtx, eventPay)
@@ -117,12 +118,12 @@ func (uc usecase) PayProcess(ctx context.Context, payload domain.PayProcessPaylo
 		if err := emailPayload.AddReceiver(
 			ctx,
 			email.Receiver{
-				Email: rEvent.Email,
+				Email: userData.Email,
 				Data: map[string]interface{}{
-					"name":     rEvent.Name,
+					"name":     userData.Username,
 					"title":    event.Title,
 					"price":    event.Price,
-					"email":    rEvent.Email,
+					"email":    userData.Email,
 					"order_no": rEvent.OrderNo,
 					"status":   payload.Status,
 					"note":     payload.Note,

app/images/delivery/http/update_image.go

@@ -0,0 +1,83 @@
+package http
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/gorilla/mux"
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/utils"
+)
+
+func (h Handler) UpdateImage(w http.ResponseWriter, r *http.Request) {
+	// Parse image ID from query or URL (misal: /images/{id})
+	idStr := mux.Vars(r)["id"]
+	if idStr == "" {
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "missing image id",
+		}, w)
+		return
+	}
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "invalid image id",
+		}, w)
+		return
+	}
+
+	// Parse multipart form
+	err = r.ParseMultipartForm(10 << 20) // 10MB
+	if err != nil {
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "failed to parse form",
+		}, w)
+		return
+	}
+	file, header, err := r.FormFile("image")
+	if err != nil {
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusBadRequest,
+			Message: "failed to get file",
+		}, w)
+		return
+	}
+	defer file.Close()
+
+	category := r.FormValue("category")
+	if category == "" {
+		category = "public"
+	}
+
+	contentType := header.Header.Values("Content-Type")[0]
+	contentFiles := strings.Split(contentType, "/")
+
+	upload := domain.UploadImage{
+		File:        file,
+		Header:      header,
+		Category:    category,
+		ContentType: contentType,
+		Format:      contentFiles[1],
+		Type:        contentFiles[0],
+	}
+
+	ctx := r.Context()
+	err = h.usecase.UpdateImage(ctx, upload, uint(id))
+	if err != nil {
+		utils.Response(domain.HttpResponse{
+			Code:    http.StatusInternalServerError,
+			Message: err.Error(),
+		}, w)
+		return
+	}
+
+	utils.Response(domain.HttpResponse{
+		Code:    200,
+		Message: "Image updated successfully",
+	}, w)
+}
+

app/images/repository/update_image.go

@@ -0,0 +1,24 @@
+package repository
+
+import (
+	"context"
+
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/sirupsen/logrus"
+)
+
+func (repo *repository) UpdateImage(ctx context.Context, img domain.Image) error {
+	err := repo.db.DB(ctx).Model(&domain.Image{}).
+		Where("id = ?", img.ID).
+		Updates(map[string]interface{}{
+			"file_name":    img.FileName,
+			"file_path":    img.FilePath,
+			"format":       img.Format,
+			"content_type": img.ContentType,
+		}).Error
+	if err != nil {
+		logrus.Error("repo.UpdateImage : failed to update")
+		return err
+	}
+	return nil
+}

app/images/usecase/update_image.go

@@ -0,0 +1,58 @@
+package usecase
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/pkg/hash"
+	"github.com/sirupsen/logrus"
+)
+
+func (us *usecase) UpdateImage(ctx context.Context, payload domain.UploadImage, id uint) error {
+	var filePath string
+	hName := hash.GenerateHash(time.Now().Format("2006-01-02 15:04:05") + "Hammercode")
+	uploadDir := "./uploads"
+	if payload.UserID != "" {
+		uploadDir = fmt.Sprintf("./uploads/%s", payload.UserID)
+	}
+
+	// file path/category/type image
+	uploadDir = fmt.Sprintf("%s/%s/%s", uploadDir, payload.Category, payload.Type)
+	fileName := fmt.Sprintf("%s.%s", hName[0:15], payload.Format)
+	filePath = fmt.Sprintf("%s/%s", uploadDir, fileName)
+
+	// Ensure the directory exists, create it if it doesn't
+	if err := os.MkdirAll(uploadDir, os.ModePerm); err != nil {
+		logrus.Error("Failed to create directory:", err)
+		return err
+	}
+
+	// Save the file to the uploads directory
+	dst, err := os.Create(filePath)
+	if err != nil {
+		logrus.Error("failed to create file path")
+		return err
+	}
+	defer dst.Close()
+
+	_, err = io.Copy(dst, payload.File)
+	if err != nil {
+		logrus.Error("failed to read all file")
+		return err
+	}
+
+	// Update data di database
+	img := domain.Image{
+		ID:          id,
+		FileName:    fileName,
+		FilePath:    filePath,
+		Format:      payload.Format,
+		ContentType: payload.ContentType,
+	}
+
+	return us.imageRepo.UpdateImage(ctx, img)
+}

cmd/serve_http.go

@@ -155,30 +155,32 @@ func registerHandler(app app.App) *mux.Router {
 	public.HandleFunc("/images", app.ImageHandler.UploadImage).Methods(http.MethodPost)
 	public.HandleFunc("/blogs", app.BlogPostHandler.GetAllBlogPosts).Methods(http.MethodGet)
 	public.HandleFunc("/blogs/{slug}", app.BlogPostHandler.GetDetailBlogPost).Methods(http.MethodGet)
-	
+
 	protectedV1Route := v1.NewRoute().Subrouter()
 	protectedV1Route.Use(app.Middleware.AuthMiddleware(constants.RoleUser))
-	
+
 	protectedV1AdminRoute := v1.PathPrefix("/admin").Subrouter()
 	protectedV1AdminRoute.Use(app.Middleware.AuthMiddleware(constants.RoleAdmin))
-	
+
 	protectedV1Route.HandleFunc("/users", app.UserHandler.GetUsers).Methods(http.MethodGet)
 	protectedV1Route.HandleFunc("/user", app.UserHandler.GetUserProfile).Methods(http.MethodGet)
 	protectedV1Route.HandleFunc("/logout", app.UserHandler.Logout).Methods(http.MethodPost)
-	
+
 	protectedV1Route.HandleFunc("/", app.UserHandler.GetUserById).Methods(http.MethodGet)
 	protectedV1Route.HandleFunc("/update", app.UserHandler.UpdateProfileUser).Methods(http.MethodPut)
 	protectedV1Route.HandleFunc("/delete", app.UserHandler.DeleteUser).Methods(http.MethodDelete)
-	
+
 	protectedV1Route.HandleFunc("/events", app.EventHandler.CreateEvent).Methods(http.MethodPost)
 	protectedV1Route.HandleFunc("/events/registrations", app.EventHandler.RegisterEvent).Methods(http.MethodPost)
 	protectedV1Route.HandleFunc("/events/registrations", app.EventHandler.ListRegistration).Methods(http.MethodGet)
 	protectedV1Route.HandleFunc("/events/pays", app.EventHandler.ListEventPay).Methods(http.MethodGet)
 	protectedV1Route.HandleFunc("/events/pays", app.EventHandler.PayProcess).Methods(http.MethodPost)
+	protectedV1Route.HandleFunc("/events/pay", app.EventHandler.PayEvent).Methods(http.MethodPost)
 	protectedV1Route.HandleFunc("/events/{id}", app.EventHandler.GetEventByID).Methods(http.MethodGet)
 	protectedV1Route.HandleFunc("/events/registrations", app.EventHandler.RegisterEvent).Methods(http.MethodPost)
 
 	protectedV1Route.HandleFunc("/images", app.ImageHandler.UploadImage).Methods(http.MethodPost)
+	protectedV1Route.HandleFunc("/images/{id}", app.ImageHandler.UpdateImage).Methods(http.MethodPut)
 
 	protectedV1Route.HandleFunc("/blogs", app.BlogPostHandler.CreateBlogPost).Methods(http.MethodPost)
 	public.HandleFunc("/blogs", app.BlogPostHandler.GetAllBlogPosts).Methods(http.MethodGet)
@@ -187,7 +189,7 @@ func registerHandler(app app.App) *mux.Router {
 	protectedV1Route.HandleFunc("/blogs/{id}", app.BlogPostHandler.DeleteBlogPost).Methods(http.MethodDelete)
 
 	protectedV1AdminRoute.HandleFunc("/events", app.EventHandler.CreateEvent).Methods(http.MethodPost)
-	protectedV1AdminRoute.HandleFunc("/events", app.EventHandler.GetEvents).Methods(http.MethodGet)
+	protectedV1Route.HandleFunc("/events", app.EventHandler.GetEvents).Methods(http.MethodGet)
 	protectedV1AdminRoute.HandleFunc("/events/{id}", app.EventHandler.DeleteEvent).Methods(http.MethodDelete)
 	protectedV1AdminRoute.HandleFunc("/events/{id}", app.EventHandler.GetDetail).Methods(http.MethodGet)