feature: user

pkg/user/router.go

 package user
 
 import (
+	"encoding/json"
+	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -15,24 +17,118 @@ func NewUserRouter() *UserRouter {
 func (u *UserRouter) RegisterRoutes(r *mux.Router) {
 	r.Path("/").Methods(http.MethodGet).HandlerFunc(u.GetAll)
 	r.Path("/{id}").Methods(http.MethodGet).HandlerFunc(u.Get)
-	r.PathPrefix("/").Methods(http.MethodPut).HandlerFunc(u.Put)
 	r.PathPrefix("/").Methods(http.MethodPost).HandlerFunc(u.Post)
+	r.PathPrefix("/{id}").Methods(http.MethodPut).HandlerFunc(u.Put)
+	r.Path("/{id}").Methods(http.MethodDelete).HandlerFunc(u.Delete)
 }
 
 func (u *UserRouter) Get(rw http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 
-	rw.Write([]byte(vars["id"]))
+	routineDay, err := findById(r.Context(), vars["id"])
+	if err != nil {
+		log.Printf("error finding routine plan by id: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(routineDay)
+	if err != nil {
+		log.Printf("error marshaling routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Header().Set("Content-Type", "application/json")
+	rw.Write(bytes)
 }
 
 func (u *UserRouter) GetAll(rw http.ResponseWriter, r *http.Request) {
-	rw.Write([]byte("list"))
+	routineDays, err := findAll(r.Context())
+	if err != nil {
+		log.Printf("error finding routine plans: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(routineDays)
+	if err != nil {
+		log.Printf("error marshaling routine plans: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Header().Set("Content-Type", "application/json")
+	rw.Write(bytes)
+}
+
+func (u *UserRouter) Post(rw http.ResponseWriter, r *http.Request) {
+	var routineDay User
+
+	err := json.NewDecoder(r.Body).Decode(&routineDay)
+	if err != nil {
+		log.Printf("error decoding routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	routineDay, err = create(r.Context(), &routineDay)
+	if err != nil {
+		log.Printf("error creating routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(routineDay)
+	if err != nil {
+		log.Printf("error marshaling routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Header().Set("Content-Type", "application/json")
+	rw.Write(bytes)
 }
 
 func (u *UserRouter) Put(rw http.ResponseWriter, r *http.Request) {
-	rw.Write([]byte("put"))
+	vars := mux.Vars(r)
+	var routineDay User
+
+	err := json.NewDecoder(r.Body).Decode(&routineDay)
+	if err != nil {
+		log.Printf("error decoding routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	routineDay, err = update(r.Context(), vars["id"], &routineDay)
+	if err != nil {
+		log.Printf("error creating routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(routineDay)
+	if err != nil {
+		log.Printf("error marshaling routine plan: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Header().Set("Content-Type", "application/json")
+	rw.Write(bytes)
 }
 
-func (u *UserRouter) Post(rw http.ResponseWriter, r *http.Request) {
-	rw.Write([]byte("post"))
+func (u *UserRouter) Delete(rw http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+
+	err := delete(r.Context(), vars["id"])
+	if err != nil {
+		log.Printf("error finding routine plan by id: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Header().Set("Content-Type", "application/json")
+	rw.WriteHeader(http.StatusOK)
 }

pkg/user/user.go

 package user
+
+import (
+	"context"
+
+	"github.com/kamva/mgm/v3"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type User struct {
+	// DefaultModel adds _id, created_at and updated_at fields to the Model
+	mgm.DefaultModel `bson:",inline"`
+	Email            string `json:"email" bson:"email"`
+	FirstName        string `json:"first_name" bson:"first_name"`
+	LastName         string `json:"last_name" bson:"last_name"`
+	Password         string `json:"password" bson:"password"`
+	SessionToken     string `json:"session_token" bson:"session_token"`
+}
+
+func create(ctx context.Context, user *User) (User, error) {
+	coll := mgm.Coll(user)
+
+	err := coll.CreateWithCtx(ctx, user)
+
+	if err != nil {
+		return User{}, err
+	}
+
+	return *user, nil
+}
+
+func delete(ctx context.Context, id interface{}) error {
+	user := &User{}
+	coll := mgm.Coll(user)
+
+	err := coll.FindByIDWithCtx(ctx, id, user)
+	if err != nil {
+		return err
+	}
+
+	err = coll.DeleteWithCtx(ctx, user)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func findAll(ctx context.Context) ([]User, error) {
+	coll := mgm.Coll(&User{})
+
+	result, err := coll.Find(ctx, bson.M{})
+	if err != nil {
+		return nil, err
+	}
+
+	users := make([]User, 0)
+	err = result.All(ctx, &users)
+	if err != nil {
+		return nil, err
+	}
+
+	return users, nil
+}
+
+func findById(ctx context.Context, id interface{}) (User, error) {
+	user := &User{}
+	coll := mgm.Coll(user)
+
+	err := coll.FindByIDWithCtx(ctx, id, user)
+	if err != nil {
+		return User{}, err
+	}
+
+	return *user, nil
+}
+
+func update(ctx context.Context, id interface{}, newUser *User) (User, error) {
+	user := &User{}
+	coll := mgm.Coll(user)
+
+	err := coll.FindByIDWithCtx(ctx, id, user)
+	if err != nil {
+		return User{}, err
+	}
+
+	user.Email = newUser.Email
+	user.FirstName = newUser.FirstName
+	user.LastName = newUser.LastName
+	user.Password = newUser.Password
+	user.SessionToken = newUser.SessionToken
+
+	err = coll.UpdateWithCtx(ctx, user)
+	if err != nil {
+		return User{}, err
+	}
+
+	return *user, nil
+}