Cart ops jwt

apperrors/apperrors.go

@@ -0,0 +1,68 @@
+package apperrors
+
+import (
+	"encoding/json"
+	"errors"
+	l "github.com/sirupsen/logrus"
+	"net/http"
+)
+
+// ErrorStruct - struct used to convert error messages into required JSON format
+type ErrorStruct struct {
+	Message string `json:"message,omitempty"` //Error Message
+	Status  int    `json:"status,omitempty"`  //HTTP Response status code
+}
+
+// Error - prints out an error
+func Error(appError error, msg string, triggeringError error) {
+	l.WithFields(l.Fields{"appError": appError, "message": msg}).Error(triggeringError)
+}
+
+// Warn - for warnings
+func Warn(appError error, msg string, triggeringError error) {
+	l.WithFields(l.Fields{"appError": appError, "message": msg}).Warn(triggeringError)
+}
+
+// JSONError - This function writes out an error response with the status
+// header passed in
+func JSONError(rw http.ResponseWriter, status int, err error) {
+
+	errObj := ErrorStruct{
+		Message: err.Error(),
+		Status:  status,
+	}
+
+	errJSON, err := json.Marshal(&errObj)
+	if err != nil {
+		Warn(err, "Error in AppErrors marshalling JSON", err)
+	}
+	rw.WriteHeader(status)
+	rw.Header().Set("Content-Type", "application/json")
+	rw.Write(errJSON)
+	return
+}
+
+// ErrRecordNotFound - for when a database record isn't found
+var ErrRecordNotFound = errors.New("Database record not found")
+
+// ErrInvalidToken - used when a JSON Web Token ("JWT") cannot be validated
+// by the JWT library
+var ErrInvalidToken = errors.New("Invalid Token")
+
+// ErrSignedString - failed to sign the token string
+var ErrSignedString = errors.New("Failed to sign token string")
+
+// ErrMissingAuthHeader - When the HTTP request doesn't contain an 'Authorization' header
+var ErrMissingAuthHeader = errors.New("Missing Auth header")
+
+// ErrJSONParseFail - If json.Unmarshal or json.Marshal returns an error
+var ErrJSONParseFail = errors.New("Failed to parse JSON response (likely not valid JSON)")
+
+// ErrNoSigningKey - there isn't a signing key defined in the app configuration
+var ErrNoSigningKey = errors.New("no JWT signing key specified; cannot authenticate users. Define JWT_SECRET in application.yml and restart")
+
+// ErrFailedToCreate - Record Creation Failed
+var ErrFailedToCreate = errors.New("Failed to create database record")
+
+// ErrUnknown - Generic Error For Unknown Errors
+var ErrUnknown = errors.New("unknown/unexpected error has occurred")

application.yml.default

@@ -1,4 +1,4 @@
-APP_NAME: "samplemgr"
+APP_NAME: "app"
 APP_PORT: "33001"
 
 # MongoDB URI

config/config.go

@@ -1,20 +1,22 @@
 package config
 
 import (
-	"errors"
 	"fmt"
 	"strconv"
 
 	"github.com/spf13/viper"
 )
 
 var (
-	appName string
-	appPort int
+	appName                string
+	appPort                int
+	jwtKey                 string
+	jwtExpiryDurationHours int
 )
 
+// Load - loads all the environment variables and/or params in application.yml
 func Load() {
-	viper.SetDefault("APP_NAME", "app")
+	viper.SetDefault("APP_NAME", "e-commerce")
 	viper.SetDefault("APP_PORT", "8002")
 
 	viper.SetConfigName("application")
@@ -24,22 +26,39 @@ func Load() {
 	viper.AddConfigPath("./../..")
 	viper.ReadInConfig()
 	viper.AutomaticEnv()
+
+	// Check for the presence of JWT_KEY and JWT_EXPIRY_DURATION_HOURS
+	JWTKey()
+	JWTExpiryDurationHours()
 }
 
+// AppName - returns the app name
 func AppName() string {
 	if appName == "" {
 		appName = ReadEnvString("APP_NAME")
 	}
 	return appName
 }
 
+// AppPort - returns application http port
 func AppPort() int {
 	if appPort == 0 {
 		appPort = ReadEnvInt("APP_PORT")
 	}
 	return appPort
 }
 
+// JWTKey - returns the JSON Web Token key
+func JWTKey() []byte {
+	return []byte(ReadEnvString("JWT_SECRET"))
+}
+
+// JWTExpiryDurationHours - returns duration for jwt expiry in int
+func JWTExpiryDurationHours() int {
+	return int(ReadEnvInt("JWT_EXPIRY_DURATION_HOURS"))
+}
+
+// ReadEnvInt - reads an environment variable as an integer
 func ReadEnvInt(key string) int {
 	checkIfSet(key)
 	v, err := strconv.Atoi(viper.GetString(key))
@@ -49,19 +68,22 @@ func ReadEnvInt(key string) int {
 	return v
 }
 
+// ReadEnvString - reads an environment variable as a string
 func ReadEnvString(key string) string {
 	checkIfSet(key)
 	return viper.GetString(key)
 }
 
+// ReadEnvBool - reads environment variable as a boolean
 func ReadEnvBool(key string) bool {
 	checkIfSet(key)
 	return viper.GetBool(key)
 }
 
+//CheckIfSet checks if all the necessary keys are set
 func checkIfSet(key string) {
 	if !viper.IsSet(key) {
-		err := errors.New(fmt.Sprintf("Key %s is not set", key))
+		err := fmt.Errorf("Key %s is not set", key)
 		panic(err)
 	}
 }

db/cart.go

@@ -0,0 +1,56 @@
+package db
+
+import(
+	"context"
+	logger "github.com/sirupsen/logrus"
+)
+
+func (s *pgStore) AddToCart(ctx context.Context, cartId, productId int) (rowsAffected int64, err error) {
+	insert := `INSERT INTO cart (id, product_id, quantity) VALUES ($1, $2, 1)`
+	result, err := s.db.Exec(insert, cartId, productId)
+
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("Error adding to cart")
+		return
+	}
+
+	rowsAffected, err = result.RowsAffected()
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("Error while fetching affected rows")
+	}
+
+	return
+}
+
+func (s *pgStore) RemoveFromCart(ctx context.Context, cartId, productId int) (rowsAffected int64, err error) {
+	delete := `DELETE FROM cart WHERE id = $1 AND product_id = $2`
+	result, err := s.db.Exec(delete, cartId, productId)
+
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("Error while removing from cart")
+		return
+	}
+
+	rowsAffected, err = result.RowsAffected()
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("Error while fetching affected rows")
+	}
+
+	return
+}
+
+func (s *pgStore) UpdateIntoCart(ctx context.Context, quantity, cartId, productId int) (rowsAffected int64, err error) {
+	update := `UPDATE cart SET quantity = $1 WHERE id = $2 AND product_id = $3`
+	result, err := s.db.Exec(update, quantity, cartId, productId)
+
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("Error while updating into cart")
+		return
+	}
+
+	rowsAffected, err = result.RowsAffected()
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("Error while fetching affected rows")
+	}
+	return
+}

db/db.go

@@ -4,8 +4,16 @@ import (
 	"context"
 )
 
+// Storer - an interface we use to expose methods that do stuff to the underlying database
 type Storer interface {
 	ListUsers(context.Context) ([]User, error)
+	AuthenticateUser(context.Context, User) (User, error)
+	GetUser(context.Context, int) (User, error)
+	CreateBlacklistedToken(context.Context, BlacklistedToken) error
+	CheckBlacklistedToken(context.Context, string) (bool, int)
+	AddToCart(context.Context, int, int) (int64, error)
+	RemoveFromCart(context.Context, int, int) (int64, error)
+	UpdateIntoCart(context.Context, int, int, int) (int64, error)
 	//Create(context.Context, User) error
 	//GetUser(context.Context) (User, error)
 	//Delete(context.Context, string) error

db/pg.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/jmoiron/sqlx"
+	//lib/pq internally configures with database/sql library"
 	_ "github.com/lib/pq"
 	"github.com/mattes/migrate"
 	"github.com/mattes/migrate/database/postgres"

db/user.go

@@ -2,21 +2,67 @@ package db
 
 import (
 	"context"
-
+	"database/sql"
 	logger "github.com/sirupsen/logrus"
+	"golang.org/x/crypto/bcrypt"
+	ae "joshsoftware/go-e-commerce/apperrors"
+	"time"
 )
 
+//User Struct for declaring attributes of User
 type User struct {
-	Name string `db:"name" json:"full_name"`
-	Age  int    `db:"age" json:"age"`
+	ID        int       `db:"id" json:"id"`
+	FirstName string    `db:"first_name" json:"first_name"`
+	LastName  string    `db:"last_name" json:"last_name"`
+	Email     string    `db:"email" json:"email"`
+	Mobile    string    `db:"mobile" json:"mobile"`
+	Address   string    `db:"address" json:"address"`
+	Password  string    `db:"password" json:"password"`
+	Country   string    `db:"country" json:"country"`
+	State     string    `db:"state" json:"state"`
+	City      string    `db:"city" json:"city"`
+	CreatedAt time.Time `db:"created_at" json:"created_at"`
 }
 
+//ListUsers function to fetch all Users From Database
 func (s *pgStore) ListUsers(ctx context.Context) (users []User, err error) {
-	err = s.db.Select(&users, "SELECT * FROM users ORDER BY name ASC")
+	err = s.db.Select(&users, "SELECT * FROM users ORDER BY first_name ASC")
 	if err != nil {
 		logger.WithField("err", err.Error()).Error("Error listing users")
 		return
 	}
 
 	return
 }
+
+//GetUser function is used to Get a Particular User
+func (s *pgStore) GetUser(ctx context.Context, id int) (user User, err error) {
+
+	err = s.db.Get(&user, "SELECT * FROM users WHERE id=$1", id)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			err = ae.ErrRecordNotFound
+		}
+		logger.WithField("err", err.Error()).Error("Query Failed")
+		return
+	}
+
+	return
+}
+
+//AuthenticateUser Function checks if User has Registered before Login
+// and Has Entered Correct Credentials
+func (s *pgStore) AuthenticateUser(ctx context.Context, u User) (user User, err error) {
+
+	err = s.db.Get(&user, "SELECT * FROM users where email = $1", u.Email)
+	if err != nil {
+		logger.WithField("err", err.Error()).Error("No such User Available")
+		return
+	}
+
+	if err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(u.Password)); err != nil {
+		// If the two passwords don't match, return a 401 status
+		logger.WithField("Error", err.Error())
+	}
+	return
+}

db/user_blacklisted_tokens.go

@@ -0,0 +1,48 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	logger "github.com/sirupsen/logrus"
+)
+
+//BlacklistedToken - struct representing a token to be blacklisted (logout)
+type BlacklistedToken struct {
+	ID             int       `db:"id" json:"id"`
+	UserID         float64   `db:"user_id" json:"user_id"`
+	Token          string    `db:"token" json:"token"`
+	ExpirationDate time.Time `db:"expiration_date" json:"expiration_date"`
+}
+
+const (
+	insertBlacklistedToken = `INSERT INTO user_blacklisted_tokens
+(user_id, token, expiration_date)
+VALUES ($1, $2, $3)`
+)
+
+//CreateBlacklistedToken function to insert the blacklisted token in database
+func (s *pgStore) CreateBlacklistedToken(ctx context.Context, token BlacklistedToken) (err error) {
+	_, err = s.db.Exec(insertBlacklistedToken, token.UserID, token.Token, token.ExpirationDate)
+
+	if err != nil {
+		errMsg := fmt.Sprintf("Error inserting the blacklisted token for user with id %v", token.UserID)
+		logger.WithField("err", err.Error()).Error(errMsg)
+		return
+	}
+	return
+}
+
+//CheckBlacklistedToken function to check if token is blacklisted earlier
+func (s *pgStore) CheckBlacklistedToken(ctx context.Context, token string) (bool, int) {
+
+	var userID int
+	query1 := fmt.Sprintf("SELECT user_id FROM user_blacklisted_tokens WHERE token='%s'", token)
+	err := s.db.QueryRow(query1).Scan(&userID)
+
+	if err != nil {
+		return false, -1
+	}
+	return true, userID
+}

go.mod

@@ -3,13 +3,16 @@ module joshsoftware/go-e-commerce
 go 1.14
 
 require (
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/gorilla/mux v1.8.0
 	github.com/jmoiron/sqlx v1.2.0
 	github.com/lib/pq v1.8.0
 	github.com/mattes/migrate v3.0.1+incompatible
+	github.com/rs/cors v1.7.0
 	github.com/sirupsen/logrus v1.6.0
 	github.com/spf13/viper v1.7.1
 	github.com/stretchr/testify v1.6.1
 	github.com/urfave/cli v1.22.4
 	github.com/urfave/negroni v1.0.0
+	golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5
 )