resolve rackcash#4 & refactor

Author: bstrdlord

api/internal/app/app.go

@@ -12,6 +12,7 @@ import (
 	"syscall"
 
 	"github.com/gin-gonic/gin"
+	cors "github.com/rs/cors/wrapper/gin"
 	"gorm.io/gorm"
 )
 
@@ -34,6 +35,8 @@ func (app *App) Start() {
 
 	r := gin.New()
 
+	r.Use(cors.Default())
+
 	services := service.HewServices(app.NatsInfra.Ns, app.Db, app.Log, app.Config)
 
 	app.Autostart(services)

api/internal/delivery/rest/v1/invoice_public.go

@@ -121,7 +121,8 @@ func (h *Handler) invoiceCreate(c *gin.Context) {
 }
 
 // POST /invoice/info
-func (h *Handler) info(c *gin.Context) {
+func (h *Handler) invoiceInfo(c *gin.Context) {
+	// TODO: validation
 	var data struct {
 		InvoiceId string `json:"invoice_id"`
 		ApiKey    string `json:"api_key"`
@@ -183,7 +184,7 @@ func (h *Handler) info(c *gin.Context) {
 		CreatedAt:      invoice.CreatedAt.Format("2006-01-02 15:04:05"),
 	}
 
-	if time.Now().Unix() > invoice.EndTimestamp && invoice.Status.IsNotPaid() {
+	if time.Now().Unix() > invoice.EndTimestamp && invoice.Status.IsNotPaid() && !invoice.Status.IsCancelled() {
 		response.Status = "end"
 	}
 
@@ -228,8 +229,66 @@ func (h *Handler) qrCode(c *gin.Context) {
 	c.Data(http.StatusOK, "image/png", []byte(qrCode))
 }
 
+func (h *Handler) invoiceCancel(c *gin.Context) {
+	var data struct {
+		InvoiceId string `json:"invoice_id"`
+		ApiKey    string `json:"api_key"`
+	}
+
+	var errid = logger.GenErrorId()
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		responseErr(c, http.StatusBadRequest, domain.ErrMsgBadRequest, "")
+		fmt.Println("unmarshal error: " + err.Error())
+		return
+	}
+
+	if data.InvoiceId == "" {
+		responseErr(c, http.StatusBadRequest, fmt.Sprintf(domain.ErrMsgParamsBadRequest, domain.ErrParamEmptyInvoiceId), "")
+		return
+	}
+
+	if data.ApiKey == "" {
+		responseErr(c, http.StatusBadRequest, domain.ErrMsgApiKeyInvalid, "")
+		return
+	}
+
+	exists, err := h.services.Merchants.ApiKeyExists(h.db, data.ApiKey)
+	if err != nil {
+		responseErr(c, http.StatusInternalServerError, domain.ErrMsgInternalServerError, errid)
+		h.log.TemplInvoiceErr("api key exists error: "+err.Error(), errid, data.InvoiceId, decimal.Zero, logger.NA, c.Request.RequestURI, logger.NA, c.ClientIP())
+		return
+	}
+
+	if !exists {
+		responseErr(c, http.StatusBadRequest, domain.ErrMsgApiKeyNotFound, "")
+		return
+	}
+
+	if err = h.services.Invoices.Cancel(data.InvoiceId); err != nil {
+		var _errid = ""
+		var errmsg = err.Error()
+
+		code := domain.GetStatusByErr(err)
+		if code == http.StatusInternalServerError {
+			_errid = errid
+			errmsg = domain.ErrMsgInternalServerError
+			h.log.TemplInvoiceErr("invoice cancel error: "+err.Error(), errid, data.InvoiceId, decimal.Zero, logger.NA, c.Request.RequestURI, logger.NA, c.ClientIP())
+		}
+		responseErr(c, code, errmsg, _errid)
+		return
+	}
+
+	c.AbortWithStatusJSON(http.StatusOK, responseInvoiceCancelled{
+		Error: false,
+	})
+
+}
+
 func (h *Handler) initPubInvoiceRoutes(g *gin.RouterGroup) {
 	g.POST("/invoice/create", h.invoiceCreate)
-	g.POST("/invoice/info", h.info)
+	g.POST("/invoice/info", h.invoiceInfo)
+	g.POST("/invoice/cancel", h.invoiceCancel)
+
 	g.GET("/invoice/qr-code/:invoice_id", h.qrCode)
 }

api/internal/delivery/rest/v1/response.go

@@ -77,6 +77,11 @@ type responseMerchantCreated struct {
 	MerchantId string `json:"merchant_id"`
 }
 
+type responseInvoiceCancelled struct {
+	Error bool `json:"error"`
+	// Message string `json:"message"`
+}
+
 func responseErr(c *gin.Context, statusCode int, msg, errorID string) {
 	// var errorId string
 

api/internal/domain/invoices.go

@@ -28,9 +28,10 @@ const (
 	STATUS_END
 	STATUS_PAID_LESS
 	STATUS_IN_PROCESSING
+	STATUS_CANCELLED
 )
 
-var Statuses = [...]string{"not_paid", "paid", "paid_over", "end", "paid_less", "processing"}
+var Statuses = [...]string{"not_paid", "paid", "paid_over", "end", "paid_less", "processing", "cancelled"}
 
 // methods
 
@@ -48,6 +49,9 @@ func (s Status) ToString() string {
 	return Statuses[s]
 }
 
+func (s Status) IsCancelled() bool {
+	return s == STATUS_CANCELLED
+}
 func (s Status) IsPaid() bool {
 	return s == STATUS_PAID || s == STATUS_PAID_OVER
 }

api/internal/domain/responses.go

@@ -46,18 +46,22 @@ const (
 	ErrMsgInitBalancesError     = "can't init balances"
 )
 
+type ResponseError error
+
 var (
-	ErrInvalidInvoiceId    = fmt.Errorf("invalid invoice id")
-	Err                    = fmt.Errorf("invalid invoice id")
-	ErrInternalServerError = fmt.Errorf(ErrMsgInternalServerError)
-	ErrInvoiceIdNotFound   = fmt.Errorf("invoice id not found")
+	ErrInvalidInvoiceId    ResponseError = fmt.Errorf("invalid invoice id")
+	Err                    ResponseError = fmt.Errorf("invalid invoice id")
+	ErrInternalServerError ResponseError = fmt.Errorf(ErrMsgInternalServerError)
+	ErrInvoiceIdNotFound   ResponseError = fmt.Errorf("invoice id not found")
+
+	ErrInvoiceAlreadyCancelled ResponseError = fmt.Errorf("invoice already cancelled")
 )
 
 const (
 	ErrParamEmptyInvoiceId = "invoice id is empty"
 )
 
-func GetStatusByErr(err error) (status int) {
+func GetStatusByErr(err ResponseError) (status int) {
 	if err == nil {
 		return 200
 	}
@@ -69,6 +73,8 @@ func GetStatusByErr(err error) (status int) {
 		status = http.StatusBadRequest
 	case errors.Is(err, ErrInvoiceIdNotFound):
 		status = http.StatusBadRequest
+	case errors.Is(err, ErrInvoiceAlreadyCancelled):
+		status = http.StatusBadRequest
 	default:
 		status = http.StatusInternalServerError
 	}

api/internal/service/invoices.go

@@ -28,6 +28,7 @@ type InvoicesService struct {
 	repo     repository.Invoices
 	wallets  repository.Wallets
 	balances repository.Balances
+	events   repository.Events
 	locker   Locker
 	n        *nats.NatsInfra
 	db       *gorm.DB
@@ -36,8 +37,8 @@ type InvoicesService struct {
 	config   *config.Config
 }
 
-func NewInvoicesService(db *gorm.DB, repo repository.Invoices, wallets repository.Wallets, balances repository.Balances, locker Locker, n *nats.NatsInfra, l logger.Logger, cache *cache.Cache, config *config.Config) *InvoicesService {
-	return &InvoicesService{repo: repo, wallets: wallets, balances: balances, n: n, db: db, l: l, cache: cache, locker: locker, config: config}
+func NewInvoicesService(db *gorm.DB, repo repository.Invoices, wallets repository.Wallets, balances repository.Balances, events repository.Events, locker Locker, n *nats.NatsInfra, l logger.Logger, cache *cache.Cache, config *config.Config) *InvoicesService {
+	return &InvoicesService{repo: repo, wallets: wallets, balances: balances, n: n, db: db, l: l, cache: cache, locker: locker, config: config, events: events}
 }
 
 func (s *InvoicesService) Create(tx *gorm.DB, invoice *domain.Invoices) error {
@@ -157,6 +158,11 @@ func (s *InvoicesService) RunCheck(ctx context.Context, cancel context.CancelFun
 				continue
 			}
 
+			if invoice.Status.IsCancelled() {
+				fmt.Println("CANCELLED")
+				return
+			}
+
 			if invoice.Status.IsPaid() || invoice.IsInProcessing() {
 				fmt.Println("!= NOT PAID: ", invoice.Status)
 				return
@@ -340,6 +346,36 @@ func (s *InvoicesService) RunCheck(ctx context.Context, cancel context.CancelFun
 
 }
 
+func (s *InvoicesService) Cancel(invoiceId string) domain.ResponseError {
+	invoice, err := s.repo.FindByID(s.db, invoiceId)
+	if err != nil {
+		if postgres.IsNotFound(err) {
+			return domain.ErrInvoiceIdNotFound
+		}
+		return err
+	}
+
+	if invoice.Status.IsCancelled() {
+		return domain.ErrInvoiceAlreadyCancelled
+	}
+
+	return s.db.Transaction(func(tx *gorm.DB) error {
+		invoice.Status = domain.STATUS_CANCELLED
+
+		// update invoice table
+		err := s.repo.Update(tx, invoice)
+		if err != nil {
+			s.l.TemplInvoiceErr("update invoice error: "+err.Error(), "", invoiceId, invoice.Amount, invoice.Cryptocurrency, logger.NA, invoice.MerchantID, logger.NA)
+			return err
+		}
+
+		//  update cache
+		s.cache.Set(invoice.InvoiceID, invoice, time.Minute*5)
+		return nil
+	})
+
+}
+
 func (s *InvoicesService) CalculateFinAmount(amount, rate decimal.Decimal, ceil ...int32) decimal.Decimal {
 	var _ceil int32
 

api/internal/service/service.go

@@ -34,6 +34,7 @@ type Invoices interface {
 	// Tries to find from cache, if not found, searches the database
 	FindGlobal(tx *gorm.DB, invoiceId string) (*domain.Invoices, error)
 
+	Cancel(invoiceId string) domain.ResponseError
 	// for autostart only
 	RunFindEnd()
 	RunAutostartCheck()
@@ -119,9 +120,10 @@ func HewServices(ns *natsdomain.Ns, db *gorm.DB, l logger.Logger, config *config
 
 	webhookSender := NewWebhookSenderService(nil, l)
 
-	invoiceService := NewInvoicesService(db, repository.InitInvoicesRepo(), walletsRepo, balancesRepo, lockerService, n, l, cache.InitStorage(), config)
-
 	eventsRepo := repository.InitEventsRepo()
+
+	invoiceService := NewInvoicesService(db, repository.InitInvoicesRepo(), walletsRepo, balancesRepo, eventsRepo, lockerService, n, l, cache.InitStorage(), config)
+
 	GetWithdrawalService := NewGetWithdrawalService(db, n, l, eventsRepo, walletsRepo, balancesRepo, invoiceService, webhookSender, config)
 
 	withdrawalsRepo := repository.InitWithdrawalsRepo()

go.mod

@@ -15,6 +15,7 @@ require (
 	github.com/joho/godotenv v1.5.1
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/nats-io/nats.go v1.36.0
+	github.com/rs/cors v1.7.0
 	github.com/shopspring/decimal v1.4.0
 	github.com/xssnick/tonutils-go v1.9.8
 	github.com/yeqown/go-qrcode/v2 v2.2.4