Build out the HTTP interface

- Use echo as the http server
- Wrap echo's context so that we can get real simple routing and error
  handling

Author: Jeff Mataya

remote/controllers/channels.go

@@ -0,0 +1,35 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/FoxComm/highlander/remote/models/phoenix"
+	"github.com/FoxComm/highlander/remote/payloads"
+	"github.com/FoxComm/highlander/remote/responses"
+)
+
+// GetChannel finds a single channel by its ID.
+func GetChannel(id int) ControllerFunc {
+	return func() *responses.Response {
+		channel := phoenix.Channel{
+			ID:               1,
+			Name:             "The Perfect Gourmet",
+			PurchaseLocation: 1,
+		}
+
+		return &responses.Response{
+			StatusCode: http.StatusOK,
+			Body:       channel,
+		}
+	}
+}
+
+// CreateChannel creates a new channel.
+func CreateChannel(payload *payloads.CreateChannel) ControllerFunc {
+	return func() *responses.Response {
+		return &responses.Response{
+			StatusCode: http.StatusCreated,
+			Body:       "I'm a channel",
+		}
+	}
+}

remote/controllers/controller_func.go

@@ -0,0 +1,7 @@
+package controllers
+
+import "github.com/FoxComm/highlander/remote/responses"
+
+// ControllerFunc is the execution API that any function called in a route must
+// conform to. It executes, then returns a response that can be handled.
+type ControllerFunc func() *responses.Response

remote/controllers/controllers.go

@@ -0,0 +1,25 @@
+package controllers
+
+import (
+	"github.com/labstack/echo"
+)
+
+// Start initializes all the controllers and routes.
+func Start() {
+	e := echo.New()
+
+	e.Use(func(h echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			fc := NewFoxContext(c)
+			return h(fc)
+		}
+	})
+
+	e.GET("/v1/public/channels/:id", func(c echo.Context) error {
+		fc := c.(*FoxContext)
+		id := fc.ParamInt("id")
+		return fc.Run(GetChannel(id))
+	})
+
+	e.Start(":9898")
+}

remote/controllers/errors.go

@@ -0,0 +1,26 @@
+package controllers
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/FoxComm/highlander/remote/responses"
+)
+
+func errParamMustBeNumber(paramName string) *responses.Response {
+	return &responses.Response{
+		StatusCode: http.StatusBadRequest,
+		Errs: []error{
+			fmt.Errorf("Param %s must be a number", paramName),
+		},
+	}
+}
+
+func errParamNotFound(paramName string) *responses.Response {
+	return &responses.Response{
+		StatusCode: http.StatusBadRequest,
+		Errs: []error{
+			fmt.Errorf("Param %s not found", paramName),
+		},
+	}
+}

remote/controllers/fox_context.go

@@ -0,0 +1,82 @@
+package controllers
+
+import (
+	"strconv"
+
+	"github.com/FoxComm/highlander/remote/responses"
+	"github.com/labstack/echo"
+)
+
+// FoxContext is a wrapper around echo.Context that eases error handling,
+// provides helper methods, and ensures we have consistent response handling.
+type FoxContext struct {
+	echo.Context
+	resp *responses.Response
+}
+
+// NewFoxContext creates a new FoxContext from an existing echo.Context.
+func NewFoxContext(c echo.Context) *FoxContext {
+	return &FoxContext{c, nil}
+}
+
+// ParamInt parses an integer from the parameters list (as defined by the URI).
+func (fc *FoxContext) ParamInt(name string) int {
+	if fc.resp != nil {
+		return 0
+	}
+
+	param := fc.Param(name)
+	if param == "" {
+		fc.resp = errParamNotFound(name)
+		return 0
+	}
+
+	paramInt, err := strconv.Atoi(param)
+	if err != nil {
+		fc.resp = errParamMustBeNumber(name)
+		return 0
+	}
+
+	return paramInt
+}
+
+// ParamString parses an string from the parameters list (as defined by the URI).
+func (fc *FoxContext) ParamString(name string) string {
+	if fc.resp != nil {
+		return ""
+	}
+
+	param := fc.Param(name)
+	if param == "" {
+		fc.resp = errParamNotFound(name)
+		return ""
+	}
+
+	return param
+}
+
+// Run executes the primary controller method and returns the response.
+func (fc *FoxContext) Run(ctrlFn ControllerFunc) error {
+	if fc.resp != nil {
+		return fc.handleResponse(fc.resp)
+	}
+
+	return fc.handleResponse(ctrlFn())
+}
+
+func (fc *FoxContext) handleResponse(resp *responses.Response) error {
+	if len(resp.Errs) == 0 {
+		return fc.JSON(resp.StatusCode, resp.Body)
+	}
+
+	errors := make([]string, len(resp.Errs))
+	for i, err := range resp.Errs {
+		errors[i] = err.Error()
+	}
+
+	errResp := map[string][]string{
+		"errors": errors,
+	}
+
+	return fc.JSON(resp.StatusCode, errResp)
+}

remote/glide.lock

@@ -1,3 +1,4 @@
 package: github.com/FoxComm/highlander/remote
 import:
-  - package: github.com/gin-gonic/gin
+  - package: github.com/labstack/echo
+  - package: github.com/lib/pq

remote/glide.yaml

@@ -1,7 +1,7 @@
 package main
 
-import "fmt"
+import "github.com/FoxComm/highlander/remote/controllers"
 
 func main() {
-	fmt.Println("Hello, I'm remote")
+	controllers.Start()
 }

remote/main.go

@@ -5,9 +5,9 @@ import "time"
 // Channel represents an avenue for purchasing on the Fox Platform. This could
 // be a website (theperfectgourmet.com), third-party (Amazon), or sale type (B2B).
 type Channel struct {
-	ID               int64
+	ID               int
 	Name             string
-	PurchaseLocation PurchaseLocation
+	PurchaseLocation int
 	CreatedAt        time.Time
 	UpdatedAt        time.Time
 }

remote/models/phoenix/channel.go

@@ -7,7 +7,3 @@ const (
 	// PurchaseOffFox means the channel's transactions happen off the platform.
 	PurchaseOffFox
 )
-
-// PurchaseLocation signifies whether a channel's transactions occur on the
-// platform, or whether they occur in a different location.
-type PurchaseLocation int64

remote/models/phoenix/purchase_location.go

@@ -0,0 +1,23 @@
+package payloads
+
+import "github.com/FoxComm/highlander/remote/models/phoenix"
+
+// CreateChannel is the structure of payload needed to create a channel.
+type CreateChannel struct {
+	Name          string `json:"name"`
+	PurchaseOnFox bool   `json:"purchaseOnFox"`
+	CatalogID     *int64 `json:"catalogId"`
+}
+
+// PhoenixModel returns the phoenix model for this payload.
+func (c CreateChannel) PhoenixModel() *phoenix.Channel {
+	model := &phoenix.Channel{Name: c.Name}
+
+	if c.PurchaseOnFox {
+		model.PurchaseLocation = phoenix.PurchaseOnFox
+	} else {
+		model.PurchaseLocation = phoenix.PurchaseOffFox
+	}
+
+	return model
+}

remote/payloads/channel_payloads.go

@@ -0,0 +1,8 @@
+package responses
+
+// Response is a generic HTTP response type.
+type Response struct {
+	StatusCode int
+	Body       interface{}
+	Errs       []error
+}