naise_pos/db/sqlc/tx_purchase_order.go

package db

import (
	"context"
	"database/sql"
	"fmt"

	"git.nochill.in/nochill/naice_pos/util"
	"github.com/google/uuid"
)

type PurchaseOrderProduct struct {
	ProductID uuid.UUID `json:"product_id"`
	Quantity  float64   `json:"quantity"`
	Sub_total float64   `json:"sub_total"`
	Price     float64   `json:"price"`
}

type PurchasoOrderTxParams struct {
	MerchantID  uuid.UUID              `json:"merchant_id"`
	CreatedBy   uuid.UUID              `json:"created_by"` // user_id
	SupplierID  uuid.UUID              `json:"supplier_id"`
	Code        sql.NullString         `json:"code"`
	IsPaid      bool                   `json:"is_paid"`
	Total       float64                `json:"total"`
	PaidNominal float64                `json:"paid_nominal"`
	Note        sql.NullString         `json:"note"`
	Products    []PurchaseOrderProduct `json:"products"`
}

type PurchaseOrderTxResult struct {
	PurchaseOrder       PurchaseOrder         `json:"purchase_order"`
	PurchaseOrderDetail []PurchaseOrderDetail `json:"detail"`
}

func (store *SQLStore) PurchaseOrderTx(ctx context.Context, arg PurchasoOrderTxParams) (PurchaseOrderTxResult, error) {
	var result PurchaseOrderTxResult

	err := store.execTx(ctx, func(q *Queries) error {
		var err error

		// create purchase order
		result.PurchaseOrder, err = q.CreatePurchaseOrder(ctx, CreatePurchaseOrderParams{
			MerchantID:  arg.MerchantID,
			SupplierID:  arg.SupplierID,
			Code:        arg.Code,
			CreatedBy:   arg.CreatedBy,
			IsPaid:      arg.IsPaid,
			Total:       arg.Total,
			PaidNominal: arg.PaidNominal,
			Note:        arg.Note,
		})

		if err != nil {
			return err
		}

		// create purchase order detail for each products in purchase order
		for i := 0; i < len(arg.Products); i++ {
			purchaseOrderDetail, err := q.CreatePurchaseOrderDetail(ctx, CreatePurchaseOrderDetailParams{
				PurchaseOrderID: result.PurchaseOrder.ID,
				MerchantID:      arg.MerchantID,
				ProductID:       arg.Products[i].ProductID,
				Quantity:        arg.Products[i].Quantity,
				SubTotal:        arg.Products[i].Sub_total,
				ProductPrice:    arg.Products[i].Price,
			})

			if err != nil {
				return err
			}

			result.PurchaseOrderDetail = append(result.PurchaseOrderDetail, purchaseOrderDetail)

			product, err := q.GetStockForUpdateStock(ctx, arg.Products[i].ProductID)
			if err != nil {
				return err
			}

			err = q.UpdateProductStock(ctx, UpdateProductStockParams{
				ID:    product.ID,
				Stock: product.Stock + arg.Products[i].Quantity,
			})
			if err != nil {
				return err
			}

			_, err = q.CreateStockLogs(ctx, CreateStockLogsParams{
				ProductID:              arg.Products[i].ProductID,
				MerchantID:             arg.MerchantID,
				CreatedBy:              arg.CreatedBy,
				TransactionID:          uuid.NullUUID{UUID: result.PurchaseOrder.ID, Valid: true},
				TransactionActionType:  "purchase_order",
				TransactionDescription: fmt.Sprintf("Penambahan stok produk %s dari pembelian dengan code %s", product.Name, arg.Code.String),
				Type:                   util.STOCK_LOG_IN,
				SellingPrice:           product.SellingPrice,
				PurchasePrice:          arg.Products[i].Price,
				Quantity:               arg.Products[i].Quantity,
			})

			if err != nil {
				return err
			}

		}

		return nil
	})

	return result, err
}