Development commit

Author: victorsteven

.env

@@ -0,0 +1,44 @@
+# Postgres Live
+DB_HOST=postgres # used when running the app with docker
+# DB_HOST=127.0.0.1 # when running the app without docker 
+DB_DRIVER=postgres
+API_SECRET=98hbun98h # Used for creating a JWT. Can be anything 
+DB_USER=steven
+DB_PASSWORD=
+DB_NAME=fullstack_api
+DB_PORT=5432 #Default postgres port
+
+PGADMIN_DEFAULT_EMAIL=live@admin.com
+PGADMIN_DEFAULT_PASSWORD=password
+
+# Postgres Test
+TEST_DB_HOST=postgres_test # used when running the app with docker
+# TEST_DB_HOST=127.0.0.1 # when running the app without docker 
+TEST_DB_DRIVER=postgres
+TEST_API_SECRET=98hbun98h
+TEST_DB_USER=steven
+TEST_DB_PASSWORD=
+TEST_DB_NAME=fullstack_api_test
+TEST_DB_PORT=5432
+
+
+# # Mysql Live
+# DB_HOST=mysql # used when running the app with docker
+# # DB_HOST=127.0.0.1 # when running the app without docker 
+# DB_DRIVER=mysql 
+# API_SECRET=98hbun98h #Used for creating a JWT. Can be anything 
+# DB_USER=steven
+# DB_PASSWORD=here
+# DB_NAME=fullstack_api
+# DB_PORT=3306 #Default mysql port
+
+
+# # Mysql Test
+# TEST_DB_HOST=mysql_test # used when running the app with docker
+# # TEST_DB_HOST=127.0.0.1 # when running the app without docker 
+# TEST_DB_DRIVER=mysql
+# TEST_API_SECRET=98hbun98h
+# TEST_DB_USER=steven
+# TEST_DB_PASSWORD=here
+# TEST_DB_NAME=fullstack_api_test
+# TEST_DB_PORT=3306

Dockerfile

@@ -0,0 +1,43 @@
+# Start from golang base image
+FROM golang:alpine as builder
+
+# ENV GO111MODULE=on
+
+# Add Maintainer info
+LABEL maintainer="Steven Victor <chikodi543@gmail.com>"
+
+# Install git.
+# Git is required for fetching the dependencies.
+RUN apk update && apk add --no-cache git
+
+# Set the current working directory inside the container 
+WORKDIR /app
+
+# Copy go mod and sum files 
+COPY go.mod go.sum ./
+
+# RUN go mod tidy
+
+# Download all dependencies. Dependencies will be cached if the go.mod and the go.sum files are not changed 
+RUN go mod download 
+
+# Copy the source from the current directory to the working Directory inside the container 
+COPY . .
+# Build the Go app
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .
+
+# Start a new stage from scratch
+FROM alpine:latest
+RUN apk --no-cache add ca-certificates
+
+WORKDIR /root/
+
+# Copy the Pre-built binary file from the previous stage
+COPY --from=builder /app/main .
+COPY --from=builder /app/.env .
+
+# Expose port 8080 to the outside world
+EXPOSE 8080
+
+#Command to run the executable
+CMD ["./main"]

Dockerfile.test

@@ -0,0 +1,17 @@
+FROM golang:1.12-alpine
+
+# Install git
+
+RUN apk update && apk add --no-cache git
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+
+RUN go mod download 
+
+# Copy the source from the current directory to the working Directory inside the container 
+COPY . .
+
+# Run tests
+CMD CGO_ENABLED=0 go test -v  ./...

api/auth/token.go

@@ -0,0 +1,88 @@
+package auth
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	jwt "github.com/dgrijalva/jwt-go"
+)
+
+func CreateToken(user_id uint32) (string, error) {
+	claims := jwt.MapClaims{}
+	claims["authorized"] = true
+	claims["user_id"] = user_id
+	claims["exp"] = time.Now().Add(time.Hour * 1).Unix() //Token expires after 1 hour
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString([]byte(os.Getenv("API_SECRET")))
+
+}
+
+func TokenValid(r *http.Request) error {
+	tokenString := ExtractToken(r)
+	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
+		}
+		return []byte(os.Getenv("API_SECRET")), nil
+	})
+	if err != nil {
+		return err
+	}
+	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
+		Pretty(claims)
+	}
+	return nil
+}
+
+func ExtractToken(r *http.Request) string {
+	keys := r.URL.Query()
+	token := keys.Get("token")
+	if token != "" {
+		return token
+	}
+	bearerToken := r.Header.Get("Authorization")
+	if len(strings.Split(bearerToken, " ")) == 2 {
+		return strings.Split(bearerToken, " ")[1]
+	}
+	return ""
+}
+
+func ExtractTokenID(r *http.Request) (uint32, error) {
+
+	tokenString := ExtractToken(r)
+	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
+		}
+		return []byte(os.Getenv("API_SECRET")), nil
+	})
+	if err != nil {
+		return 0, err
+	}
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if ok && token.Valid {
+		uid, err := strconv.ParseUint(fmt.Sprintf("%.0f", claims["user_id"]), 10, 32)
+		if err != nil {
+			return 0, err
+		}
+		return uint32(uid), nil
+	}
+	return 0, nil
+}
+
+//Pretty display the claims licely in the terminal
+func Pretty(data interface{}) {
+	b, err := json.MarshalIndent(data, "", " ")
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	fmt.Println(string(b))
+}

api/controllers/base.go

@@ -0,0 +1,57 @@
+package controllers
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/jinzhu/gorm"
+
+	_ "github.com/jinzhu/gorm/dialects/mysql"    //mysql database driver
+	_ "github.com/jinzhu/gorm/dialects/postgres" //postgres database driver
+
+	"github.com/victorsteven/fullstack/api/models"
+)
+
+type Server struct {
+	DB     *gorm.DB
+	Router *mux.Router
+}
+
+func (server *Server) Initialize(Dbdriver, DbUser, DbPassword, DbPort, DbHost, DbName string) {
+
+	var err error
+
+	if Dbdriver == "mysql" {
+		DBURL := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8&parseTime=True&loc=Local", DbUser, DbPassword, DbHost, DbPort, DbName)
+		server.DB, err = gorm.Open(Dbdriver, DBURL)
+		if err != nil {
+			fmt.Printf("Cannot connect to %s database", Dbdriver)
+			log.Fatal("This is the error:", err)
+		} else {
+			fmt.Printf("We are connected to the %s database", Dbdriver)
+		}
+	}
+	if Dbdriver == "postgres" {
+		DBURL := fmt.Sprintf("host=%s port=%s user=%s dbname=%s sslmode=disable password=%s", DbHost, DbPort, DbUser, DbName, DbPassword)
+		server.DB, err = gorm.Open(Dbdriver, DBURL)
+		if err != nil {
+			fmt.Printf("Cannot connect to %s database", Dbdriver)
+			log.Fatal("This is the error:", err)
+		} else {
+			fmt.Printf("We are connected to the %s database", Dbdriver)
+		}
+	}
+
+	server.DB.Debug().AutoMigrate(&models.User{}, &models.Post{}) //database migration
+
+	server.Router = mux.NewRouter()
+
+	server.initializeRoutes()
+}
+
+func (server *Server) Run(addr string) {
+	fmt.Println("Listening to port 8080")
+	log.Fatal(http.ListenAndServe(addr, server.Router))
+}

api/controllers/home_controller.go

@@ -0,0 +1,12 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/victorsteven/fullstack/api/responses"
+)
+
+func (server *Server) Home(w http.ResponseWriter, r *http.Request) {
+	responses.JSON(w, http.StatusOK, "Welcome To This Awesome API")
+
+}

api/controllers/login_controller.go

@@ -0,0 +1,58 @@
+package controllers
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/victorsteven/fullstack/api/auth"
+	"github.com/victorsteven/fullstack/api/models"
+	"github.com/victorsteven/fullstack/api/responses"
+	"github.com/victorsteven/fullstack/api/utils/formaterror"
+	"golang.org/x/crypto/bcrypt"
+)
+
+func (server *Server) Login(w http.ResponseWriter, r *http.Request) {
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		responses.ERROR(w, http.StatusUnprocessableEntity, err)
+		return
+	}
+	user := models.User{}
+	err = json.Unmarshal(body, &user)
+	if err != nil {
+		responses.ERROR(w, http.StatusUnprocessableEntity, err)
+		return
+	}
+
+	user.Prepare()
+	err = user.Validate("login")
+	if err != nil {
+		responses.ERROR(w, http.StatusUnprocessableEntity, err)
+		return
+	}
+	token, err := server.SignIn(user.Email, user.Password)
+	if err != nil {
+		formattedError := formaterror.FormatError(err.Error())
+		responses.ERROR(w, http.StatusUnprocessableEntity, formattedError)
+		return
+	}
+	responses.JSON(w, http.StatusOK, token)
+}
+
+func (server *Server) SignIn(email, password string) (string, error) {
+
+	var err error
+
+	user := models.User{}
+
+	err = server.DB.Debug().Model(models.User{}).Where("email = ?", email).Take(&user).Error
+	if err != nil {
+		return "", err
+	}
+	err = models.VerifyPassword(user.Password, password)
+	if err != nil && err == bcrypt.ErrMismatchedHashAndPassword {
+		return "", err
+	}
+	return auth.CreateToken(user.ID)
+}