merge dev to prod

api/v1/account/account.go

@@ -10,9 +10,10 @@ func ApplyRoutes(r *gin.RouterGroup) {
 	g := r.Group("/account")
 	{
 		g.POST("generate-auth-id", GenerateAuthId)
+		g.POST("auth-google", authGoogle)
+		g.POST("auth-google/app", authGoogleApp)
 		g.Use(paseto.PASETO(true))
 		g.POST("paseto-from-magic-link", PasetoFromMagicLink)
-		g.POST("auth-google", authGoogle)
 		g.Use(paseto.PASETO(false))
 		g.DELETE("remove-mail", removeMail)
 	}

api/v1/account/auth-google.go

@@ -105,3 +105,97 @@
 	}
 	httpo.NewSuccessResponseP(200, "Token generated successfully", payload).SendD(c)
 }
+func authGoogleApp(c *gin.Context) {
+	userId := c.GetString(paseto.CTX_USER_ID)
+	db := dbconfig.GetDb()
+	var request AppAccountRequest
+	err := c.BindJSON(&request)
+	if err != nil {
+		httpo.NewErrorResponse(http.StatusBadRequest, fmt.Sprintf("payload is invalid %s", err)).SendD(c)
+		return
+	}
+
+	// ctx := context.Background()
+	// tokenValidationRes, err := verifyIDToken(ctx, request.IdToken)
+	// if err != nil {
+	// 	httpo.NewErrorResponse(http.StatusBadRequest, "failed to validate ").SendD(c)
+	// 	return
+	// }
+
+	// response := map[string]interface{}{
+	// 	"email": payload.Claims["email"],
+	// 	"name":  payload.Claims["name"],
+	// }
+	// if !tokenValidationRes.Claims["email_verified"].(bool) {
+	// 	httpo.NewErrorResponse(http.StatusForbidden, "email not verified").SendD(c)
+	// 	return
+	// }
+
+	// email := tokenValidationRes.Claims["email"].(string)
+	var user models.User
+	err = db.Model(&models.User{}).Where("email_id = ?", request.Email).First(&user).Error
+	if err == nil && userId != "" {
+		httpo.NewErrorResponse(http.StatusBadRequest, "another user with this email already exist").SendD(c)
+		return
+	}
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			if userId != "" {
+				err = db.Model(&models.User{}).Where("user_id = ?", userId).Update("email_id", request.Email).Error
+				if err != nil {
+					logwrapper.Errorf("failed to update user email: %s", err)
+					httpo.NewErrorResponse(http.StatusInternalServerError, "internal server error").SendD(c)
+					return
+				}
+				httpo.NewSuccessResponse(200, "email linked successfully").SendD(c)
+				return
+			}
+
+			// User does not exist, so create a new user
+			user = models.User{
+				EmailId: &request.Email,
+				UserId:  uuid.NewString(),
+			}
+			err = db.Model(&models.User{}).Create(&user).Error
+			if err != nil {
+				logwrapper.Errorf("failed to create user: %s", err)
+				httpo.NewErrorResponse(http.StatusInternalServerError, "internal server error").SendD(c)
+				return
+			}
+		} else {
+			// Other error occurred
+			logwrapper.Errorf("failed to retrieve user: %s", err)
+			httpo.NewErrorResponse(http.StatusInternalServerError, "internal server error").SendD(c)
+			return
+		}
+	}
+
+	customClaims := claims.NewWithEmail(user.UserId, user.EmailId)
+	pvKey, err := hex.DecodeString(envconfig.EnvVars.PASETO_PRIVATE_KEY[2:])
+	if err != nil {
+		httpo.NewErrorResponse(http.StatusInternalServerError, "Unexpected error occured").SendD(c)
+		logwrapper.Errorf("failed to generate token, error %v", err.Error())
+		return
+	}
+
+	pasetoToken, err := auth.GenerateToken(customClaims, pvKey)
+	if err != nil {
+		logwrapper.Errorf("failed to create paseto token: %s", err)
+		httpo.NewErrorResponse(http.StatusInternalServerError, "internal server error").SendD(c)
+		return
+	}
+
+	payload := CreateAccountResponse{
+		Token:  pasetoToken,
+		UserId: user.UserId,
+	}
+	httpo.NewSuccessResponseP(200, "Token generated successfully", payload).SendD(c)
+}
+
+func verifyIDToken(ctx context.Context, idToken string) (*idtoken.Payload, error) {
+	payload, err := idtoken.Validate(ctx, idToken, "699954671747-i1mqa1d7k3nh8bo9arv58pq8j4osl642.apps.googleusercontent.com")
+	if err != nil {
+		return nil, err
+	}
+	return payload, nil
+}

api/v1/account/subscription/create.go

@@ -3,6 +3,7 @@ package subscription
 import (
 	"math"
 	"net/http"
+	"time"
 
 	"github.com/NetSepio/gateway/api/middleware/auth/paseto"
 	"github.com/NetSepio/gateway/config/dbconfig"
@@ -14,6 +15,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/stripe/stripe-go/v76"
 	"github.com/stripe/stripe-go/v76/paymentintent"
+	"gorm.io/gorm"
 )
 
 func Buy111NFT(c *gin.Context) {
@@ -48,13 +50,6 @@ func Buy111NFT(c *gin.Context) {
 		return
 	}
 
-	// type UsersStripePi struct {
-	// 	Id           string    `gorm:"primary_key" json:"id,omitempty"`
-	// 	UserId       string `json:"userId,omitempty"`
-	// 	StripePiId   string `json:"stripePiId,omitempty"`
-	// 	StripePiType string `json:"stripePiType,omitempty"`
-	// }
-
 	// insert in above table
 	err = db.Create(&models.UserStripePi{
 		Id:           uuid.NewString(),
@@ -70,3 +65,92 @@ func Buy111NFT(c *gin.Context) {
 
 	httpo.NewSuccessResponseP(http.StatusOK, "payment intent created", BuyErebrusNFTResponse{ClientSecret: pi.ClientSecret}).SendD(c)
 }
+
+func TrialSubscription(c *gin.Context) {
+	userId := c.GetString(paseto.CTX_USER_ID)
+
+	// Check if there is already an active trial subscription for the user
+	var existingSubscription models.Subscription
+	db := dbconfig.GetDb()
+	if err := db.Where("user_id = ? AND type = ? AND end_time > ?", userId, "trial", time.Now()).First(&existingSubscription).Error; err == nil {
+		// There is already an active trial subscription for the user
+		c.JSON(http.StatusBadRequest, gin.H{"error": "You already have an active trial subscription"})
+		return
+	}
+
+	// Create a new trial subscription
+	subscription := models.Subscription{
+		UserId:    userId,
+		StartTime: time.Now(),
+		EndTime:   time.Now().AddDate(0, 0, 7),
+		Type:      "TrialSubscription",
+	}
+
+	// Save the new trial subscription to the database
+	if err := db.Model(models.Subscription{}).Create(&subscription).Error; err != nil {
+		logwrapper.Errorf("Error creating subscription: %v", err)
+		c.Status(http.StatusInternalServerError)
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"status": "subscription created"})
+}
+
+func CheckSubscription(c *gin.Context) {
+	userId := c.GetString(paseto.CTX_USER_ID)
+
+	db := dbconfig.GetDb()
+	var subscription *models.Subscription
+	err := db.Where("user_id = ?", userId).Order("end_time DESC").First(&subscription).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			res := SubscriptionResponse{
+				Status: "notFound",
+			}
+			c.JSON(http.StatusNotFound, res)
+		}
+		logwrapper.Errorf("Error fetching subscriptions: %v", err)
+		c.Status(http.StatusInternalServerError)
+		return
+	}
+	var status = "expired"
+	if time.Now().Before(subscription.EndTime) {
+		status = "active"
+	}
+	res := SubscriptionResponse{
+		Subscription: subscription,
+		Status:       status,
+	}
+	c.JSON(http.StatusOK, res)
+}
+
+func CreatePaymentIntent(c *gin.Context) {
+	userId := c.GetString(paseto.CTX_USER_ID)
+	db := dbconfig.GetDb()
+	params := &stripe.PaymentIntentParams{
+		Amount:      stripe.Int64(1000),
+		Currency:    stripe.String(string(stripe.CurrencyUSD)),
+		Description: stripe.String("Payment to purchase 3 month subscription"),
+	}
+	pi, err := paymentintent.New(params)
+	if err != nil {
+		logwrapper.Errorf("failed to create new payment intent: %s", err)
+		httpo.NewErrorResponse(http.StatusInternalServerError, err.Error()).SendD(c)
+		return
+	}
+
+	// insert in above table
+	err = db.Create(&models.UserStripePi{
+		Id:           uuid.NewString(),
+		UserId:       userId,
+		StripePiId:   pi.ID,
+		StripePiType: models.ThreeMonthSubscription,
+	}).Error
+	if err != nil {
+		logwrapper.Errorf("failed to insert into users_stripe_pi: %v", err)
+		httpo.NewErrorResponse(http.StatusInternalServerError, "internal server error").SendD(c)
+		return
+	}
+
+	httpo.NewSuccessResponseP(200, "Created new charge", gin.H{"clientSecret": pi.ClientSecret}).SendD(c)
+}

api/v1/account/subscription/subscription.go

@@ -11,6 +11,9 @@ func ApplyRoutes(r *gin.RouterGroup) {
 	{
 		g.POST("payment-webhook", StripeWebhookHandler)
 		g.Use(paseto.PASETO(false))
+		g.POST("/trial", TrialSubscription)
+		g.POST("/create-payment", CreatePaymentIntent)
+		g.GET("", CheckSubscription)
 		g.POST("erebrus", Buy111NFT)
 	}
 }

api/v1/account/subscription/type.go

@@ -1,5 +1,12 @@
 package subscription
 
+import "github.com/NetSepio/gateway/models"
+
 type BuyErebrusNFTResponse struct {
 	ClientSecret string `json:"clientSecret"`
 }
+
+type SubscriptionResponse struct {
+	Subscription *models.Subscription `json:"subscription,omitempty"`
+	Status       string               `json:"status"`
+}

api/v1/account/subscription/webhook.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"time"
 
 	"github.com/NetSepio/gateway/config/dbconfig"
 	"github.com/NetSepio/gateway/config/envconfig"
@@ -37,6 +38,7 @@ func StripeWebhookHandler(c *gin.Context) {
 		c.Status(http.StatusBadRequest)
 		return
 	}
+
 	switch event.Type {
 	case stripe.EventTypePaymentIntentSucceeded:
 		var paymentIntent stripe.PaymentIntent
@@ -47,11 +49,11 @@ func StripeWebhookHandler(c *gin.Context) {
 			return
 		}
 
-		// get user with stripe_pi_id
+		// Get user with stripe_pi_id
 		var userStripePi models.UserStripePi
 		if err := db.Where("stripe_pi_id = ?", paymentIntent.ID).First(&userStripePi).Error; err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
-				//warn and return success
+				// Warn and return success
 				logwrapper.Warnf("No user found with stripe_pi_id: %v", err)
 				c.JSON(http.StatusOK, gin.H{"status": "received"})
 				return
@@ -61,20 +63,36 @@ func StripeWebhookHandler(c *gin.Context) {
 			return
 		}
 
-		// get user with user_id
+		// Get user with user_id
 		var user models.User
 		if err := db.Where("user_id = ?", userStripePi.UserId).First(&user).Error; err != nil {
 			logwrapper.Errorf("Error getting user with user_id: %v", err)
 			c.Status(http.StatusInternalServerError)
 			return
 		}
 
-		if _, err = aptos.DelegateMintNft(*user.WalletAddress); err != nil {
-			logwrapper.Errorf("Error minting nft: %v", err)
-			c.Status(http.StatusInternalServerError)
-			return
+		if userStripePi.StripePiType == models.ThreeMonthSubscription {
+			// Handle ThreeMonthSubscription payment intent
+			subscription := models.Subscription{
+				UserId:    user.UserId,
+				StartTime: time.Now(),
+				EndTime:   time.Now().AddDate(0, 3, 0),
+				Type:      "ThreeMonthSubscription",
+			}
+			if err = db.Model(models.Subscription{}).Create(&subscription).Error; err != nil {
+				logwrapper.Errorf("Error creating subscription: %v", err)
+				c.Status(http.StatusInternalServerError)
+				return
+			}
+		} else if userStripePi.StripePiType == models.Erebrus111NFT {
+			// Handle Erebrus111NFT payment intent
+			if _, err = aptos.DelegateMintNft(*user.WalletAddress); err != nil {
+				logwrapper.Errorf("Error minting nft: %v", err)
+				c.Status(http.StatusInternalServerError)
+				return
+			}
+			fmt.Println("minting nft -- 111NFT")
 		}
-		fmt.Println("minting nft -- 111NFT")
 
 	case stripe.EventTypePaymentIntentCanceled:
 		err := HandleCanceledOrFailedPaymentIntent(event.Data.Raw)
@@ -88,7 +106,6 @@ func StripeWebhookHandler(c *gin.Context) {
 
 	c.JSON(http.StatusOK, gin.H{"status": "received"})
 }
-
 func HandleCanceledOrFailedPaymentIntent(eventDataRaw json.RawMessage) error {
 	var paymentIntent stripe.PaymentIntent
 	err := json.Unmarshal(eventDataRaw, &paymentIntent)

api/v1/account/types.go

@@ -3,6 +3,9 @@ package account
 type CreateAccountRequest struct {
 	IdToken string `json:"idToken" binding:"required"`
 }
+type AppAccountRequest struct {
+	Email string `json:"email" binding:"required"`
+}
 
 type CreateAccountResponse struct {
 	Token  string `json:"token"`