zineshop/controllers/cartItemController.go

package controllers

import (
	"crypto/rand"
	"encoding/hex"
	"errors"
	"fmt"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"

	"example.com/gin/test/models"
	//"example.com/gin/test/services"
	"example.com/gin/test/repositories"
)

type CartItemController interface {
	//CRUDController
	CartItemView(*gin.Context)
	AddItemHandler(*gin.Context)
	DeleteItemHandler(*gin.Context)
	EditItemHandler(*gin.Context)
	CheckoutView(*gin.Context)
	CheckoutHandler(*gin.Context)
	OrderView(*gin.Context)
	OrderHandler(*gin.Context)
}

type cartItemController struct{}

func NewCartItemController() CartItemController {
	return &cartItemController{}
}

func GetShippingMethods() []models.Shipping {
	return []models.Shipping{
		{Id: "germany", Name: "Germany (DHL)", Price: 3.99},
		{Id: "international", Name: "International (DHL)", Price: 5.99},
		{Id: "pickup", Name: "Pickup", Price: 0.00},
	}
}

func generateSessionId(length int) string {
	bytes := make([]byte, length) // 16 bytes = 128 bits
	_, err := rand.Read(bytes)
	if err != nil {
		panic("failed to generate session ID")
	}
	return hex.EncodeToString(bytes)
}

func GetSessionId(ctx *gin.Context) string {
	sessionId, err := ctx.Cookie("session_id")

	if err != nil {
		sessionId = generateSessionId(16)
		ctx.SetCookie("session_id", sessionId, 3600, "/", "", false, true)
	}

	return sessionId
}

func GenerateToken() string {
	return generateSessionId(8)
}

func (rc *cartItemController) NewCartItemFromForm(ctx *gin.Context) (models.CartItem, error) {
	sessionId := GetSessionId(ctx)
	shopItemIdStr := ctx.PostForm("ShopItemId")
	shopItemId, err := strconv.Atoi(shopItemIdStr)
	itemVariantIdStr := ctx.PostForm("ItemVariantId")
	itemVariantId, err := strconv.Atoi(itemVariantIdStr)

	if err != nil {
		return models.CartItem{}, err
	}

	quantity := 1

	shopItem, err := repositories.ShopItems.GetById(shopItemIdStr)

	if err != nil {
		return models.CartItem{}, err
	}

	itemVariant, err := repositories.ShopItems.GetVariantById(itemVariantIdStr)

	cartItem := models.CartItem{
		SessionId:     sessionId,
		ShopItemId:    uint(shopItemId),
		ShopItem:      shopItem,
		ItemVariantId: uint(itemVariantId),
		ItemVariant:   itemVariant,
		Quantity:      quantity,
	}

	return cartItem, nil
}

func (rc *cartItemController) NewAddressFromForm(ctx *gin.Context) (models.AddressInfo, error) {
	firstName := ctx.PostForm("firstName")
	lastName := ctx.PostForm("lastName")
	address := ctx.PostForm("address")
	postalCode := ctx.PostForm("postalCode")
	city := ctx.PostForm("city")
	country := ctx.PostForm("country")

	if firstName == "" {
		return models.AddressInfo{}, fmt.Errorf("first name missing.")
	}

	if lastName == "" {
		return models.AddressInfo{}, fmt.Errorf("Last name missing.")
	}

	if address == "" {
		return models.AddressInfo{}, fmt.Errorf("address missing.")
	}

	if postalCode == "" {
		return models.AddressInfo{}, fmt.Errorf("postalCode missing.")
	}

	if city == "" {
		return models.AddressInfo{}, fmt.Errorf("city missing.")
	}

	if country == "" {
		return models.AddressInfo{}, fmt.Errorf("country missing.")
	}

	return models.AddressInfo{
		FirstName:  firstName,
		LastName:   lastName,
		Address:    address,
		PostalCode: postalCode,
		City:       city,
		Country:    country,
	}, nil
}

func (rc *cartItemController) NewOrderFromForm(ctx *gin.Context) (models.Order, error) {
	sessionId := GetSessionId(ctx)
	status := models.OrderStatus("Received")
	token := GenerateToken()
	email := ctx.PostForm("email")
	comment := ctx.PostForm("comment")
	firstName := ctx.PostForm("firstName")
	lastName := ctx.PostForm("lastName")
	address := ctx.PostForm("address")
	postalCode := ctx.PostForm("postalCode")
	city := ctx.PostForm("city")
	country := ctx.PostForm("country")
	shippingStr := ctx.PostForm("shippingMethod")

	//address, err := rc.NewAddressFromForm(ctx)
	//if shippingStr != "pickup" {
	//	if err != nil {
	//		return models.Order{}, fmt.Errorf("Invalid address information.")
	//	}
	//}

	var shipping models.Shipping
	for _, shippingMethod := range GetShippingMethods() {
		if shippingMethod.Id == shippingStr {
			shipping = shippingMethod
		}
	}

	if shipping == (models.Shipping{}) {
		return models.Order{}, fmt.Errorf("Invalid shipping method.")
	}

	cartItems, err := repositories.CartItems.GetAllBySession(sessionId)
	fmt.Println(sessionId)
	fmt.Println(cartItems)

	if err != nil {
		return models.Order{}, err
	}

	cartItem := models.Order{
		SessionId:  sessionId,
		Status:     status,
		Token:      token,
		Email:      email,
		Comment:    comment,
		FirstName:  firstName,
		LastName:   lastName,
		Address:    address,
		PostalCode: postalCode,
		City:       city,
		Country:    country,
		Shipping:   shipping.Id,
		CartItems:  cartItems,
	}

	return cartItem, nil
}

func (rc *cartItemController) Create(c *gin.Context) {
	cartItem, err := rc.NewCartItemFromForm(c)

	if err != nil {
		ReplyError(c, fmt.Errorf("cartItem creation failed: %s", err))
		return
	}

	_, err = repositories.CartItems.Create(cartItem)

	if err != nil {
		ReplyError(c, fmt.Errorf("cartItem creation failed: %s", err))
		return
	}

	ReplyOK(c, "cartItem was created")
}

func (rc *cartItemController) Update(c *gin.Context) {
	cartItem, err := rc.NewCartItemFromForm(c)

	if err != nil {
		ReplyError(c, err)
		return
	}

	_, err = repositories.CartItems.Update(cartItem)

	if err != nil {
		ReplyError(c, fmt.Errorf("cartItem creation failed: %s", err))
		return
	}

	ReplyOK(c, "cartItem was updated")
}

//func (rc *cartItemController) Delete(c *gin.Context) {
//	err := repositories.CartItems.DeleteBySessionId(c.Param("id"))
//
//	if err != nil {
//		ReplyError(c, fmt.Errorf("cartItem deletion failed: %s", err))
//		return
//	}
//
//	ReplyOK(c, "cartItem was deleted")
//}

func (rc *cartItemController) CartItemView(c *gin.Context) {
	//sessionId := GetSessionId(c)

	//cartItems, err := repositories.CartItems.GetAllBySession(sessionId)
	cartItems, err := repositories.CartItems.GetAll()

	if err != nil {
		c.HTML(http.StatusBadRequest, "cart.html", gin.H{"data": gin.H{"error": err}})
	}

	priceTotal := 0.0
	for _, cartItem := range cartItems {
		priceTotal += (float64(cartItem.Quantity) * cartItem.ItemVariant.Price)
	}

	fmt.Println("PRICE TOTAL", priceTotal)

	data := CreateSessionData(c, gin.H{
		"cartItems":  cartItems,
		"priceTotal": fmt.Sprintf("%.2f", priceTotal), //round 2 decimals
		"shipping":   GetShippingMethods(),
	})

	c.HTML(http.StatusOK, "cart.html", data)
}

func (rc *cartItemController) AddItemHandler(c *gin.Context) {
	cartItem, err := rc.NewCartItemFromForm(c)

	if err != nil {
		fmt.Println(err)
		c.HTML(http.StatusBadRequest, "error.html", gin.H{"error": err})
		return
	}

	_, err = repositories.CartItems.Create(cartItem)
	if err != nil {
		data := CreateSessionData(c, gin.H{
			"error":   err,
			"success": "",
		})

		c.HTML(http.StatusOK, "cart.html", data)
		return
	}

	rc.CartItemView(c)
}

func (rc *cartItemController) DeleteItemHandler(c *gin.Context) {
	err := repositories.CartItems.DeleteById(c.PostForm("id"))

	if err != nil {
		fmt.Println(err)
		data := CreateSessionData(c, gin.H{
			"error":   err,
			"success": "",
		})

		c.HTML(http.StatusOK, "index.html", data)
	}

	c.Redirect(http.StatusFound, "/cart")
}

func (rc *cartItemController) EditItemHandler(c *gin.Context) {
	cartItemId := c.PostForm("id")
	cartItem, err := repositories.CartItems.GetById(cartItemId)

	if err != nil {
		fmt.Println(err)
		c.Redirect(http.StatusFound, "/cart")
		return
	}

	action := c.PostForm("action")

	if action == "increase" {
		cartItem.Quantity += 1
	}

	if action == "decrease" {
		cartItem.Quantity -= 1

		if cartItem.Quantity == 0 {
			cartItem.Quantity = 1
		}
	}

	_, err = repositories.CartItems.Update(cartItem)

	if err != nil {
		fmt.Println(err)
	}

	c.Redirect(http.StatusFound, "/cart")
}

func (rc *cartItemController) CheckoutView(c *gin.Context) {
	shippingMethod := c.Query("shippingMethod")

	c.HTML(http.StatusOK, "checkout.html", gin.H{
		"askAddress":     (shippingMethod != "pickup"),
		"shippingMethod": shippingMethod,
	})
}

func (rc *cartItemController) CheckoutHandler(c *gin.Context) {
	order, err := rc.NewOrderFromForm(c)

	if err != nil {
		fmt.Println(err)
		c.HTML(http.StatusBadRequest, "error.html", gin.H{"error": err})
		return
	}

	existingOrder, err := repositories.Orders.GetBySession(order.SessionId)

	if errors.Is(err, gorm.ErrRecordNotFound) {
		fmt.Println("CREATE")
		_, err = repositories.Orders.Create(order)
	} else if err == nil {
		fmt.Println("UPDATE")
		order.ID = existingOrder.ID
		order.CreatedAt = existingOrder.CreatedAt
		repositories.Orders.Update(order)
	}

	if err != nil {
		data := CreateSessionData(c, gin.H{
			"error":   err,
			"success": "",
		})

		c.HTML(http.StatusOK, "cart.html", data)
		return
	}

	var shipping models.Shipping
	for _, shippingMethod := range GetShippingMethods() {
		if shippingMethod.Id == order.Shipping {
			shipping = shippingMethod
		}
	}

	priceProducts := 0.0
	for _, cartItem := range order.CartItems {
		priceProducts += (float64(cartItem.Quantity) * cartItem.ItemVariant.Price)
	}

	priceTotal := priceProducts + shipping.Price

	data := CreateSessionData(c, gin.H{
		"error":         "",
		"success":       "",
		"order":         order,
		"askAddress":    (order.Shipping != "pickup"),
		"isPreview":     true,
		"shipping":      shipping,
		"priceProducts": fmt.Sprintf("%.2f", priceProducts), //round 2 decimals
		"priceTotal":    fmt.Sprintf("%.2f", priceTotal),    //round 2 decimals
	})

	fmt.Println(order)
	c.HTML(http.StatusOK, "order.html", data)
}

func (rc *cartItemController) OrderView(c *gin.Context) {
	shippingMethod := c.Query("shippingMethod")

	c.HTML(http.StatusOK, "checkout.html", gin.H{
		"askAddress":     (shippingMethod != "pickup"),
		"shippingMethod": shippingMethod,
	})
}

func (rc *cartItemController) OrderHandler(c *gin.Context) {
	//get order by session id
	//generate token, preview payment info
}