Add functionality to stop, resume and pause a susbcription

Signed-off-by: Imre Nagi <[email protected]>
imrenagi · Jun 7, 2020 · a9081ea · a9081ea
1 parent 57d38f2
commit a9081ea
Show file tree

Hide file tree

Showing 12 changed files with 627 additions and 87 deletions.
diff --git a/example/server/server.go b/example/server/server.go
@@ -90,4 +90,7 @@ func (s srv) routes() {
 	s.Router.HandleFunc("/payment/xendit/dana/callback", s.paymentSrv.XenditDanaCallbackHandler()).Methods("POST")
 	s.Router.HandleFunc("/payment/xendit/linkaja/callback", s.paymentSrv.XenditLinkAjaCallbackHandler()).Methods("POST")
 	s.Router.HandleFunc("/payment/subscriptions", s.paymentSrv.CreateSubscriptionHandler()).Methods("POST")
+	s.Router.HandleFunc("/payment/subscriptions/{subscription_number}/pause", s.paymentSrv.PauseSubscriptionHandler()).Methods("POST", "PUT")
+	s.Router.HandleFunc("/payment/subscriptions/{subscription_number}/stop", s.paymentSrv.StopSubscriptionHandler()).Methods("POST", "PUT")
+	s.Router.HandleFunc("/payment/subscriptions/{subscription_number}/resume", s.paymentSrv.ResumeSubscriptionHandler()).Methods("POST", "PUT")
 }
diff --git a/example/server/subscription.yaml b/example/server/subscription.yaml
diff --git a/gateway/xendit/gateway.go b/gateway/xendit/gateway.go
@@ -52,4 +52,7 @@ type xInvoice interface {
 
 type xRecurring interface {
 	CreateWithContext(ctx context.Context, data *recurring.CreateParams) (*xgo.RecurringPayment, *xendit.Error)
+	PauseWithContext(ctx context.Context, data *recurring.PauseParams) (*xgo.RecurringPayment, *xendit.Error)
+	ResumeWithContext(ctx context.Context, data *recurring.ResumeParams) (*xgo.RecurringPayment, *xendit.Error)
+	StopWithContext(ctx context.Context, data *recurring.StopParams) (*xgo.RecurringPayment, *xendit.Error)
 }
diff --git a/manage/manage.go b/manage/manage.go
@@ -50,6 +50,7 @@ type FailInvoiceRequest struct {
 	Reason        string `json:"reason"`
 }
 
+// CreateSubscriptionRequest contains data for creating subscription
 type CreateSubscriptionRequest struct {
 	Name              string  `json:"name"`
 	Description       string  `json:"description"`
@@ -96,11 +97,12 @@ func (csr CreateSubscriptionRequest) ToSubscription() *subscription.Subscription
 	s.TotalReccurence = csr.TotalReccurence
 	s.CardToken = csr.CardToken
 	s.ChargeImmediately = csr.ChargeImmediately
-	s.Schedule = subscription.Schedule{
-		Interval:     csr.Schedule.Interval,
-		IntervalUnit: subscription.NewIntervalUnit(csr.Schedule.IntervalUnit),
-		StartAt:      csr.StartAt(),
-	}
+	schedule := subscription.NewSchedule(
+		csr.Schedule.Interval,
+		subscription.NewIntervalUnit(csr.Schedule.IntervalUnit),
+		csr.StartAt(),
+	)
+	s.Schedule = *schedule
 	return s
 }
 
@@ -116,9 +118,14 @@ func (csr CreateSubscriptionRequest) StartAt() *time.Time {
 
 // Interface payment management interface
 type Interface interface {
+	invoiceI
+	subscriptionI
+
 	// return the payment methods available in payment service
 	GetPaymentMethods(ctx context.Context, opts ...payment.Option) (*PaymentMethodList, error)
+}
 
+type invoiceI interface {
 	// return invoice given its invoice number
 	GetInvoice(ctx context.Context, number string) (*invoice.Invoice, error)
 
@@ -133,9 +140,20 @@ type Interface interface {
 
 	// FailInvoice make the invoice failed
 	FailInvoice(ctx context.Context, fir *FailInvoiceRequest) (*invoice.Invoice, error)
+}
 
+type subscriptionI interface {
 	// CreateSubscription creates new subscription
 	CreateSubscription(ctx context.Context, csr *CreateSubscriptionRequest) (*subscription.Subscription, error)
+
+	// PauseSubscription pause active subscription
+	PauseSubscription(ctx context.Context, subsNumber string) (*subscription.Subscription, error)
+
+	// ResumeSubscription resume paused subscription
+	ResumeSubscription(ctx context.Context, subsNumber string) (*subscription.Subscription, error)
+
+	// StopSubscription stop subscription
+	StopSubscription(ctx context.Context, subsNumber string) (*subscription.Subscription, error)
 }
 
 // XenditProcessor callback handler for xendit

diff --git a/manage/manager.go b/manage/manager.go
@@ -261,6 +261,64 @@ func (m *Manager) CreateSubscription(ctx context.Context, csr *CreateSubscriptio
 	return s, nil
 }
 
+// PauseSubscription pause active subscription
+func (m *Manager) PauseSubscription(ctx context.Context, subsNumber string) (*subscription.Subscription, error) {
+
+	sub, err := m.subscriptionRepository.FindByNumber(ctx, subsNumber)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := sub.Pause(ctx, m.subscriptionController(payment.GatewayXendit)); err != nil {
+		return nil, err
+	}
+
+	if err := m.subscriptionRepository.Save(ctx, sub); err != nil {
+		return nil, err
+	}
+
+	return sub, nil
+
+}
+
+// ResumeSubscription resume paused subscription
+func (m *Manager) ResumeSubscription(ctx context.Context, subsNumber string) (*subscription.Subscription, error) {
+
+	sub, err := m.subscriptionRepository.FindByNumber(ctx, subsNumber)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := sub.Resume(ctx, m.subscriptionController(payment.GatewayXendit)); err != nil {
+		return nil, err
+	}
+
+	if err := m.subscriptionRepository.Save(ctx, sub); err != nil {
+		return nil, err
+	}
+
+	return sub, nil
+}
+
+// StopSubscription stop subscription
+func (m *Manager) StopSubscription(ctx context.Context, subsNumber string) (*subscription.Subscription, error) {
+
+	sub, err := m.subscriptionRepository.FindByNumber(ctx, subsNumber)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := sub.Stop(ctx, m.subscriptionController(payment.GatewayXendit)); err != nil {
+		return nil, err
+	}
+
+	if err := m.subscriptionRepository.Save(ctx, sub); err != nil {
+		return nil, err
+	}
+
+	return sub, nil
+}
+
 func (m Manager) subscriptionController(gateway payment.Gateway) subscription.Controller {
 	return &xenditSubscriptionController{
 		XenditGateway: m.xenditGateway,

diff --git a/manage/subscription.go b/manage/subscription.go
@@ -13,6 +13,7 @@ import (
 	"github.com/imrenagi/go-payment/subscription"
 
 	goxendit "github.com/xendit/xendit-go"
+	xrecurring "github.com/xendit/xendit-go/recurringpayment"
 )
 
 type xenditSubscriptionController struct {
@@ -44,6 +45,39 @@ func (sc xenditSubscriptionController) Create(ctx context.Context, sub *subscrip
 	}, nil
 }
 
+func (sc xenditSubscriptionController) Resume(ctx context.Context, sub *subscription.Subscription) error {
+	_, err := sc.XenditGateway.Recurring.ResumeWithContext(ctx, &xrecurring.ResumeParams{
+		ID: sub.GatewayRecurringID,
+	})
+	var xError *goxendit.Error
+	if ok := errors.As(err, &xError); ok && xError != nil {
+		return xError
+	}
+	return nil
+}
+
+func (sc xenditSubscriptionController) Stop(ctx context.Context, sub *subscription.Subscription) error {
+	_, err := sc.XenditGateway.Recurring.StopWithContext(ctx, &xrecurring.StopParams{
+		ID: sub.GatewayRecurringID,
+	})
+	var xError *goxendit.Error
+	if ok := errors.As(err, &xError); ok && xError != nil {
+		return xError
+	}
+	return nil
+}
+
+func (sc xenditSubscriptionController) Pause(ctx context.Context, sub *subscription.Subscription) error {
+	_, err := sc.XenditGateway.Recurring.PauseWithContext(ctx, &xrecurring.PauseParams{
+		ID: sub.GatewayRecurringID,
+	})
+	var xError *goxendit.Error
+	if ok := errors.As(err, &xError); ok && xError != nil {
+		return xError
+	}
+	return nil
+}
+
 func (sc xenditSubscriptionController) Gateway() payment.Gateway {
 	return payment.GatewayXendit
 }
diff --git a/manage/xendit.go b/manage/xendit.go
@@ -227,7 +227,7 @@ func (m Manager) processXenditRecurringTransactionCallback(ctx context.Context,
 		}
 	}
 
-	if err := subs.Record(inv); err != nil {
+	if err := subs.Save(inv); err != nil {
 		return err
 	}
 

diff --git a/server/server.go b/server/server.go
@@ -110,6 +110,48 @@ func (s Server) CreateSubscriptionHandler() http.HandlerFunc {
 	}
 }
 
+// PauseSubscriptionHandler returns handler for pausing subscription
+func (s Server) PauseSubscriptionHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		subscriptionNumber := vars["subscription_number"]
+		subs, err := s.Manager.PauseSubscription(r.Context(), subscriptionNumber)
+		if err != nil {
+			WriteFailResponseFromError(w, err)
+			return
+		}
+		WriteSuccessResponse(w, http.StatusOK, subs, nil)
+	}
+}
+
+// StopSubscriptionHandler returns stop subscription handler
+func (s Server) StopSubscriptionHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		subscriptionNumber := vars["subscription_number"]
+		subs, err := s.Manager.StopSubscription(r.Context(), subscriptionNumber)
+		if err != nil {
+			WriteFailResponseFromError(w, err)
+			return
+		}
+		WriteSuccessResponse(w, http.StatusOK, subs, nil)
+	}
+}
+
+// ResumeSubscriptionHandler returns resume susbcription handler
+func (s Server) ResumeSubscriptionHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		subscriptionNumber := vars["subscription_number"]
+		subs, err := s.Manager.ResumeSubscription(r.Context(), subscriptionNumber)
+		if err != nil {
+			WriteFailResponseFromError(w, err)
+			return
+		}
+		WriteSuccessResponse(w, http.StatusOK, subs, nil)
+	}
+}
+
 // MidtransTransactionCallbackHandler handles incoming notification about payment status from midtrans.
 func (s *Server) MidtransTransactionCallbackHandler() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {

diff --git a/subscription/interface.go b/subscription/interface.go
@@ -1,3 +1,5 @@
+//go:generate mockery -dir . -name Controller -output ./mocks -filename controller.go
+
 package subscription
 
 import (
@@ -15,7 +17,22 @@ type creator interface {
 	Create(ctx context.Context, sub *Subscription) (*CreateResponse, error)
 }
 
+type pauser interface {
+	Pause(ctx context.Context, sub *Subscription) error
+}
+
+type stopper interface {
+	Stop(ctx context.Context, stop *Subscription) error
+}
+
+type resumer interface {
+	Resume(ctx context.Context, sub *Subscription) error
+}
+
 // Controller is payment gateway interface for subscription handling
 type Controller interface {
 	creator
+	pauser
+	stopper
+	resumer
 }
diff --git a/subscription/mocks/controller.go b/subscription/mocks/controller.go