mirror of https://github.com/aclindsa/moneygo.git
141 lines
3.0 KiB
Go
141 lines
3.0 KiB
Go
package handlers
|
|
|
|
import (
|
|
"github.com/aclindsa/moneygo/internal/models"
|
|
"github.com/aclindsa/moneygo/internal/store"
|
|
"github.com/aclindsa/moneygo/internal/store/db"
|
|
"log"
|
|
"net/http"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// But who writes the ResponseWriterWriter?
|
|
type ResponseWriterWriter interface {
|
|
Write(http.ResponseWriter) error
|
|
}
|
|
|
|
type Context struct {
|
|
Tx *db.Tx
|
|
StoreTx store.Tx
|
|
User *models.User
|
|
remainingURL string // portion of URL path not yet reached in the hierarchy
|
|
}
|
|
|
|
func (c *Context) SetURL(url string) {
|
|
c.remainingURL = path.Clean("/" + url)[1:]
|
|
}
|
|
|
|
func (c *Context) NextLevel() string {
|
|
split := strings.SplitN(c.remainingURL, "/", 2)
|
|
if len(split) == 2 {
|
|
c.remainingURL = split[1]
|
|
} else {
|
|
c.remainingURL = ""
|
|
}
|
|
return split[0]
|
|
}
|
|
|
|
func (c *Context) NextID() (int64, error) {
|
|
return strconv.ParseInt(c.NextLevel(), 0, 64)
|
|
}
|
|
|
|
func (c *Context) LastLevel() bool {
|
|
return len(c.remainingURL) == 0
|
|
}
|
|
|
|
type Handler func(*http.Request, *Context) ResponseWriterWriter
|
|
|
|
type APIHandler struct {
|
|
Store *db.DbStore
|
|
}
|
|
|
|
func (ah *APIHandler) txWrapper(h Handler, r *http.Request, context *Context) (writer ResponseWriterWriter) {
|
|
tx, err := GetTx(ah.Store.DbMap)
|
|
if err != nil {
|
|
log.Print(err)
|
|
return NewError(999 /*Internal Error*/)
|
|
}
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
panic(r)
|
|
}
|
|
if _, ok := writer.(*Error); ok {
|
|
tx.Rollback()
|
|
} else {
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
log.Print(err)
|
|
writer = NewError(999 /*Internal Error*/)
|
|
}
|
|
}
|
|
}()
|
|
|
|
context.Tx = tx
|
|
context.StoreTx = tx
|
|
return h(r, context)
|
|
}
|
|
|
|
func (ah *APIHandler) storeTxWrapper(h Handler, r *http.Request, context *Context) (writer ResponseWriterWriter) {
|
|
tx, err := ah.Store.Begin()
|
|
if err != nil {
|
|
log.Print(err)
|
|
return NewError(999 /*Internal Error*/)
|
|
}
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
panic(r)
|
|
}
|
|
if _, ok := writer.(*Error); ok {
|
|
tx.Rollback()
|
|
} else {
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
log.Print(err)
|
|
writer = NewError(999 /*Internal Error*/)
|
|
}
|
|
}
|
|
}()
|
|
|
|
context.StoreTx = tx
|
|
return h(r, context)
|
|
}
|
|
|
|
func (ah *APIHandler) route(r *http.Request) ResponseWriterWriter {
|
|
context := &Context{}
|
|
context.SetURL(r.URL.Path)
|
|
if context.NextLevel() != "v1" {
|
|
return NewError(3 /*Invalid Request*/)
|
|
}
|
|
|
|
route := context.NextLevel()
|
|
|
|
switch route {
|
|
case "sessions":
|
|
return ah.txWrapper(SessionHandler, r, context)
|
|
case "users":
|
|
return ah.txWrapper(UserHandler, r, context)
|
|
case "securities":
|
|
return ah.txWrapper(SecurityHandler, r, context)
|
|
case "securitytemplates":
|
|
return SecurityTemplateHandler(r, context)
|
|
case "accounts":
|
|
return ah.txWrapper(AccountHandler, r, context)
|
|
case "transactions":
|
|
return ah.txWrapper(TransactionHandler, r, context)
|
|
case "imports":
|
|
return ah.txWrapper(ImportHandler, r, context)
|
|
case "reports":
|
|
return ah.txWrapper(ReportHandler, r, context)
|
|
default:
|
|
return NewError(3 /*Invalid Request*/)
|
|
}
|
|
}
|
|
|
|
func (ah *APIHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ah.route(r).Write(w)
|
|
}
|