534 lines
14 KiB
Go
534 lines
14 KiB
Go
package user
|
|
|
|
import (
|
|
"fmt"
|
|
"furtuna-be/internal/constants/role"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/xuri/excelize/v2"
|
|
|
|
"furtuna-be/internal/common/errors"
|
|
"furtuna-be/internal/entity"
|
|
"furtuna-be/internal/handlers/request"
|
|
"furtuna-be/internal/handlers/response"
|
|
"furtuna-be/internal/services"
|
|
)
|
|
|
|
type Handler struct {
|
|
service services.User
|
|
}
|
|
|
|
func (h *Handler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
|
|
route := group.Group("/user")
|
|
|
|
route.POST("/", jwt, h.Create)
|
|
route.POST("/customer", jwt, h.CreateCustomer)
|
|
route.POST("/customer-bulk-excel", jwt, h.CreateCustomersFromExcel)
|
|
route.GET("/list", jwt, h.GetAll)
|
|
route.GET("/customer/list", jwt, h.GetAllCustomer)
|
|
route.GET("/:id", jwt, h.GetByID)
|
|
route.PUT("/:id", jwt, h.Update)
|
|
route.PUT("/customer/:id", jwt, h.UpdateCustomer)
|
|
route.DELETE("/customer/:id", jwt, h.DeleteCustomer)
|
|
route.DELETE("/:id", jwt, h.Delete)
|
|
}
|
|
|
|
func NewHandler(service services.User) *Handler {
|
|
return &Handler{
|
|
service: service,
|
|
}
|
|
}
|
|
|
|
// Create handles the creation of a new user.
|
|
// @Summary Create a new user
|
|
// @Description Create a new user based on the provided data.
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT token"
|
|
// @Param req body request.User true "New user details"
|
|
// @Success 200 {object} response.BaseResponse{data=response.User} "User created successfully"
|
|
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
|
|
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
|
|
// @Router /api/v1/user [post]
|
|
// @Tags User APIs
|
|
func (h *Handler) Create(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
var req request.User
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
if !ctx.IsSuperAdmin() {
|
|
req.PartnerID = ctx.GetPartnerID()
|
|
if err := req.Validate(); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorInvalidRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
if req.RoleID == role.Casheer && req.SiteID == nil {
|
|
response.ErrorWrapper(c, errors.NewServiceException("site id is required for cashier"))
|
|
return
|
|
}
|
|
|
|
res, err := h.service.Create(ctx, req.ToEntity(ctx, ""))
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
resp := response.User{
|
|
ID: res.ID,
|
|
Name: res.Name,
|
|
Email: res.Email,
|
|
RoleID: int64(res.RoleID),
|
|
PartnerID: res.PartnerID,
|
|
Status: string(res.Status),
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: resp,
|
|
})
|
|
}
|
|
|
|
func (h *Handler) CreateCustomer(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
var req request.User
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
res, err := h.service.Create(ctx, req.ToEntity(ctx, "CUSTOMER"))
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
resp := response.User{
|
|
ID: res.ID,
|
|
Name: res.Name,
|
|
Email: res.Email,
|
|
RoleID: int64(res.RoleID),
|
|
PartnerID: res.PartnerID,
|
|
Status: string(res.Status),
|
|
PhoneNumber: res.PhoneNumber,
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: resp,
|
|
})
|
|
}
|
|
|
|
func (h *Handler) CreateCustomersFromExcel(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
// var req request.User
|
|
var responseData []response.User
|
|
|
|
file, err := c.FormFile("file")
|
|
if err != nil {
|
|
fmt.Println("err", err.Error())
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
f, err := file.Open()
|
|
if err != nil {
|
|
fmt.Println("err", err.Error())
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
defer f.Close()
|
|
|
|
excel, err := excelize.OpenReader(f)
|
|
if err != nil {
|
|
fmt.Println("err", err.Error())
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
// c.JSON(http.StatusInternalServerError, gin.H{"success": false, "message": "Failed to read Excel file"})
|
|
return
|
|
}
|
|
|
|
// sheetName := excel.GetSheetName(1) // Assuming the data is in the first sheet
|
|
rows, err := excel.GetRows("Sheet1")
|
|
if err != nil {
|
|
fmt.Println("err", err.Error())
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
// c.JSON(http.StatusInternalServerError, gin.H{"success": false, "message": "Failed to read rows from Excel"})
|
|
return
|
|
}
|
|
|
|
var phoneNumbers []string
|
|
|
|
for _, row := range rows {
|
|
if len(row) > 0 {
|
|
phoneNumber := strings.TrimSpace(row[0])
|
|
if phoneNumber != "" {
|
|
phoneNumbers = append(phoneNumbers, phoneNumber)
|
|
}
|
|
}
|
|
}
|
|
|
|
// c.JSON(http.StatusOK, response.BaseResponse{
|
|
// Success: true,
|
|
// Status: http.StatusOK,
|
|
// Data: phoneNumbers,
|
|
// })
|
|
// return
|
|
|
|
if len(phoneNumbers) == 0 {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
// c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "No phone numbers found in the Excel file"})
|
|
return
|
|
}
|
|
|
|
// var createdCustomers []CustomerResponse
|
|
for _, phone := range phoneNumbers {
|
|
req := request.User{
|
|
PhoneNumber: phone,
|
|
Email: "",
|
|
}
|
|
|
|
res, err := h.service.Create(ctx, req.ToEntity(ctx, "CUSTOMER"))
|
|
// res, err := h.service.Create(c, customer)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{
|
|
"success": false,
|
|
"message": fmt.Sprintf("Failed to create customer for phone number %s: %v", phone, err),
|
|
})
|
|
return
|
|
}
|
|
|
|
responseData = append(responseData, response.User{PhoneNumber: res.PhoneNumber})
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: responseData,
|
|
})
|
|
}
|
|
|
|
// Update handles the update of an existing user.
|
|
// @Summary Update an existing user
|
|
// @Description Update the details of an existing user based on the provided ID.
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT token"
|
|
// @Param id path int64 true "User ID to update"
|
|
// @Param req body request.User true "Updated user details"
|
|
// @Success 200 {object} response.BaseResponse{data=response.User} "User updated successfully"
|
|
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
|
|
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
|
|
// @Router /api/v1/user/{id} [put]
|
|
// @Tags User APIs
|
|
func (h *Handler) Update(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
id := c.Param("id")
|
|
|
|
userID, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
var req request.User
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
validate := validator.New()
|
|
if err := validate.Struct(req); err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
updatedUser, err := h.service.Update(ctx, userID, req.ToEntity(ctx, ""))
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: h.toUserResponse(updatedUser),
|
|
})
|
|
}
|
|
func (h *Handler) UpdateCustomer(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
id := c.Param("id")
|
|
|
|
userID, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
var req request.User
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
updatedUser, err := h.service.Update(ctx, userID, req.ToEntity(ctx, "CUSTOMER"))
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: h.toUserResponse(updatedUser),
|
|
})
|
|
}
|
|
|
|
// GetAll retrieves a list of users.
|
|
// @Summary Get a list of users
|
|
// @Description Get a paginated list of users based on query parameters.
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT token"
|
|
// @Param Limit query int false "Number of items to retrieve (default 10)"
|
|
// @Param Offset query int false "Offset for pagination (default 0)"
|
|
// @Success 200 {object} response.BaseResponse{data=response.UserList} "List of users"
|
|
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
|
|
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
|
|
// @Router /api/v1/user/list [get]
|
|
// @Tags User APIs
|
|
func (h *Handler) GetAll(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
var req request.UserParam
|
|
if err := c.ShouldBindQuery(&req); err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
users, total, err := h.service.GetAll(ctx, req.ToEntity(ctx))
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: h.toUserResponseList(users, int64(total), req),
|
|
})
|
|
}
|
|
|
|
func (h *Handler) GetAllCustomer(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
var req request.CustomerParam
|
|
if err := c.ShouldBindQuery(&req); err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
users, total, err := h.service.GetAllCustomer(ctx, req.ToEntity(ctx))
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: h.toCustomerResponseList(users, int64(total), req),
|
|
})
|
|
}
|
|
|
|
// GetByID retrieves details of a specific user by ID.
|
|
// @Summary Get details of a user by ID
|
|
// @Description Get details of a user based on the provided ID.
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT token"
|
|
// @Param id path int64 true "User ID to retrieve"
|
|
// @Success 200 {object} response.BaseResponse{data=response.User} "User details"
|
|
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
|
|
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
|
|
// @Router /api/v1/user/{id} [get]
|
|
// @Tags User APIs
|
|
func (h *Handler) GetByID(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
id := c.Param("id")
|
|
|
|
// Parse the ID into a uint
|
|
userID, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
res, err := h.service.GetByID(ctx, userID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, response.BaseResponse{
|
|
Success: false,
|
|
Status: http.StatusInternalServerError,
|
|
Message: err.Error(),
|
|
Data: nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: h.toUserResponse(res),
|
|
})
|
|
}
|
|
|
|
// Delete handles the deletion of a user by ID.
|
|
// @Summary Delete a user by ID
|
|
// @Description Delete a user based on the provided ID.
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param Authorization header string true "JWT token"
|
|
// @Param id path int64 true "User ID to delete"
|
|
// @Success 200 {object} response.BaseResponse "User deleted successfully"
|
|
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
|
|
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
|
|
// @Router /api/v1/user/{id} [delete]
|
|
// @Tags User APIs
|
|
func (h *Handler) Delete(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
id := c.Param("id")
|
|
|
|
// Parse the ID into a uint
|
|
userID, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
err = h.service.Delete(ctx, userID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, response.BaseResponse{
|
|
Success: false,
|
|
Status: http.StatusInternalServerError,
|
|
Message: err.Error(),
|
|
Data: nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: nil,
|
|
})
|
|
}
|
|
|
|
func (h *Handler) DeleteCustomer(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
id := c.Param("id")
|
|
|
|
// Parse the ID into an int64 (or whatever type is used for customer ID)
|
|
customerID, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
// Handle invalid ID format error
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
// Call the service to delete the customer
|
|
err = h.service.Delete(ctx, customerID)
|
|
if err != nil {
|
|
// If there was an error deleting, return a 500 Internal Server Error
|
|
c.JSON(http.StatusInternalServerError, response.BaseResponse{
|
|
Success: false,
|
|
Status: http.StatusInternalServerError,
|
|
Message: err.Error(),
|
|
Data: nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
// Return a success response after deletion
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Message: "Customer deleted successfully", // Added success message
|
|
Data: nil,
|
|
})
|
|
}
|
|
|
|
func (h *Handler) toUserResponse(resp *entity.User) response.User {
|
|
return response.User{
|
|
ID: resp.ID,
|
|
Name: resp.Name,
|
|
Email: resp.Email,
|
|
PhoneNumber: resp.PhoneNumber,
|
|
NIK: resp.NIK,
|
|
Status: string(resp.Status),
|
|
RoleID: int64(resp.RoleID),
|
|
RoleName: resp.RoleName,
|
|
PartnerID: resp.PartnerID,
|
|
PartnerName: resp.PartnerName,
|
|
CreatedAt: resp.CreatedAt.Format(time.RFC3339),
|
|
UpdatedAt: resp.CreatedAt.Format(time.RFC3339),
|
|
SiteID: resp.SiteID,
|
|
}
|
|
}
|
|
|
|
func (h *Handler) toUserResponseList(resp []*entity.User, total int64, req request.UserParam) response.UserList {
|
|
var users []response.User
|
|
for _, b := range resp {
|
|
users = append(users, h.toUserResponse(b))
|
|
}
|
|
|
|
return response.UserList{
|
|
Users: users,
|
|
Total: total,
|
|
Limit: req.Limit,
|
|
Offset: req.Offset,
|
|
}
|
|
}
|
|
func (h *Handler) toCustomerResponse(resp *entity.Customer) response.Customer {
|
|
return response.Customer{
|
|
ID: resp.ID,
|
|
Name: resp.Name,
|
|
Email: resp.Email,
|
|
PhoneNumber: resp.PhoneNumber,
|
|
Status: string(resp.Status),
|
|
RoleID: int64(resp.RoleID),
|
|
RoleName: resp.RoleName,
|
|
PartnerID: resp.PartnerID,
|
|
PartnerName: resp.PartnerName,
|
|
CreatedAt: resp.CreatedAt.Format(time.RFC3339),
|
|
UpdatedAt: resp.CreatedAt.Format(time.RFC3339),
|
|
}
|
|
}
|
|
|
|
func (h *Handler) toCustomerResponseList(resp []*entity.Customer, total int64, req request.CustomerParam) response.CustomerList {
|
|
var users []response.Customer
|
|
for _, b := range resp {
|
|
users = append(users, h.toCustomerResponse(b))
|
|
}
|
|
|
|
return response.CustomerList{
|
|
Users: users,
|
|
Total: total,
|
|
Limit: req.Limit,
|
|
Offset: req.Offset,
|
|
}
|
|
}
|