Add API with insert about go-base HOT 5 CLOSED

func (rs *ReportResource) insert(w http.ResponseWriter, r *http.Request) {
p := r.Context().Value(ctxReport).(*models.Report)
data := &reportRequest{Report: p}

func (rs *ReportResource) insert(w http.ResponseWriter, r *http.Request) {
data := &reportRequest{}

{
    "status": "Internal Server Error"
}

// Package app ties together application resources and handlers.
package app

import (
	"net/http"

	"github.com/go-chi/chi"
	"github.com/go-pg/pg"
	"github.com/sirupsen/logrus"

	"github.com/dhax/go-base/database"
	"github.com/dhax/go-base/logging"
)

type ctxKey int

const (
	ctxAccount ctxKey = iota
	ctxProfile
	ctxReport
)

// API provides application resources and handlers.
type API struct {
	Account *AccountResource
	Profile *ProfileResource
	Report *ReportResource
}

// NewAPI configures and returns application API.
func NewAPI(db *pg.DB) (*API, error) {
	accountStore := database.NewAccountStore(db)
	account := NewAccountResource(accountStore)

	profileStore := database.NewProfileStore(db)
	profile := NewProfileResource(profileStore)

	reportStore := database.NewReportStore(db)
	report := NewReportResource(reportStore)

	api := &API{
		Account: account,
		Profile: profile,
		Report: report,
	}
	return api, nil
}

// Router provides application routes.
func (a *API) Router() *chi.Mux {
	r := chi.NewRouter()

	r.Mount("/account", a.Account.router())
	r.Mount("/profile", a.Profile.router())
	r.Mount("/report", a.Report.router())

	return r
}

func log(r *http.Request) logrus.FieldLogger {
	return logging.GetLogEntry(r)
}

package app

import (
	"context"
	"errors"
	"github.com/dhax/go-base/auth/jwt"
	"github.com/dhax/go-base/models"
	"github.com/go-chi/chi"
	"github.com/go-chi/render"
	"net/http"
)

// The list of error types returned from account resource.
var (
	ErrReportValidation = errors.New("report validation error")
)

// ReportStore defines database operations for a report.
type ReportStore interface {
	Get(accountID int) (*models.Report, error)
	Create(*models.Report) error
}

// ReportResource implements report management handler.
type ReportResource struct {
	Store ReportStore
}

// NewReportResource creates and returns a report resource.
func NewReportResource(store ReportStore) *ReportResource {
	return &ReportResource{
		Store: store,
	}
}

func (rs *ReportResource) router() *chi.Mux {
	r := chi.NewRouter()
	r.Use(rs.reportCtx)
	r.Get("/", rs.get)
	r.Post("/", rs.create)
	//r.Put("/", rs.update)
	return r
}

func (rs *ReportResource) reportCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		claims := jwt.ClaimsFromCtx(r.Context())
		p, err := rs.Store.Get(claims.ID)
		if err != nil {
			log(r).WithField("reportCtx", claims.Sub).Error(err)
			render.Render(w, r, ErrInternalServerError)
			return
		}

		ctx := context.WithValue(r.Context(), ctxReport, p)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

type reportRequest struct {
	*models.Report
}

func (d *reportRequest) Bind(r *http.Request) error {
	return nil
}

type reportResponse struct {
	*models.Report
}

func newReportResponse(p *models.Report) *reportResponse {
	return &reportResponse{
		Report: p,
	}

}

func (rs *ReportResource) get(w http.ResponseWriter, r *http.Request) {
	p := r.Context().Value(ctxReport).(*models.Report)
	render.Respond(w, r, newReportResponse(p))
}

func (rs *ReportResource) create(w http.ResponseWriter, r *http.Request) {
	data := &reportRequest{}
	if err := render.Bind(r, data); err != nil {
		render.Render(w, r, ErrInvalidRequest(err))
	}

	if err := rs.Store.Create(data.Report); err != nil {
		//switch err.(type) {
		//case validation.Errors:
		//	render.Render(w, r, ErrValidation(ErrReportValidation, err.(validation.Errors)))
		//	return
		//}
		render.Render(w, r, ErrRender(err))
		return
	}
	render.Respond(w, r, http.StatusOK)
}

package database

import (
	"github.com/dhax/go-base/models"
	"github.com/go-pg/pg"
	//"database/sql"
	"log"
)

// ReportStore implements database operations for profile management.
type ReportStore struct {
	db *pg.DB
}

// NewProfileStore returns a ReportStore implementation.
func NewReportStore(db *pg.DB) *ReportStore {
	return &ReportStore{
		db: db,
	}
}

// Get gets a report by account ID.
func (s *ReportStore) Get(accountID int) (*models.Report, error) {
	p := models.Report{AccountID: accountID}
	_, err := s.db.Model(&p).
		Where("account_id = ?", accountID).
		SelectOrInsert()

	return &p, err
}

// Update report .
func (s *ReportStore) Update(p *models.Report) error {
	err := s.db.Update(p)
	return err
}


// Create inserts the Reports to the database.
func (s *ReportStore) Create(p *models.Report) error {
	err := s.db.Insert(p)
	log.Println(p)
	if err != nil {
		return err
	}
	return err
}

// Package models contains application specific entities.
package models

import (
	"database/sql"
	"github.com/go-ozzo/ozzo-validation"
	"time"
	//"github.com/pkg/errors"

)

// Profile holds specific application settings linked to an Account.
type Report struct {
	// Reports represents public.reports
	Id              int   `sql:",pk,unique"`          // id
	AccountID       int   // account_id
	UpdatedAt       time.Time      // date
	Temperature     sql.NullFloat64 // temperature
	Cough           bool            // cough
	RunningNose     bool            // running_nose
	SoreThroat      bool            // sore_throat
	DifficultBreath bool            // difficult_breath
	Headache        bool            // headache
	Diarrhea        bool            // diarrhea
	Nausea          bool            // nausea
	VitA            bool            // vit_a
	VitE            bool            // vit_e
	VitD            bool            // vit_d
	VitC            bool            // vit_c
	Sunbathe        bool            // sunbathe
	Exercise        bool            // exercise
	Veg             bool            // veg
	Fruit           bool            // fruit
	SleepEarly      bool            // sleep_early
	Mask            bool            // mask
	Handwash        bool            // handwash
	Complaint       sql.NullString  // complaint
	Medicine        sql.NullString  // medicine
}

// Validate validates Profile struct and returns validation errors.
func (p *Report) Validate() error {

	return validation.ValidateStruct(p,
		validation.Field(&p.AccountID, validation.Required),
	)
}