WIP

Author: Jeff Mataya

remote/controllers/channels.go

@@ -3,29 +3,53 @@ package controllers
 import (
 	"net/http"
 
+	"github.com/FoxComm/highlander/remote/db"
 	"github.com/FoxComm/highlander/remote/models/phoenix"
 	"github.com/FoxComm/highlander/remote/payloads"
 	"github.com/FoxComm/highlander/remote/responses"
+	"github.com/jinzhu/gorm"
 )
 
+type Channels struct {
+	phxDB *gorm.DB
+}
+
+func NewChannels(phxDB *gorm.DB) *Channels {
+	return &Channels{phxDB: phxDB}
+}
+
 // GetChannel finds a single channel by its ID.
-func GetChannel(id int) ControllerFunc {
+func (ctrl *Channels) GetChannel(id int) ControllerFunc {
 	return func() *responses.Response {
-		channel := phoenix.Channel{
-			ID:               1,
-			Name:             "The Perfect Gourmet",
-			PurchaseLocation: 1,
+		channel := &phoenix.Channel{}
+
+		err := db.FindChannelByID(ctrl.phxDB, id, channel)
+		if err != nil {
+			if err.Error() == "record not found" {
+				return &responses.Response{
+					StatusCode: http.StatusNotFound,
+					Errs:       []error{err},
+				}
+			}
+
+			return &responses.Response{
+				StatusCode: http.StatusInternalServerError,
+				Errs:       []error{err},
+			}
 		}
 
+		chResp := &responses.Channel{}
+		chResp.Build(channel)
+
 		return &responses.Response{
 			StatusCode: http.StatusOK,
-			Body:       channel,
+			Body:       chResp,
 		}
 	}
 }
 
 // CreateChannel creates a new channel.
-func CreateChannel(payload *payloads.CreateChannel) ControllerFunc {
+func (ctrl *Channels) CreateChannel(payload *payloads.CreateChannel) ControllerFunc {
 	return func() *responses.Response {
 		return &responses.Response{
 			StatusCode: http.StatusCreated,

remote/controllers/controllers.go

@@ -1,11 +1,28 @@
 package controllers
 
 import (
+	"log"
+
+	"github.com/FoxComm/highlander/remote/db"
+	"github.com/FoxComm/highlander/remote/utils"
 	"github.com/labstack/echo"
 )
 
 // Start initializes all the controllers and routes.
 func Start() {
+	config, err := utils.NewConfig()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	phxDB, err := db.NewPhoenixConnection(config)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	defer phxDB.Close()
+	channelsCtrl := NewChannels(phxDB)
+
 	e := echo.New()
 
 	e.Use(func(h echo.HandlerFunc) echo.HandlerFunc {
@@ -18,7 +35,7 @@ func Start() {
 	e.GET("/v1/public/channels/:id", func(c echo.Context) error {
 		fc := c.(*FoxContext)
 		id := fc.ParamInt("id")
-		return fc.Run(GetChannel(id))
+		return fc.Run(channelsCtrl.GetChannel(id))
 	})
 
 	e.Start(":9898")

remote/glide.lock

@@ -2,3 +2,5 @@ package: github.com/FoxComm/highlander/remote
 import:
   - package: github.com/labstack/echo
   - package: github.com/lib/pq
+  - package: github.com/jinzhu/gorm
+  - package: github.com/jinzhu/inflection

remote/glide.yaml

@@ -1,6 +1,10 @@
 package phoenix
 
-import "time"
+import (
+	"errors"
+	"fmt"
+	"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).
@@ -11,3 +15,50 @@ type Channel struct {
 	CreatedAt        time.Time
 	UpdatedAt        time.Time
 }
+
+func NewChannel(name string, purchaseLocation int) *Channel {
+	return &Channel{
+		ID:               0,
+		Name:             name,
+		PurchaseLocation: purchaseLocation,
+		CreatedAt:        time.Now().UTC(),
+		UpdatedAt:        time.Now().UTC(),
+	}
+}
+
+func (c Channel) Table() string {
+	return "channels"
+}
+
+func (c Channel) Fields() map[string]interface{} {
+	return map[string]interface{}{
+		"name":              c.Name,
+		"purchase_location": c.PurchaseLocation,
+		"created_at":        c.CreatedAt,
+		"updated_at":        c.UpdatedAt,
+	}
+}
+
+func (c Channel) FieldRefs() []interface{} {
+	return []interface{}{
+		&c.ID,
+		&c.Name,
+		&c.PurchaseLocation,
+		&c.CreatedAt,
+		&c.UpdatedAt,
+	}
+}
+
+func (c Channel) Validate() error {
+	if c.Name == "" {
+		return errors.New("Channel name must not be empty")
+	} else if c.PurchaseLocation != PurchaseOnFox && c.PurchaseLocation != PurchaseOffFox {
+		return fmt.Errorf(
+			"Expected PurchaseLocation to be %d or %d, got %d",
+			PurchaseOnFox,
+			PurchaseOffFox,
+			c.PurchaseLocation)
+	}
+
+	return nil
+}

remote/models/phoenix/channel.go

@@ -1,6 +1,10 @@
 package payloads
 
-import "github.com/FoxComm/highlander/remote/models/phoenix"
+import (
+	"time"
+
+	"github.com/FoxComm/highlander/remote/models/phoenix"
+)
 
 // CreateChannel is the structure of payload needed to create a channel.
 type CreateChannel struct {
@@ -11,7 +15,11 @@ type CreateChannel struct {
 
 // PhoenixModel returns the phoenix model for this payload.
 func (c CreateChannel) PhoenixModel() *phoenix.Channel {
-	model := &phoenix.Channel{Name: c.Name}
+	model := &phoenix.Channel{
+		Name:      c.Name,
+		CreatedAt: time.Now().UTC(),
+		UpdatedAt: time.Now().UTC(),
+	}
 
 	if c.PurchaseOnFox {
 		model.PurchaseLocation = phoenix.PurchaseOnFox

remote/payloads/channel_payloads.go

@@ -0,0 +1,28 @@
+package responses
+
+import (
+	"time"
+
+	"github.com/FoxComm/highlander/remote/models/phoenix"
+)
+
+type Channel struct {
+	ID            int       `json:"id"`
+	Name          string    `json:"name"`
+	PurchaseOnFox bool      `json:"purchaseOnFox"`
+	CreatedAt     time.Time `json:"createdAt"`
+	UpdatedAt     time.Time `json:"updatedAt"`
+}
+
+func (c *Channel) Build(phxChannel *phoenix.Channel) {
+	c.ID = phxChannel.ID
+	c.Name = phxChannel.Name
+	c.CreatedAt = phxChannel.CreatedAt
+	c.UpdatedAt = phxChannel.UpdatedAt
+
+	if phxChannel.PurchaseLocation == phoenix.PurchaseOnFox {
+		c.PurchaseOnFox = true
+	} else {
+		c.PurchaseOnFox = false
+	}
+}

remote/responses/channel.go

@@ -6,3 +6,11 @@ type Response struct {
 	Body       interface{}
 	Errs       []error
 }
+
+func NewErrorResponse(err error) *Response {
+	if err.Error() == "record not found" {
+		return nil
+	}
+
+	return nil
+}

remote/responses/response.go

@@ -0,0 +1,26 @@
+package services
+
+import (
+	"fmt"
+
+	"github.com/FoxComm/highlander/remote/utils"
+	"github.com/jinzhu/gorm"
+	_ "github.com/lib/pq"
+)
+
+func NewPhoenixConnection(config *utils.Config) (*gorm.DB, error) {
+	connStr := fmt.Sprintf(
+		"host=%s user=%s password=%s dbname=%s sslmode=%s",
+		config.PhxDatabaseHost,
+		config.PhxDatabaseUser,
+		config.PhxDatabasePassword,
+		config.PhxDatabaseName,
+		config.PhxDatabaseSSL)
+
+	phxDB, err := gorm.Open("postgres", connStr)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to connect to Phoenix DB with error %s", err.Error())
+	}
+
+	return phxDB, nil
+}

remote/services/connection.go

@@ -0,0 +1 @@
+package services

remote/services/errors.go

@@ -0,0 +1,22 @@
+package services
+
+import (
+	"fmt"
+
+	"github.com/FoxComm/highlander/remote/models/phoenix"
+	"github.com/jinzhu/gorm"
+)
+
+func FindChannelByID(phxDB *gorm.DB, id int, phxChannel *phoenix.Channel) error {
+	err := phxDB.First(phxChannel, id).Error
+
+	if err != nil && err.Error() == "record not found" {
+		return fmt.Errorf("Channel with ID %d not found", id)
+	}
+
+	return err
+}
+
+func InsertChannel(phxDB *gorm.DB, phxChannel *phoenix.Channel) error {
+	return phxDB.Create(phxChannel).Error
+}

remote/services/queries.go

@@ -0,0 +1,56 @@
+package utils
+
+import (
+	"fmt"
+	"os"
+)
+
+const (
+	errEnvVarNotFound = "%s not found in the environment"
+
+	phoenixDatabaseName     = "PHX_DATABASE_NAME"
+	phoenixDatabaseHost     = "PHX_DATABASE_HOST"
+	phoenixDatabaseUser     = "PHX_DATABASE_USER"
+	phoenixDatabasePassword = "PHX_DATABASE_PASSWORD"
+	phoenixDatabaseSSL      = "PHX_DATABASE_SSL"
+
+	port = "PORT"
+)
+
+type Config struct {
+	PhxDatabaseName     string
+	PhxDatabaseHost     string
+	PhxDatabaseUser     string
+	PhxDatabasePassword string
+	PhxDatabaseSSL      string
+
+	Port string
+}
+
+func NewConfig() (*Config, error) {
+	config := &Config{}
+	var err error
+
+	config.PhxDatabaseName, err = parseEnvVar(phoenixDatabaseName, nil)
+	config.PhxDatabaseHost, err = parseEnvVar(phoenixDatabaseHost, err)
+	config.PhxDatabaseUser, err = parseEnvVar(phoenixDatabaseUser, err)
+	config.PhxDatabaseSSL, err = parseEnvVar(phoenixDatabaseSSL, err)
+	config.PhxDatabasePassword = os.Getenv(phoenixDatabasePassword)
+
+	config.Port, err = parseEnvVar(port, err)
+
+	return config, err
+}
+
+func parseEnvVar(varName string, err error) (string, error) {
+	if err != nil {
+		return "", err
+	}
+
+	str := os.Getenv(varName)
+	if str == "" {
+		return "", fmt.Errorf(errEnvVarNotFound, varName)
+	}
+
+	return str, nil
+}