naise_pos/api/product.go

package api

import (
	"database/sql"
	"errors"
	"net/http"
	"time"

	db "git.nochill.in/nochill/naice_pos/db/sqlc"
	"git.nochill.in/nochill/naice_pos/token"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

type createProductRequest struct {
	Name              string  `json:"name" binding:"required"`
	SellingPrice      float64 `json:"selling_price" binding:"required"`
	ProductTypeID     int16   `json:"product_type_id" binding:"required"`
	PurchasePrice     float64 `json:"purchase_price" binding:"required"`
	ProductCategoryID string  `json:"product_category_id" binding:"required"`
	Stock             float64 `json:"stock" binding:"number"`
}

func (server *Server) createProduct(ctx *gin.Context) {
	var req createProductRequest

	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, errorResponse(err, ""))
		return
	}

	authPayload := ctx.MustGet(authorizationPayloadKey).(*token.Payload)
	arg := db.CreateProductParams{
		MerchantID:        authPayload.MerchantID,
		Name:              req.Name,
		ProductTypeID:     req.ProductTypeID,
		SellingPrice:      req.SellingPrice,
		PurchasePrice:     req.PurchasePrice,
		ProductCategoryID: uuid.MustParse(req.ProductCategoryID),
		Stock:             req.Stock,
	}

	product, err := server.store.CreateProduct(ctx, arg)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, errorResponse(err, ""))
		return
	}

	ctx.JSON(http.StatusOK, product)
}

type getProductRequest struct {
	ID string `uri:"id" binding:"required,uuid"`
}

func (server *Server) getProduct(ctx *gin.Context) {
	var req getProductRequest
	if err := ctx.ShouldBindUri(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, errorResponse(err, ""))
		return
	}

	product, err := server.store.GetProduct(ctx, uuid.MustParse(req.ID))
	if err != nil {
		if err == sql.ErrNoRows {
			ctx.JSON(http.StatusNotFound, errorResponse(err, ""))
			return
		}
		ctx.JSON(http.StatusInternalServerError, errorResponse(err, ""))
		return
	}

	authPayload := ctx.MustGet(authorizationPayloadKey).(*token.Payload)
	if product.MerchantID != authPayload.MerchantID {
		err := errors.New("Product doesn't belong to the user")
		ctx.JSON(http.StatusUnauthorized, errorResponse(err, ""))
		return
	}

	ctx.JSON(http.StatusOK, product)
}

type listProductsRequest struct {
	PageID   int32 `form:"page_id" binding:"required,min=1"`
	PageSize int32 `form:"page_size" binding:"required,min=5"`
}

func (server *Server) listProducts(ctx *gin.Context) {
	var req listProductsRequest
	if err := ctx.ShouldBindQuery(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, errorResponse(err, ""))
		return
	}

	authPayload := ctx.MustGet(authorizationPayloadKey).(*token.Payload)
	arg := db.ListProductsParams{
		MerchantID: authPayload.MerchantID,
		Limit:      req.PageSize,
		Offset:     (req.PageID - 1) * req.PageSize,
	}

	products, err := server.store.ListProducts(ctx, arg)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, errorResponse(err, ""))
		return
	}

	ctx.JSON(http.StatusOK, products)
}

type updateProductRequest struct {
	ProductID     uuid.UUID `json:"product_id" binding:"required"`
	Name          string    `json:"name" binding:"required"`
	SellingPrice  float64   `json:"selling_price" binding:"required"`
	PurchasePrice float64   `json:"purchase_price" binding:"required"`
}

func (server *Server) updateProduct(ctx *gin.Context) {
	var req updateProductRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, errorResponse(err, ""))
		return
	}

	arg := db.UpdateProductParams{
		ID:            req.ProductID,
		Name:          req.Name,
		SellingPrice:  req.SellingPrice,
		PurchasePrice: req.PurchasePrice,
		UpdatedAt:     sql.NullTime{Time: time.Now(), Valid: true},
	}

	product, err := server.store.UpdateProduct(ctx, arg)
	if err != nil {
		if err == sql.ErrNoRows {
			ctx.JSON(http.StatusNotFound, errorResponse(err, ""))
			return
		}
		ctx.JSON(http.StatusInternalServerError, errorResponse(err, ""))
		return
	}

	ctx.JSON(http.StatusOK, product)
}