github.com/d0sbit/gocode@v0.0.0-20211001144653-a968ce917518/cmd/gocode_handlercrud/handlercrud.tmpl

{{define "HandlerUtil"}}
import "net/http"
import "strings"
import "strconv"
import "encoding/json"
import "fmt"
import "time"
import "log"
import "errors"
import "runtime"
import mathrand "math/rand"
import "github.com/julienschmidt/httprouter"

const (
    Create = "create"
    Read = "read"
    Update = "update"
    Delete = "delete"
)

type Allower interface {
    Allow(obj interface{}, perm string) error
}

type AllowerFunc func(obj interface{}, perm string) error

func (f AllowerFunc) Allow(obj interface{}, perm string) error {
    return f(obj, perm)
}

func isJSONMimeType(mt string) bool {
    mt = strings.TrimSpace(strings.SplitN(mt, ";", 2)[0])
    if strings.EqualFold("application/json", mt) {
        return true
    }
    return false
}

func param(r *http.Request, names ...string) string {
    p := httprouter.ParamsFromContext(r.Context())
    for _, name := range names {
        value := p.ByName(name)
        if value != "" {
            return value
        }
        value = r.FormValue(name)
        if value != "" {
            return value
        }
    }
    return ""
}

func scanParam(dst interface{}, paramVal string) (err error) {

    // some common cases we can deal with simply
    switch dstv := dst.(type) {
    case *string:
        *dstv = paramVal
        return
    case *int:
        v, err := strconv.ParseInt(paramVal, 0, 0)
        if err != nil {
            return err
        }
        *dstv = int(v)
        return nil
    case *uint:
        v, err := strconv.ParseUint(paramVal, 0, 0)
        if err != nil {
            return err
        }
        *dstv = uint(v)
        return nil
    case *int64:
        *dstv, err = strconv.ParseInt(paramVal, 0, 64)
        return nil
    case *uint64:
        *dstv, err = strconv.ParseUint(paramVal, 0, 64)
        return nil
    case *int32:
        v, err := strconv.ParseInt(paramVal, 0, 32)
        if err != nil {
            return err
        }
        *dstv = int32(v)
        return nil
    case *uint32:
        v, err := strconv.ParseUint(paramVal, 0, 32)
        if err != nil {
            return err
        }
        *dstv = uint32(v)
        return nil
    }

    // or delegate to a JSON unmarshal func if available
    if j, ok := dst.(json.Unmarshaler); ok {
        // TODO: read json.Marshal source to see if it's worth adding a fast path for strings that don't need escaping
        b, err := json.Marshal(paramVal)
        if err != nil {
            return err
        }
        return j.UnmarshalJSON(b)
    }

    return fmt.Errorf("don't know how to scan into %T", dst)
}

type httpStatusCoder interface {
    HTTPStatusCode() int
}

var rnd = mathrand.New(mathrand.NewSource(time.Now().UnixNano()))

type printfer interface {
    Printf(format string, v ...interface{})
}

var logger printfer = log.Default()

func writeErrf(w http.ResponseWriter, status int, err error, responseTextFormat string, args ...interface{}) {

    // look for a httpStatusCoder or default to status 500 (internal server error)
    sterr := err
    for status <= 0 && sterr != nil {
        s, ok := sterr.(httpStatusCoder)
        if ok {
            status = s.HTTPStatusCode()
            break
        }
        sterr = errors.Unwrap(sterr)
    }
    if status <= 0 {
        status = 500
    }

    errID := fmt.Sprintf("%016x", rnd.Uint64())

    w.Header().Set("X-Error-Id", errID)
    w.Header().Set("Content-Type", "text/html; charset=utf-8")

    w.WriteHeader(status)

    var responseMessage string
    if responseTextFormat != "" {
        responseMessage = fmt.Sprintf(responseTextFormat, args...)
    }
    if responseMessage == "" {
        responseMessage = http.StatusText(status)
    }
    if responseMessage == "" {
        responseMessage = "unknown error"
    }

    fmt.Fprint(w, "<h1>")
    fmt.Fprint(w, responseMessage)
    fmt.Fprint(w, "</h1><p>")
    fmt.Fprintf(w, "\n\nError ID: %s\n", errID)

    if logger == nil {
        return
    }

    _, file, line, _ := runtime.Caller(1)

    logger.Printf("HTTP handler error ID %s at %s:%d: %v; message: %s\n", errID, file, line, err, responseMessage)
}

func writeErr(w http.ResponseWriter, status int, err error) {
    writeErrf(w, status, err, "")
}
{{end}}

{{define "Handler"}}
{{if .StoreImportPath}}
import store "{{.StoreImportPath}}"
{{end}}

type {{$.Struct.LocalName}}Handler struct {
    Allower
    Store *store.{{$.Struct.LocalName}}Store
}
{{end}}

{{define "HandlerMethods"}}
import "net/http"
import "encoding/json"
{{if .StoreImportPath}}
import store "{{.StoreImportPath}}"
{{end}}


func (h *{{$.Struct.LocalName}}Handler) GetByID(w http.ResponseWriter, r *http.Request) {
    {{$idf := index $.Struct.FieldList.PK 0}}
    var err error
    var in store.{{$.Struct.LocalName}}
    idParam := param(r, "id")
    err = scanParam(&in.{{$idf.GoName}}, idParam)
    if err != nil {
        writeErrf(w, 400, err, "invalid ID %q", idParam)
        return
    }
    id := in.{{$idf.GoName}}
    err = h.Allow(&in, Read)
    if err != nil {
        writeErrf(w, 403, err, "access not allowed to record with ID %v", id)
        return
    }
    ret, err := h.Store.SelectByID(r.Context(), id)
    if err != nil {
        writeErrf(w, 0, err, "failed to load record with ID %v", id)
        return
    }
    err = json.NewEncoder(w).Encode(ret)
    if err != nil {
        writeErrf(w, 0, err, "json encoding error")
        return
    }
}

/*
func (h *XYZHandler) Post(w http.ResponseWriter, r *http.Request) {
}

func (h *XYZHandler) Patch(w http.ResponseWriter, r *http.Request) {
}

func (h *XYZHandler) Delete(w http.ResponseWriter, r *http.Request) {
}

func (h *XYZHandler) Select(w http.ResponseWriter, r *http.Request) {
}

func (h *XYZHandler) SelectCursor(w http.ResponseWriter, r *http.Request) {
}
*/
{{end}}

{{define "TestHandler"}}
{{end}}