#17 add dockerfile for api

api/src/middleware/auth.go

@@ -0,0 +1,34 @@
+package middleware
+
+import (
+	"api/src/utils"
+
+	"context"
+	"net/http"
+)
+
+type ContextKey string
+
+const TOKEN_KEY ContextKey = "token"
+
+func EnsureAuth(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tokenStr := r.Header.Get("Authorization")
+		if (tokenStr == "") || (len(tokenStr) < len("Bearer ")) {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+
+		tokenStr = tokenStr[len("Bearer "):]
+
+		token, err := utils.VerifyToken(tokenStr)
+		if err != nil {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+
+		var newContext = context.WithValue(r.Context(), TOKEN_KEY, token)
+
+		next.ServeHTTP(w, r.WithContext(newContext))
+	})
+}

api/src/middleware/cors.go

@@ -0,0 +1,28 @@
+package middleware
+
+import (
+	"log"
+	"net/http"
+	"os"
+)
+
+func EnableCors(next http.Handler) http.Handler {
+	var frontent_url = os.Getenv("FRONTEND_URL")
+	if frontent_url == "" {
+		log.Fatal("FRONTEND_URL is not set")
+	}
+	log.Println("FRONTEND_URL is", frontent_url)
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", frontent_url)
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE")
+		w.Header().Set("Access-Control-Allow-Headers", "Authorization")
+
+		if r.Method == "OPTIONS" {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}

api/src/middleware/logger.go

@@ -0,0 +1,30 @@
+package middleware
+
+import (
+	"log"
+	"net/http"
+	"time"
+)
+
+type WrappedWriter struct {
+	http.ResponseWriter
+	StatusCode int
+}
+
+func (w *WrappedWriter) WriteHeader(code int) {
+	w.ResponseWriter.WriteHeader(code)
+	w.StatusCode = code
+}
+
+func Logging(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+
+		wrapped := &WrappedWriter{
+			ResponseWriter: w,
+			StatusCode:     http.StatusOK,
+		}
+		next.ServeHTTP(wrapped, r)
+		log.Println(wrapped.StatusCode, r.Method, r.URL.Path, time.Since(start))
+	})
+}

api/src/utils/auth.go

@@ -0,0 +1,36 @@
+package utils
+
+import (
+	"context"
+	"log"
+
+	firebase "firebase.google.com/go"
+	"firebase.google.com/go/auth"
+	"google.golang.org/api/option"
+)
+
+var app *firebase.App
+
+func VerifyToken(token string) (*auth.Token, error) {
+	if app == nil {
+		setup()
+	}
+
+	client, err := app.Auth(context.Background())
+	if err != nil {
+		log.Fatalf("error getting Auth client: %v\n", err)
+	}
+	return client.VerifyIDToken(context.Background(), token)
+}
+
+func setup() {
+	opt := option.WithCredentialsFile("./secrets/me-fit-a9365-firebase-adminsdk-8065w-7cf8443902.json")
+
+	firebaseApp, err := firebase.NewApp(context.Background(), nil, opt)
+
+	if err != nil {
+		log.Fatalf("error initializing app: %v", err)
+	}
+
+	app = firebaseApp
+}

api/src/utils/db.go

@@ -0,0 +1,43 @@
+package utils
+
+import (
+	"database/sql"
+	"log"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database/sqlite3"
+	_ "github.com/golang-migrate/migrate/v4/source/file"
+)
+
+func InitializeDB() *sql.DB {
+
+	db, err := sql.Open("sqlite3", "./data.db")
+	if err != nil {
+		log.Fatal("Could not open Database data.db: ", err)
+	}
+	defer db.Close()
+
+	runMigrations(db)
+
+	return db
+}
+
+func runMigrations(db *sql.DB) {
+	driver, err := sqlite3.WithInstance(db, &sqlite3.Config{})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	m, err := migrate.NewWithDatabaseInstance(
+		"file://./migrations/",
+		"",
+		driver)
+	if err != nil {
+		log.Fatal("Could not create migrations instance: ", err)
+	}
+
+	err = m.Up()
+	if err != nil {
+		log.Fatal("Could not run migrations: ", err)
+	}
+}

api/src/utils/http-utils.go

@@ -0,0 +1,11 @@
+package utils
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func WriteJSON(w http.ResponseWriter, data interface{}) error {
+	w.Header().Set("Content-Type", "application/json")
+	return json.NewEncoder(w).Encode(data)
+}

api/src/workout/workout.go

@@ -0,0 +1,91 @@
+package workout
+
+import (
+	"api/src/middleware"
+	"api/src/utils"
+
+	"database/sql"
+	"net/http"
+	"strconv"
+	"time"
+
+	"firebase.google.com/go/auth"
+)
+
+func NewWorkout(db *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var dateStr = r.FormValue("date")
+		var typeStr = r.FormValue("type")
+		var setsStr = r.FormValue("sets")
+		var repsStr = r.FormValue("reps")
+
+		if dateStr == "" || typeStr == "" || setsStr == "" || repsStr == "" {
+			http.Error(w, "Missing required fields", http.StatusBadRequest)
+			return
+		}
+
+		date, err := time.Parse("2006-01-02", dateStr)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		sets, err := strconv.Atoi(setsStr)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		reps, err := strconv.Atoi(repsStr)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		token := r.Context().Value(middleware.TOKEN_KEY).(*auth.Token)
+
+		_, err = db.Exec("INSERT INTO workout (user_id, date, type, sets, reps) VALUES (?, ?, ?, ?, ?)", token.UID, date, typeStr, sets, reps)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+func GetWorkouts(db *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		token := r.Context().Value(middleware.TOKEN_KEY).(*auth.Token)
+		var userId = token.UID
+
+		rows, err := db.Query("SELECT date, type, sets, reps FROM workout WHERE user_id = ?", userId)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		var workouts = make([]map[string]interface{}, 0)
+		for rows.Next() {
+			var date string
+			var workoutType string
+			var sets int
+			var reps int
+
+			err = rows.Scan(&date, &workoutType, &sets, &reps)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			workout := map[string]interface{}{
+				"date": date,
+				"type": workoutType,
+				"sets": sets,
+				"reps": reps,
+			}
+			workouts = append(workouts, workout)
+		}
+
+		utils.WriteJSON(w, workouts)
+	}
+}