gogmagog/routes/primary_plans.go

package routes

import (
	"encoding/json"
	"gitea.deepak.science/deepak/gogmagog/models"
	"gitea.deepak.science/deepak/gogmagog/tokens"
	"github.com/go-chi/chi"
	"io"
	"net/http"
)

// NewPrimaryPlanRouter returns a new primary plan router
func NewPrimaryPlanRouter(m *models.Model) http.Handler {
	router := chi.NewRouter()
	router.Get("/", getPrimaryPlanFunc(m))
	router.Post("/", postPrimaryPlanFunc(m))
	router.Put("/", putPrimaryPlanFunc(m))
	return router
}

func getPrimaryPlanFunc(m *models.Model) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, userErr := tokens.GetUserID(r.Context())
		if userErr != nil {
			unauthorizedHandler(w, r)
			return
		}

		pp, err := m.PrimaryPlan(userID)
		if err != nil {
			if models.IsNotFoundError(err) {
				notFoundHandler(w, r)
				return
			}
			serverError(w, err)
			return
		}

		w.Header().Add("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(pp); err != nil {
			serverError(w, err)
		}
	}
}

type createPrimaryPlanResponse struct {
	CreatedPrimaryPlan *models.PrimaryPlan `json:"created_current_plan"`
}

func postPrimaryPlanFunc(m *models.Model) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {

		userID, err := tokens.GetUserID(r.Context())
		if err != nil {
			unauthorizedHandler(w, r)
			return
		}

		r.Body = http.MaxBytesReader(w, r.Body, 1024)
		dec := json.NewDecoder(r.Body)
		dec.DisallowUnknownFields()
		var pp models.PrimaryPlan
		err = dec.Decode(&pp)
		if err != nil {
			badRequestError(w, err)
			return
		}
		err = dec.Decode(&struct{}{})
		if err != io.EOF {
			badRequestError(w, err)
			return
		}

		newPP := &models.PrimaryPlan{
			PlanID: pp.PlanID,
			UserID: int64(userID),
		}
		err = m.AddPrimaryPlan(newPP, userID)
		if err != nil {
			serverError(w, err)
			return
		}
		finishedPP, err := m.PrimaryPlan(userID)
		if err != nil {
			serverError(w, err)
			return
		}

		response := &createPrimaryPlanResponse{
			CreatedPrimaryPlan: finishedPP,
		}
		w.Header().Add("Content-Type", "application/json")
		w.WriteHeader(http.StatusCreated)
		if err := json.NewEncoder(w).Encode(response); err != nil {
			serverError(w, err)
		}

	}
}

type updatePrimaryPlanResponse struct {
	UpdatedPrimaryPlan *models.PrimaryPlan `json:"updated_current_plan"`
}

func putPrimaryPlanFunc(m *models.Model) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {

		userID, err := tokens.GetUserID(r.Context())
		if err != nil {
			unauthorizedHandler(w, r)
			return
		}

		_, err = m.PrimaryPlan(userID)
		if models.IsNotFoundError(err) {
			notFoundHandler(w, r)
			return
		}

		r.Body = http.MaxBytesReader(w, r.Body, 1024)
		dec := json.NewDecoder(r.Body)
		dec.DisallowUnknownFields()
		var pp models.PrimaryPlan
		err = dec.Decode(&pp)
		if err != nil {
			badRequestError(w, err)
			return
		}
		err = dec.Decode(&struct{}{})
		if err != io.EOF {
			badRequestError(w, err)
			return
		}

		newPP := &models.PrimaryPlan{
			PlanID: pp.PlanID,
			UserID: int64(userID),
		}
		err = m.SavePrimaryPlan(newPP, userID)
		if err != nil {
			serverError(w, err)
			return
		}
		newPP, err = m.PrimaryPlan(userID)
		if err != nil {
			serverError(w, err)
			return
		}

		response := &updatePrimaryPlanResponse{
			UpdatedPrimaryPlan: newPP,
		}
		w.Header().Add("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		if err := json.NewEncoder(w).Encode(response); err != nil {
			serverError(w, err)
		}

	}
}