feat/fix: adds player handlers,dockerfiles & minor fixes

auth/cmd/main/main.go

@@ -4,10 +4,12 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/p-society/gc-server/auth/internal/db"
 	"github.com/p-society/gc-server/auth/internal/router"
 )
 
 func main() {
+	db.InitAuth()
 	fmt.Println("Running...")
 	http.ListenAndServe(":2609", router.AuthRouter())
 }

auth/internal/handlers/callback_signup.go

@@ -5,10 +5,12 @@ import (
 	"encoding/json"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/p-society/gc-server/auth/internal/db"
 	"github.com/p-society/gc-server/auth/internal/utils"
 	"github.com/p-society/gc-server/auth/pkg/security"
+	errors "github.com/p-society/gc-server/errors/pkg"
 	model "github.com/p-society/gc-server/schemas/pkg/models"
 )
 
@@ -37,21 +39,35 @@ func CallbackVerification(w http.ResponseWriter, r *http.Request) {
 
 	if err := p.Valid(); err != nil {
 		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"error": err.Error(),
-		})
+		errors.SendErrorJson(w, err)
 		return
 	}
 
 	if err := utils.CheckOTP(p.OTP, reqBody.OTP); err != nil {
 		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"error": err.Error(),
-		})
+		errors.SendErrorJson(w, err)
 		return
 	}
 
-	res, _ := db.PlayerCollection.InsertOne(context.TODO(), p)
+	res, err := db.PlayerCollection.InsertOne(context.TODO(), model.Player{
+		FirstName: p.FirstName,
+		LastName:  p.LastName,
+		Email:     p.Email,
+		Password:  p.Password,
+		Role:      p.Role,
+		Branch:    p.Branch,
+		Year:      p.Year,
+		ContactNo: p.ContactNo,
+		Social:    p.Social,
+		CreatedAt: time.Now(),
+	})
+	if err != nil {
+		// TODO: Handle Error Properly (Duplicacy Mongo..
+		// @zakhaev26
+		// )
+		errors.SendErrorJson(w, err)
+		return
+	}
 
 	json.NewEncoder(w).Encode(res.InsertedID)
 }

auth/internal/handlers/signup_handler.go

@@ -7,12 +7,11 @@ import (
 	"time"
 
 	"github.com/golang-jwt/jwt"
-	"github.com/p-society/gc-server/auth/internal"
 	"github.com/p-society/gc-server/auth/internal/utils"
 	"github.com/p-society/gc-server/auth/pkg/security"
 	enum "github.com/p-society/gc-server/enums/pkg"
+	errors "github.com/p-society/gc-server/errors/pkg"
 	model "github.com/p-society/gc-server/schemas/pkg/models"
-	"golang.org/x/crypto/bcrypt"
 )
 
 func SignUpHandler(w http.ResponseWriter, r *http.Request) {
@@ -23,27 +22,23 @@ func SignUpHandler(w http.ResponseWriter, r *http.Request) {
 	err := json.NewDecoder(r.Body).Decode(&p)
 	defer r.Body.Close()
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+		errors.SendErrorJson(w, err)
 		return
 	}
 	// NOTE: To create PSA , Comment this as of now.
 	p.Role = enum.PLAYER
 
 	err = p.Valid()
 	if err != nil {
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"error": err.Error(),
-		})
+		errors.SendErrorJson(w, err)
 		return
 	}
 
-	err = utils.IsUniqueInDB(p.Email)
-	if err != nil {
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"error": err.Error(),
-		})
-		return
-	}
+	// err = utils.IsUniqueInDB(p.Email)
+	// if err != nil {
+	// 	errors.SendErrorJson(w, err)
+	// 	return
+	// }
 
 	p.StandardClaims = jwt.StandardClaims{
 		IssuedAt:  time.Now().Unix(),
@@ -54,23 +49,24 @@ func SignUpHandler(w http.ResponseWriter, r *http.Request) {
 	p.OTP = utils.GenerateOTP(6)
 	fmt.Println(p.OTP)
 
-	if err := internal.SendEmail(&p); err != nil {
-		json.NewEncoder(w).Encode(err.Error())
+	if err := utils.SendEmail(&p); err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		errors.SendErrorJson(w, fmt.Errorf("internal server error"))
+		return
 	}
 
-	hashedPass, err := bcrypt.GenerateFromPassword([]byte(p.Password), 10)
+	hashedPass, err := security.HashPassword(p.Password)
 
 	if err != nil {
+		errors.SendErrorJson(w, err)
 		panic(err)
 	}
 
 	p.Password = string(hashedPass)
 
 	token, err := security.NewAccessToken(p)
 	if err != nil {
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"error": err.Error(),
-		})
+		errors.SendErrorJson(w, err)
 		return
 	}
 

auth/internal/render_engine.go → auth/internal/utils/render_engine.go

@@ -1,4 +1,4 @@
-package internal
+package utils
 
 func RenderEngine(OTP int) string {
 	return `

auth/internal/sendMail.go → auth/internal/utils/sendMail.go

@@ -1,4 +1,4 @@
-package internal
+package utils
 
 import (
 	"bytes"

auth/internal/utils/extract_token.go → auth/pkg/security/extract_token.go

@@ -1,4 +1,4 @@
-package utils
+package security
 
 import (
 	"fmt"
@@ -9,7 +9,7 @@ import (
 func ExtractTokenFromHeader(r *http.Request) (string, error) {
 
 	authHeader := r.Header.Get("Authorization")
-	if authHeader == "" && strings.Split(authHeader, " ")[0] == "Bearer" {
+	if authHeader == "" || len(authHeader) == 2 {
 		return "", fmt.Errorf("token not found")
 	}
 

auth/pkg/security/hash_passwords.go

@@ -0,0 +1,7 @@
+package security
+
+import "golang.org/x/crypto/bcrypt"
+
+func HashPassword(password string) ([]byte, error) {
+	return bcrypt.GenerateFromPassword([]byte(password), 10)
+}

auth/pkg/security/rbac.go

@@ -1,9 +1,8 @@
 package security
 
 import (
+	"encoding/json"
 	"net/http"
-
-	"github.com/p-society/gc-server/auth/internal/utils"
 )
 
 type RoleGuard struct {
@@ -17,10 +16,13 @@ func (rg *RoleGuard) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		err   error
 	)
 
-	token, err = utils.ExtractTokenFromHeader(r)
-	if err != nil {
+	token, err = ExtractTokenFromHeader(r)
+	if err != nil || token == "" {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusUnauthorized)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"error": err.Error(),
+		})
 		return
 	}
 
@@ -29,6 +31,9 @@ func (rg *RoleGuard) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if !contains(rg.AllowedRoles, p.Role) {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusForbidden)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"error": "you are not authorized to access this resource",
+		})
 		return
 	}
 

core/cmd/main/main.go

@@ -1,5 +1,15 @@
 package main
 
-func main() {
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/p-society/gc-server/core/internal"
+	"github.com/p-society/gc-server/core/internal/db"
+)
 
+func main() {
+	db.Init()
+	fmt.Println("core live @ 127.0.0.1:8080")
+	http.ListenAndServe(":8080", internal.Router())
 }

core/internal/player/handlers/delete_handler.go

@@ -1,7 +1,51 @@
 package handlers
 
-import "net/http"
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/p-society/gc-server/auth/pkg/security"
+	"github.com/p-society/gc-server/core/internal/db"
+	errors "github.com/p-society/gc-server/errors/pkg"
+	model "github.com/p-society/gc-server/schemas/pkg/models"
+	"go.mongodb.org/mongo-driver/bson"
+)
 
 func DeleteHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+
+	token, err := security.ExtractTokenFromHeader(r)
+	if err != nil {
+		errors.SendErrorJson(w, err)
+	}
+
+	p := security.ParseAccessToken(token)
+
+	p.IsDeleted = true
+	p.DeletedBy = p.ID
+
+	update := bson.M{
+		"$set": bson.M{
+			"isDeleted": true,
+			"deletedBy": p.ID, //for now ...
+			"deletedAt": time.Now(),
+		},
+	}
+
+	filter := bson.M{"_id": p.ID}
+
+	var x model.Player
+	res := db.PlayerCollection.FindOneAndUpdate(context.Background(), filter, update)
+
+	if err := res.Decode(&x); err != nil {
+		errors.SendErrorJson(w, err)
+		return
+	}
+
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"updated": true,
+	})
 
 }

core/internal/player/handlers/get_handler.go

@@ -0,0 +1,9 @@
+package handlers
+
+import "net/http"
+
+func GetHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+
+
+}

core/internal/player/handlers/update_handler.go

@@ -1,7 +1,57 @@
 package handlers
 
-import "net/http"
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/p-society/gc-server/auth/pkg/security"
+	"github.com/p-society/gc-server/core/internal/db"
+	errors "github.com/p-society/gc-server/errors/pkg"
+	model "github.com/p-society/gc-server/schemas/pkg/models"
+	"go.mongodb.org/mongo-driver/bson"
+)
 
 func UpdateHandler(w http.ResponseWriter, r *http.Request) {
+	var (
+		p map[string]interface{}
+	)
+	token, _ := security.ExtractTokenFromHeader(r)
+	reqP := security.ParseAccessToken(token)
+	id := reqP.ID
+	if err := json.NewDecoder(r.Body).Decode(&p); err != nil {
+		errors.SendErrorJson(w, err)
+		return
+	}
+
+	filter := bson.M{"_id": id}
+
+	//  Prepare update operation
+	update := bson.M{
+		"$set": p,
+	}
+
+	if p["email"] != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		errors.SendErrorJson(w, fmt.Errorf("email can't be changed"))
+		return
+	}
+
+	var x model.Player
+	res := db.PlayerCollection.FindOneAndUpdate(context.Background(), filter, update)
+	if res.Err() != nil {
+		errors.SendErrorJson(w, res.Err())
+		return
+	}
+
+	// Decode the result into x
+	if err := res.Decode(&x); err != nil {
+		errors.SendErrorJson(w, err)
+		return
+	}
 
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"updated": true,
+	})
 }

core/internal/router.go

@@ -12,15 +12,19 @@ import (
 func Router() *mux.Router {
 	r := mux.NewRouter()
 
-	r.Handle("/v0/players/update", &security.RoleGuard{
-		AllowedRoles: []string{enum.ADMIN, enum.PLATFORM_SUPER_ADMIN, enum.ADMIN},
+	r.Handle("/v0/players", &security.RoleGuard{
+		AllowedRoles: []string{enum.ADMIN, enum.PLAYER, enum.PLATFORM_SUPER_ADMIN},
 		Handler:      http.HandlerFunc((handlers.UpdateHandler)),
-	})
+	}).Methods("PATCH")
 
-	r.Handle("/v0/players/delete", &security.RoleGuard{
-		AllowedRoles: []string{enum.ADMIN, enum.PLATFORM_SUPER_ADMIN, enum.ADMIN},
+	r.Handle("/v0/players", &security.RoleGuard{
+		AllowedRoles: []string{enum.ADMIN, enum.PLATFORM_SUPER_ADMIN, enum.PLAYER},
 		Handler:      http.HandlerFunc((handlers.DeleteHandler)),
-	})
+	}).Methods("DELETE")
 
+	r.Handle("/v0/players", &security.RoleGuard{
+		AllowedRoles: []string{enum.ADMIN, enum.PLATFORM_SUPER_ADMIN},
+		Handler:      http.HandlerFunc((handlers.GetHandler)),
+	}).Methods("GET")
 	return r
 }

docker/auth/Dockerfile

@@ -0,0 +1,8 @@
+FROM golang:latest
+
+WORKDIR /go/src/app
+
+COPY . .
+
+RUN go mod download
+

docker/core/Dockerfile

@@ -0,0 +1 @@
+FROM golang:latest