import code gen and generated files

sam/channel.go

@@ -0,0 +1,27 @@
+package sam
+
+import (
+	"github.com/pkg/errors"
+)
+
+func (c *Channel) Edit(r *ChannelEditRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.edit")
+}
+func (c *Channel) Remove(r *ChannelRemoveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.remove")
+}
+func (c *Channel) Read(r *ChannelReadRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.read")
+}
+func (c *Channel) Search(r *ChannelSearchRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.search")
+}
+func (c *Channel) Archive(r *ChannelArchiveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.archive")
+}
+func (c *Channel) Move(r *ChannelMoveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.move")
+}
+func (c *Channel) Merge(r *ChannelMergeRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Channel.merge")
+}

sam/channel.handlers.go

@@ -0,0 +1,36 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+func (ch *ChannelHandlers) Edit(w http.ResponseWriter, r *http.Request) {
+	params := ChannelEditRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Edit(params) })
+}
+func (ch *ChannelHandlers) Remove(w http.ResponseWriter, r *http.Request) {
+	params := ChannelRemoveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Remove(params) })
+}
+func (ch *ChannelHandlers) Read(w http.ResponseWriter, r *http.Request) {
+	params := ChannelReadRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Read(params) })
+}
+func (ch *ChannelHandlers) Search(w http.ResponseWriter, r *http.Request) {
+	params := ChannelSearchRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Search(params) })
+}
+func (ch *ChannelHandlers) Archive(w http.ResponseWriter, r *http.Request) {
+	params := ChannelArchiveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Archive(params) })
+}
+func (ch *ChannelHandlers) Move(w http.ResponseWriter, r *http.Request) {
+	params := ChannelMoveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Move(params) })
+}
+func (ch *ChannelHandlers) Merge(w http.ResponseWriter, r *http.Request) {
+	params := ChannelMergeRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Merge(params) })
+}

sam/channel.interfaces.go

@@ -0,0 +1,42 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type ChannelHandlers struct {
+	*Channel
+}
+
+func (ChannelHandlers) new() *ChannelHandlers {
+	return &ChannelHandlers{
+		Channel{}.new(),
+	}
+}
+
+// Internal API interface
+type ChannelAPI interface {
+	Edit(*ChannelEditRequest) (interface{}, error)
+	Remove(*ChannelRemoveRequest) (interface{}, error)
+	Read(*ChannelReadRequest) (interface{}, error)
+	Search(*ChannelSearchRequest) (interface{}, error)
+	Archive(*ChannelArchiveRequest) (interface{}, error)
+	Move(*ChannelMoveRequest) (interface{}, error)
+	Merge(*ChannelMergeRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type ChannelHandlersAPI interface {
+	Edit(http.ResponseWriter, *http.Request)
+	Remove(http.ResponseWriter, *http.Request)
+	Read(http.ResponseWriter, *http.Request)
+	Search(http.ResponseWriter, *http.Request)
+	Archive(http.ResponseWriter, *http.Request)
+	Move(http.ResponseWriter, *http.Request)
+	Merge(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ ChannelHandlersAPI = &ChannelHandlers{}
+var _ ChannelAPI = &Channel{}

sam/channel.request.go

@@ -0,0 +1,205 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// Channel edit request parameters
+type ChannelEditRequest struct {
+	id    uint64
+	name  string
+	topic string
+}
+
+func (ChannelEditRequest) new() *ChannelEditRequest {
+	return &ChannelEditRequest{}
+}
+
+func (c *ChannelEditRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.id = parseUInt64(post["id"])
+
+	c.name = post["name"]
+
+	c.topic = post["topic"]
+	return errors.New("Not implemented: ChannelEditRequest.Fill")
+}
+
+var _ RequestFiller = ChannelEditRequest{}.new()
+
+// Channel remove request parameters
+type ChannelRemoveRequest struct {
+	id uint64
+}
+
+func (ChannelRemoveRequest) new() *ChannelRemoveRequest {
+	return &ChannelRemoveRequest{}
+}
+
+func (c *ChannelRemoveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: ChannelRemoveRequest.Fill")
+}
+
+var _ RequestFiller = ChannelRemoveRequest{}.new()
+
+// Channel read request parameters
+type ChannelReadRequest struct {
+	id uint64
+}
+
+func (ChannelReadRequest) new() *ChannelReadRequest {
+	return &ChannelReadRequest{}
+}
+
+func (c *ChannelReadRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: ChannelReadRequest.Fill")
+}
+
+var _ RequestFiller = ChannelReadRequest{}.new()
+
+// Channel search request parameters
+type ChannelSearchRequest struct {
+	query string
+}
+
+func (ChannelSearchRequest) new() *ChannelSearchRequest {
+	return &ChannelSearchRequest{}
+}
+
+func (c *ChannelSearchRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.query = get["query"]
+	return errors.New("Not implemented: ChannelSearchRequest.Fill")
+}
+
+var _ RequestFiller = ChannelSearchRequest{}.new()
+
+// Channel archive request parameters
+type ChannelArchiveRequest struct {
+	id uint64
+}
+
+func (ChannelArchiveRequest) new() *ChannelArchiveRequest {
+	return &ChannelArchiveRequest{}
+}
+
+func (c *ChannelArchiveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.id = parseUInt64(post["id"])
+	return errors.New("Not implemented: ChannelArchiveRequest.Fill")
+}
+
+var _ RequestFiller = ChannelArchiveRequest{}.new()
+
+// Channel move request parameters
+type ChannelMoveRequest struct {
+	id uint64
+}
+
+func (ChannelMoveRequest) new() *ChannelMoveRequest {
+	return &ChannelMoveRequest{}
+}
+
+func (c *ChannelMoveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.id = parseUInt64(post["id"])
+	return errors.New("Not implemented: ChannelMoveRequest.Fill")
+}
+
+var _ RequestFiller = ChannelMoveRequest{}.new()
+
+// Channel merge request parameters
+type ChannelMergeRequest struct {
+	destination uint64
+	source      uint64
+}
+
+func (ChannelMergeRequest) new() *ChannelMergeRequest {
+	return &ChannelMergeRequest{}
+}
+
+func (c *ChannelMergeRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	c.destination = parseUInt64(post["destination"])
+
+	c.source = parseUInt64(post["source"])
+	return errors.New("Not implemented: ChannelMergeRequest.Fill")
+}
+
+var _ RequestFiller = ChannelMergeRequest{}.new()

sam/channel.structs.go

@@ -0,0 +1,37 @@
+package sam
+
+// Channels
+type Channel struct {
+	ID    uint64
+	Name  string
+	Topic string
+}
+
+func (Channel) new() *Channel {
+	return &Channel{}
+}
+
+func (c *Channel) GetID() uint64 {
+	return c.ID
+}
+
+func (c *Channel) SetID(value uint64) *Channel {
+	c.ID = value
+	return c
+}
+func (c *Channel) GetName() string {
+	return c.Name
+}
+
+func (c *Channel) SetName(value string) *Channel {
+	c.Name = value
+	return c
+}
+func (c *Channel) GetTopic() string {
+	return c.Topic
+}
+
+func (c *Channel) SetTopic(value string) *Channel {
+	c.Topic = value
+	return c
+}

sam/message.go

@@ -0,0 +1,27 @@
+package sam
+
+import (
+	"github.com/pkg/errors"
+)
+
+func (m *Message) Edit(r *MessageEditRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.edit")
+}
+func (m *Message) Attach(r *MessageAttachRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.attach")
+}
+func (m *Message) Remove(r *MessageRemoveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.remove")
+}
+func (m *Message) Read(r *MessageReadRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.read")
+}
+func (m *Message) Search(r *MessageSearchRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.search")
+}
+func (m *Message) Pin(r *MessagePinRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.pin")
+}
+func (m *Message) Flag(r *MessageFlagRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Message.flag")
+}

sam/message.handlers.go

@@ -0,0 +1,36 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+func (mh *MessageHandlers) Edit(w http.ResponseWriter, r *http.Request) {
+	params := MessageEditRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Edit(params) })
+}
+func (mh *MessageHandlers) Attach(w http.ResponseWriter, r *http.Request) {
+	params := MessageAttachRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Attach(params) })
+}
+func (mh *MessageHandlers) Remove(w http.ResponseWriter, r *http.Request) {
+	params := MessageRemoveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Remove(params) })
+}
+func (mh *MessageHandlers) Read(w http.ResponseWriter, r *http.Request) {
+	params := MessageReadRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Read(params) })
+}
+func (mh *MessageHandlers) Search(w http.ResponseWriter, r *http.Request) {
+	params := MessageSearchRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Search(params) })
+}
+func (mh *MessageHandlers) Pin(w http.ResponseWriter, r *http.Request) {
+	params := MessagePinRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Pin(params) })
+}
+func (mh *MessageHandlers) Flag(w http.ResponseWriter, r *http.Request) {
+	params := MessageFlagRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Flag(params) })
+}

sam/message.interfaces.go

@@ -0,0 +1,42 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type MessageHandlers struct {
+	*Message
+}
+
+func (MessageHandlers) new() *MessageHandlers {
+	return &MessageHandlers{
+		Message{}.new(),
+	}
+}
+
+// Internal API interface
+type MessageAPI interface {
+	Edit(*MessageEditRequest) (interface{}, error)
+	Attach(*MessageAttachRequest) (interface{}, error)
+	Remove(*MessageRemoveRequest) (interface{}, error)
+	Read(*MessageReadRequest) (interface{}, error)
+	Search(*MessageSearchRequest) (interface{}, error)
+	Pin(*MessagePinRequest) (interface{}, error)
+	Flag(*MessageFlagRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type MessageHandlersAPI interface {
+	Edit(http.ResponseWriter, *http.Request)
+	Attach(http.ResponseWriter, *http.Request)
+	Remove(http.ResponseWriter, *http.Request)
+	Read(http.ResponseWriter, *http.Request)
+	Search(http.ResponseWriter, *http.Request)
+	Pin(http.ResponseWriter, *http.Request)
+	Flag(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ MessageHandlersAPI = &MessageHandlers{}
+var _ MessageAPI = &Message{}

sam/message.request.go

@@ -0,0 +1,202 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// Message edit request parameters
+type MessageEditRequest struct {
+	id         uint64
+	channel_id uint64
+	contents   string
+}
+
+func (MessageEditRequest) new() *MessageEditRequest {
+	return &MessageEditRequest{}
+}
+
+func (m *MessageEditRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	m.id = parseUInt64(post["id"])
+
+	m.channel_id = parseUInt64(post["channel_id"])
+
+	m.contents = post["contents"]
+	return errors.New("Not implemented: MessageEditRequest.Fill")
+}
+
+var _ RequestFiller = MessageEditRequest{}.new()
+
+// Message attach request parameters
+type MessageAttachRequest struct {
+}
+
+func (MessageAttachRequest) new() *MessageAttachRequest {
+	return &MessageAttachRequest{}
+}
+
+func (m *MessageAttachRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+	return errors.New("Not implemented: MessageAttachRequest.Fill")
+}
+
+var _ RequestFiller = MessageAttachRequest{}.new()
+
+// Message remove request parameters
+type MessageRemoveRequest struct {
+	id uint64
+}
+
+func (MessageRemoveRequest) new() *MessageRemoveRequest {
+	return &MessageRemoveRequest{}
+}
+
+func (m *MessageRemoveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	m.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: MessageRemoveRequest.Fill")
+}
+
+var _ RequestFiller = MessageRemoveRequest{}.new()
+
+// Message read request parameters
+type MessageReadRequest struct {
+	channel_id uint64
+}
+
+func (MessageReadRequest) new() *MessageReadRequest {
+	return &MessageReadRequest{}
+}
+
+func (m *MessageReadRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	m.channel_id = parseUInt64(post["channel_id"])
+	return errors.New("Not implemented: MessageReadRequest.Fill")
+}
+
+var _ RequestFiller = MessageReadRequest{}.new()
+
+// Message search request parameters
+type MessageSearchRequest struct {
+	query        string
+	message_type string
+}
+
+func (MessageSearchRequest) new() *MessageSearchRequest {
+	return &MessageSearchRequest{}
+}
+
+func (m *MessageSearchRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	m.query = get["query"]
+
+	m.message_type = get["message_type"]
+	return errors.New("Not implemented: MessageSearchRequest.Fill")
+}
+
+var _ RequestFiller = MessageSearchRequest{}.new()
+
+// Message pin request parameters
+type MessagePinRequest struct {
+	id uint64
+}
+
+func (MessagePinRequest) new() *MessagePinRequest {
+	return &MessagePinRequest{}
+}
+
+func (m *MessagePinRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	m.id = parseUInt64(post["id"])
+	return errors.New("Not implemented: MessagePinRequest.Fill")
+}
+
+var _ RequestFiller = MessagePinRequest{}.new()
+
+// Message flag request parameters
+type MessageFlagRequest struct {
+	id uint64
+}
+
+func (MessageFlagRequest) new() *MessageFlagRequest {
+	return &MessageFlagRequest{}
+}
+
+func (m *MessageFlagRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	m.id = parseUInt64(post["id"])
+	return errors.New("Not implemented: MessageFlagRequest.Fill")
+}
+
+var _ RequestFiller = MessageFlagRequest{}.new()

sam/message.structs.go

@@ -0,0 +1,91 @@
+package sam
+
+// Messages
+type Message struct {
+	Service    string
+	Channel    string
+	UserName   string
+	UserID     uint64
+	User       *User
+	UserAvatar string
+	Message    string
+	MessageID  string
+	Type       MessageType
+}
+
+func (Message) new() *Message {
+	return &Message{}
+}
+
+func (m *Message) GetService() string {
+	return m.Service
+}
+
+func (m *Message) SetService(value string) *Message {
+	m.Service = value
+	return m
+}
+func (m *Message) GetChannel() string {
+	return m.Channel
+}
+
+func (m *Message) SetChannel(value string) *Message {
+	m.Channel = value
+	return m
+}
+func (m *Message) GetUserName() string {
+	return m.UserName
+}
+
+func (m *Message) SetUserName(value string) *Message {
+	m.UserName = value
+	return m
+}
+func (m *Message) GetUserID() uint64 {
+	return m.UserID
+}
+
+func (m *Message) SetUserID(value uint64) *Message {
+	m.UserID = value
+	return m
+}
+func (m *Message) GetUser() *User {
+	return m.User
+}
+
+func (m *Message) SetUser(value *User) *Message {
+	m.User = value
+	return m
+}
+func (m *Message) GetUserAvatar() string {
+	return m.UserAvatar
+}
+
+func (m *Message) SetUserAvatar(value string) *Message {
+	m.UserAvatar = value
+	return m
+}
+func (m *Message) GetMessage() string {
+	return m.Message
+}
+
+func (m *Message) SetMessage(value string) *Message {
+	m.Message = value
+	return m
+}
+func (m *Message) GetMessageID() string {
+	return m.MessageID
+}
+
+func (m *Message) SetMessageID(value string) *Message {
+	m.MessageID = value
+	return m
+}
+func (m *Message) GetType() MessageType {
+	return m.Type
+}
+
+func (m *Message) SetType(value MessageType) *Message {
+	m.Type = value
+	return m
+}

sam/misc.go

@@ -0,0 +1,22 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// RequestFiller is an interface for typed request parameters
+type RequestFiller interface {
+	Fill(r *http.Request) error
+}
+
+// MessageType is a type used to determine the CRUD state of a message.
+type MessageType string
+
+const (
+	// MessageTypeCreate is the message type for message creation.
+	MessageTypeCreate MessageType = "create"
+	// MessageTypeUpdate is the message type for message updates.
+	MessageTypeUpdate = "update"
+	// MessageTypeDelete is the message type for message deletion.
+	MessageTypeDelete = "delete"
+)

sam/organisation.go

@@ -0,0 +1,21 @@
+package sam
+
+import (
+	"github.com/pkg/errors"
+)
+
+func (o *Organisation) Edit(r *OrganisationEditRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Organisation.edit")
+}
+func (o *Organisation) Remove(r *OrganisationRemoveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Organisation.remove")
+}
+func (o *Organisation) Read(r *OrganisationReadRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Organisation.read")
+}
+func (o *Organisation) Search(r *OrganisationSearchRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Organisation.search")
+}
+func (o *Organisation) Archive(r *OrganisationArchiveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Organisation.archive")
+}

sam/organisation.handlers.go

@@ -0,0 +1,28 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+func (oh *OrganisationHandlers) Edit(w http.ResponseWriter, r *http.Request) {
+	params := OrganisationEditRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Edit(params) })
+}
+func (oh *OrganisationHandlers) Remove(w http.ResponseWriter, r *http.Request) {
+	params := OrganisationRemoveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Remove(params) })
+}
+func (oh *OrganisationHandlers) Read(w http.ResponseWriter, r *http.Request) {
+	params := OrganisationReadRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Read(params) })
+}
+func (oh *OrganisationHandlers) Search(w http.ResponseWriter, r *http.Request) {
+	params := OrganisationSearchRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Search(params) })
+}
+func (oh *OrganisationHandlers) Archive(w http.ResponseWriter, r *http.Request) {
+	params := OrganisationArchiveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Archive(params) })
+}

sam/organisation.interfaces.go

@@ -0,0 +1,38 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type OrganisationHandlers struct {
+	*Organisation
+}
+
+func (OrganisationHandlers) new() *OrganisationHandlers {
+	return &OrganisationHandlers{
+		Organisation{}.new(),
+	}
+}
+
+// Internal API interface
+type OrganisationAPI interface {
+	Edit(*OrganisationEditRequest) (interface{}, error)
+	Remove(*OrganisationRemoveRequest) (interface{}, error)
+	Read(*OrganisationReadRequest) (interface{}, error)
+	Search(*OrganisationSearchRequest) (interface{}, error)
+	Archive(*OrganisationArchiveRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type OrganisationHandlersAPI interface {
+	Edit(http.ResponseWriter, *http.Request)
+	Remove(http.ResponseWriter, *http.Request)
+	Read(http.ResponseWriter, *http.Request)
+	Search(http.ResponseWriter, *http.Request)
+	Archive(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ OrganisationHandlersAPI = &OrganisationHandlers{}
+var _ OrganisationAPI = &Organisation{}

sam/organisation.request.go

@@ -0,0 +1,145 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// Organisation edit request parameters
+type OrganisationEditRequest struct {
+	id   uint64
+	name string
+}
+
+func (OrganisationEditRequest) new() *OrganisationEditRequest {
+	return &OrganisationEditRequest{}
+}
+
+func (o *OrganisationEditRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	o.id = parseUInt64(post["id"])
+
+	o.name = post["name"]
+	return errors.New("Not implemented: OrganisationEditRequest.Fill")
+}
+
+var _ RequestFiller = OrganisationEditRequest{}.new()
+
+// Organisation remove request parameters
+type OrganisationRemoveRequest struct {
+	id uint64
+}
+
+func (OrganisationRemoveRequest) new() *OrganisationRemoveRequest {
+	return &OrganisationRemoveRequest{}
+}
+
+func (o *OrganisationRemoveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	o.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: OrganisationRemoveRequest.Fill")
+}
+
+var _ RequestFiller = OrganisationRemoveRequest{}.new()
+
+// Organisation read request parameters
+type OrganisationReadRequest struct {
+	id uint64
+}
+
+func (OrganisationReadRequest) new() *OrganisationReadRequest {
+	return &OrganisationReadRequest{}
+}
+
+func (o *OrganisationReadRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	o.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: OrganisationReadRequest.Fill")
+}
+
+var _ RequestFiller = OrganisationReadRequest{}.new()
+
+// Organisation search request parameters
+type OrganisationSearchRequest struct {
+	query string
+}
+
+func (OrganisationSearchRequest) new() *OrganisationSearchRequest {
+	return &OrganisationSearchRequest{}
+}
+
+func (o *OrganisationSearchRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	o.query = get["query"]
+	return errors.New("Not implemented: OrganisationSearchRequest.Fill")
+}
+
+var _ RequestFiller = OrganisationSearchRequest{}.new()
+
+// Organisation archive request parameters
+type OrganisationArchiveRequest struct {
+	id uint64
+}
+
+func (OrganisationArchiveRequest) new() *OrganisationArchiveRequest {
+	return &OrganisationArchiveRequest{}
+}
+
+func (o *OrganisationArchiveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	o.id = parseUInt64(post["id"])
+	return errors.New("Not implemented: OrganisationArchiveRequest.Fill")
+}
+
+var _ RequestFiller = OrganisationArchiveRequest{}.new()

sam/organisation.structs.go

@@ -0,0 +1,28 @@
+package sam
+
+// Organisations
+type Organisation struct {
+	ID   uint64
+	Name string
+}
+
+func (Organisation) new() *Organisation {
+	return &Organisation{}
+}
+
+func (o *Organisation) GetID() uint64 {
+	return o.ID
+}
+
+func (o *Organisation) SetID(value uint64) *Organisation {
+	o.ID = value
+	return o
+}
+func (o *Organisation) GetName() string {
+	return o.Name
+}
+
+func (o *Organisation) SetName(value string) *Organisation {
+	o.Name = value
+	return o
+}

sam/routes.go

@@ -0,0 +1,54 @@
+package sam
+
+import (
+	"github.com/go-chi/chi"
+)
+
+func MountRoutes(r chi.Router) {
+	organisation := OrganisationHandlers{}.new()
+	team := TeamHandlers{}.new()
+	channel := ChannelHandlers{}.new()
+	message := MessageHandlers{}.new()
+	user := UserHandlers{}.new()
+	websocket := WebsocketHandlers{}.new()
+	r.Route("/organisation", func(r chi.Router) {
+		r.Post("/edit", organisation.Edit)
+		r.Delete("/remove", organisation.Remove)
+		r.Get("/read", organisation.Read)
+		r.Get("/search", organisation.Search)
+		r.Post("/archive", organisation.Archive)
+	})
+	r.Route("/team", func(r chi.Router) {
+		r.Post("/edit", team.Edit)
+		r.Delete("/remove", team.Remove)
+		r.Get("/read", team.Read)
+		r.Get("/search", team.Search)
+		r.Post("/archive", team.Archive)
+		r.Post("/move", team.Move)
+	})
+	r.Route("/channel", func(r chi.Router) {
+		r.Post("/edit", channel.Edit)
+		r.Delete("/remove", channel.Remove)
+		r.Get("/read", channel.Read)
+		r.Get("/search", channel.Search)
+		r.Post("/archive", channel.Archive)
+		r.Post("/move", channel.Move)
+		r.Post("/merge", channel.Merge)
+	})
+	r.Route("/message", func(r chi.Router) {
+		r.Post("/edit", message.Edit)
+		r.Put("/attach", message.Attach)
+		r.Delete("/remove", message.Remove)
+		r.Get("/read", message.Read)
+		r.Get("/search", message.Search)
+		r.Post("/pin", message.Pin)
+		r.Post("/flag", message.Flag)
+	})
+	r.Route("/user", func(r chi.Router) {
+		r.Post("/login", user.Login)
+		r.Get("/search", user.Search)
+	})
+	r.Route("/websocket", func(r chi.Router) {
+		r.Get("/client", websocket.Client)
+	})
+}

sam/team.go

@@ -0,0 +1,24 @@
+package sam
+
+import (
+	"github.com/pkg/errors"
+)
+
+func (t *Team) Edit(r *TeamEditRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Team.edit")
+}
+func (t *Team) Remove(r *TeamRemoveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Team.remove")
+}
+func (t *Team) Read(r *TeamReadRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Team.read")
+}
+func (t *Team) Search(r *TeamSearchRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Team.search")
+}
+func (t *Team) Archive(r *TeamArchiveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Team.archive")
+}
+func (t *Team) Move(r *TeamMoveRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Team.move")
+}

sam/team.handlers.go

@@ -0,0 +1,32 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+func (th *TeamHandlers) Edit(w http.ResponseWriter, r *http.Request) {
+	params := TeamEditRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Edit(params) })
+}
+func (th *TeamHandlers) Remove(w http.ResponseWriter, r *http.Request) {
+	params := TeamRemoveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Remove(params) })
+}
+func (th *TeamHandlers) Read(w http.ResponseWriter, r *http.Request) {
+	params := TeamReadRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Read(params) })
+}
+func (th *TeamHandlers) Search(w http.ResponseWriter, r *http.Request) {
+	params := TeamSearchRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Search(params) })
+}
+func (th *TeamHandlers) Archive(w http.ResponseWriter, r *http.Request) {
+	params := TeamArchiveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Archive(params) })
+}
+func (th *TeamHandlers) Move(w http.ResponseWriter, r *http.Request) {
+	params := TeamMoveRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Move(params) })
+}

sam/team.interfaces.go

@@ -0,0 +1,40 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type TeamHandlers struct {
+	*Team
+}
+
+func (TeamHandlers) new() *TeamHandlers {
+	return &TeamHandlers{
+		Team{}.new(),
+	}
+}
+
+// Internal API interface
+type TeamAPI interface {
+	Edit(*TeamEditRequest) (interface{}, error)
+	Remove(*TeamRemoveRequest) (interface{}, error)
+	Read(*TeamReadRequest) (interface{}, error)
+	Search(*TeamSearchRequest) (interface{}, error)
+	Archive(*TeamArchiveRequest) (interface{}, error)
+	Move(*TeamMoveRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type TeamHandlersAPI interface {
+	Edit(http.ResponseWriter, *http.Request)
+	Remove(http.ResponseWriter, *http.Request)
+	Read(http.ResponseWriter, *http.Request)
+	Search(http.ResponseWriter, *http.Request)
+	Archive(http.ResponseWriter, *http.Request)
+	Move(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ TeamHandlersAPI = &TeamHandlers{}
+var _ TeamAPI = &Team{}

sam/team.request.go

@@ -0,0 +1,176 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// Team edit request parameters
+type TeamEditRequest struct {
+	id      uint64
+	name    string
+	members []uint64
+}
+
+func (TeamEditRequest) new() *TeamEditRequest {
+	return &TeamEditRequest{}
+}
+
+func (t *TeamEditRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	t.id = parseUInt64(post["id"])
+
+	t.name = post["name"]
+	return errors.New("Not implemented: TeamEditRequest.Fill")
+}
+
+var _ RequestFiller = TeamEditRequest{}.new()
+
+// Team remove request parameters
+type TeamRemoveRequest struct {
+	id uint64
+}
+
+func (TeamRemoveRequest) new() *TeamRemoveRequest {
+	return &TeamRemoveRequest{}
+}
+
+func (t *TeamRemoveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	t.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: TeamRemoveRequest.Fill")
+}
+
+var _ RequestFiller = TeamRemoveRequest{}.new()
+
+// Team read request parameters
+type TeamReadRequest struct {
+	id uint64
+}
+
+func (TeamReadRequest) new() *TeamReadRequest {
+	return &TeamReadRequest{}
+}
+
+func (t *TeamReadRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	t.id = parseUInt64(get["id"])
+	return errors.New("Not implemented: TeamReadRequest.Fill")
+}
+
+var _ RequestFiller = TeamReadRequest{}.new()
+
+// Team search request parameters
+type TeamSearchRequest struct {
+	query string
+}
+
+func (TeamSearchRequest) new() *TeamSearchRequest {
+	return &TeamSearchRequest{}
+}
+
+func (t *TeamSearchRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	t.query = get["query"]
+	return errors.New("Not implemented: TeamSearchRequest.Fill")
+}
+
+var _ RequestFiller = TeamSearchRequest{}.new()
+
+// Team archive request parameters
+type TeamArchiveRequest struct {
+	id uint64
+}
+
+func (TeamArchiveRequest) new() *TeamArchiveRequest {
+	return &TeamArchiveRequest{}
+}
+
+func (t *TeamArchiveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	t.id = parseUInt64(post["id"])
+	return errors.New("Not implemented: TeamArchiveRequest.Fill")
+}
+
+var _ RequestFiller = TeamArchiveRequest{}.new()
+
+// Team move request parameters
+type TeamMoveRequest struct {
+	id              uint64
+	organisation_id uint64
+}
+
+func (TeamMoveRequest) new() *TeamMoveRequest {
+	return &TeamMoveRequest{}
+}
+
+func (t *TeamMoveRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	t.id = parseUInt64(post["id"])
+
+	t.organisation_id = parseUInt64(post["organisation_id"])
+	return errors.New("Not implemented: TeamMoveRequest.Fill")
+}
+
+var _ RequestFiller = TeamMoveRequest{}.new()

sam/team.structs.go

@@ -0,0 +1,46 @@
+package sam
+
+// Teams
+type Team struct {
+	ID        uint64
+	Name      string
+	MemberIDs []uint64 `json:"-"`
+	Members   []User   `json:",omitempty"`
+}
+
+func (Team) new() *Team {
+	return &Team{}
+}
+
+func (t *Team) GetID() uint64 {
+	return t.ID
+}
+
+func (t *Team) SetID(value uint64) *Team {
+	t.ID = value
+	return t
+}
+func (t *Team) GetName() string {
+	return t.Name
+}
+
+func (t *Team) SetName(value string) *Team {
+	t.Name = value
+	return t
+}
+func (t *Team) GetMemberIDs() []uint64 {
+	return t.MemberIDs
+}
+
+func (t *Team) SetMemberIDs(value []uint64) *Team {
+	t.MemberIDs = value
+	return t
+}
+func (t *Team) GetMembers() []User {
+	return t.Members
+}
+
+func (t *Team) SetMembers(value []User) *Team {
+	t.Members = value
+	return t
+}

sam/templates/http_.tpl

@@ -0,0 +1,11 @@
+package {package}
+
+import (
+	"github.com/pkg/errors"
+)
+
+{foreach $calls as $call}
+func ({self} *{name}) {call.name|ucfirst}(r *{name}{call.name|ucfirst}Request) (interface{}, error) {
+	return nil, errors.New("Not implemented: {name}.{call.name}")
+}
+{/foreach}

sam/templates/http_handlers.tpl

@@ -0,0 +1,14 @@
+package {package}
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+{foreach $calls as $call}
+func ({self}h *{name}Handlers) {call.name|ucfirst}(w http.ResponseWriter, r *http.Request) {
+	params := {name}{call.name|ucfirst}Request{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return {self}h.{name}.{call.name|ucfirst}(params) })
+}
+{/foreach}

sam/templates/http_interfaces.tpl

@@ -0,0 +1,34 @@
+package {package}
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type {name}Handlers struct {
+	*{name}
+}
+
+func ({name}Handlers) new() *{name}Handlers {
+	return &{name}Handlers{
+		{name}{}.new(),
+	}
+}
+
+// Internal API interface
+type {name}API interface {
+{foreach $calls as $call}
+	{call.name|ucfirst}(*{name}{call.name|ucfirst}Request) (interface{}, error)
+{/foreach}
+}
+
+// HTTP API interface
+type {name}HandlersAPI interface {
+{foreach $calls as $call}
+	{call.name|ucfirst}(http.ResponseWriter, *http.Request)
+{/foreach}
+}
+
+// Compile time check to see if we implement the interfaces
+var _ {name}HandlersAPI = &{name}Handlers{}
+var _ {name}API = &{name}{}

sam/templates/http_request.tpl

@@ -0,0 +1,45 @@
+package {package}
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+{foreach $calls as $call}
+// {name} {call.name} request parameters
+type {name}{call.name|ucfirst}Request struct {
+{foreach $call.parameters as $params}
+{foreach $params as $method => $param}
+	{param.name} {param.type}{newline}
+{/foreach}
+{/foreach}
+}
+
+func ({name}{call.name|ucfirst}Request) new() *{name}{call.name|ucfirst}Request {
+	return &{name}{call.name|ucfirst}Request{}
+}
+
+func ({self} *{name}{call.name|ucfirst}Request) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+{foreach $call.parameters as $method => $params}
+{foreach $params as $param}
+{if substr($param.type, 0, 2) !== '[]'}
+	{self}.{param.name} = {if $param.type !== "string"}{$parsers[$param.type]}({method|strtolower}["{param.name}"]){else}{method|strtolower}["{param.name}"]{/if}{newline}
+{/if}
+{/foreach}
+{/foreach}
+	return errors.New("Not implemented: {name}{call.name|ucfirst}Request.Fill")
+}
+
+var _ RequestFiller = {name}{call.name|ucfirst}Request{}.new()
+{/foreach}

sam/templates/http_routes.tpl

@@ -0,0 +1,18 @@
+package {package}
+
+import (
+	"github.com/go-chi/chi"
+)
+
+func MountRoutes(r chi.Router) {
+{foreach $apis as $api}
+	{api.entrypoint|strtolower} := {api.entrypoint|ucfirst}Handlers{}.new()
+{/foreach}
+{foreach $apis as $api}
+	r.Route("{api.path}", func(r chi.Router) {
+{foreach $api.apis as $call}
+		r.{eval echo ucfirst(strtolower($call.method))}("{call.path}", {api.entrypoint|strtolower}.{call.name|ucfirst})
+{/foreach}
+	})
+{/foreach}
+}

sam/templates/http_structs.tpl

@@ -0,0 +1,30 @@
+package {package}
+
+{if strpos($name, "Literal") !== false}
+	{foreach $fields as $field}
+		{field}{newline}
+	{/foreach}
+{else}
+	// {api.title}
+	type {name} struct {
+{foreach $fields as $field}
+		{field.name} {field.type}{if $field.tag} `{$field.tag}`{/if}{newline}
+{/foreach}
+	}
+
+func ({name}) new() *{name} {
+	return &{name}{}
+}
+
+{/if}
+
+{foreach $fields as $field}
+func ({self} *{name}) Get{field.name}() {field.type} {
+	return {self}.{field.name}
+}
+
+func ({self} *{name}) Set{field.name}(value {field.type}) *{name} {
+	{self}.{field.name} = value
+	return {self}
+}
+{/foreach}

sam/user.go

@@ -0,0 +1,12 @@
+package sam
+
+import (
+	"github.com/pkg/errors"
+)
+
+func (u *User) Login(r *UserLoginRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: User.login")
+}
+func (u *User) Search(r *UserSearchRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: User.search")
+}

sam/user.handlers.go

@@ -0,0 +1,16 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+func (uh *UserHandlers) Login(w http.ResponseWriter, r *http.Request) {
+	params := UserLoginRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return uh.User.Login(params) })
+}
+func (uh *UserHandlers) Search(w http.ResponseWriter, r *http.Request) {
+	params := UserSearchRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return uh.User.Search(params) })
+}

sam/user.interfaces.go

@@ -0,0 +1,32 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type UserHandlers struct {
+	*User
+}
+
+func (UserHandlers) new() *UserHandlers {
+	return &UserHandlers{
+		User{}.new(),
+	}
+}
+
+// Internal API interface
+type UserAPI interface {
+	Login(*UserLoginRequest) (interface{}, error)
+	Search(*UserSearchRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type UserHandlersAPI interface {
+	Login(http.ResponseWriter, *http.Request)
+	Search(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ UserHandlersAPI = &UserHandlers{}
+var _ UserAPI = &User{}

sam/user.request.go

@@ -0,0 +1,64 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// User login request parameters
+type UserLoginRequest struct {
+	username string
+	password string
+}
+
+func (UserLoginRequest) new() *UserLoginRequest {
+	return &UserLoginRequest{}
+}
+
+func (u *UserLoginRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	u.username = post["username"]
+
+	u.password = post["password"]
+	return errors.New("Not implemented: UserLoginRequest.Fill")
+}
+
+var _ RequestFiller = UserLoginRequest{}.new()
+
+// User search request parameters
+type UserSearchRequest struct {
+	query string
+}
+
+func (UserSearchRequest) new() *UserSearchRequest {
+	return &UserSearchRequest{}
+}
+
+func (u *UserSearchRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+
+	u.query = get["query"]
+	return errors.New("Not implemented: UserSearchRequest.Fill")
+}
+
+var _ RequestFiller = UserSearchRequest{}.new()

sam/user.structs.go

@@ -0,0 +1,37 @@
+package sam
+
+// Users
+type User struct {
+	ID       uint64
+	Username string
+	Password string `json:"-"`
+}
+
+func (User) new() *User {
+	return &User{}
+}
+
+func (u *User) GetID() uint64 {
+	return u.ID
+}
+
+func (u *User) SetID(value uint64) *User {
+	u.ID = value
+	return u
+}
+func (u *User) GetUsername() string {
+	return u.Username
+}
+
+func (u *User) SetUsername(value string) *User {
+	u.Username = value
+	return u
+}
+func (u *User) GetPassword() string {
+	return u.Password
+}
+
+func (u *User) SetPassword(value string) *User {
+	u.Password = value
+	return u
+}

sam/util.go

@@ -0,0 +1,33 @@
+package sam
+
+import (
+	"strconv"
+)
+
+// parseInt64 parses an string to int64
+func parseInt64(s string) int64 {
+	if s == "" {
+		return 0
+	}
+	i, _ := strconv.ParseInt(s, 10, 64)
+	return i
+}
+
+// parseUInt64 parses an string to uint64
+func parseUInt64(s string) uint64 {
+	if s == "" {
+		return 0
+	}
+	i, _ := strconv.ParseUint(s, 10, 64)
+	return i
+}
+
+// is checks if string s is contained in matches
+func is(s string, matches ...string) bool {
+	for _, v := range matches {
+		if s == v {
+			return true
+		}
+	}
+	return false
+}

sam/websocket.go

@@ -0,0 +1,9 @@
+package sam
+
+import (
+	"github.com/pkg/errors"
+)
+
+func (w *Websocket) Client(r *WebsocketClientRequest) (interface{}, error) {
+	return nil, errors.New("Not implemented: Websocket.client")
+}

sam/websocket.handlers.go

@@ -0,0 +1,12 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/titpetric/factory/resputil"
+)
+
+func (wh *WebsocketHandlers) Client(w http.ResponseWriter, r *http.Request) {
+	params := WebsocketClientRequest{}.new()
+	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return wh.Websocket.Client(params) })
+}

sam/websocket.interfaces.go

@@ -0,0 +1,30 @@
+package sam
+
+import (
+	"net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type WebsocketHandlers struct {
+	*Websocket
+}
+
+func (WebsocketHandlers) new() *WebsocketHandlers {
+	return &WebsocketHandlers{
+		Websocket{}.new(),
+	}
+}
+
+// Internal API interface
+type WebsocketAPI interface {
+	Client(*WebsocketClientRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type WebsocketHandlersAPI interface {
+	Client(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ WebsocketHandlersAPI = &WebsocketHandlers{}
+var _ WebsocketAPI = &Websocket{}

sam/websocket.request.go

@@ -0,0 +1,31 @@
+package sam
+
+import (
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// Websocket client request parameters
+type WebsocketClientRequest struct {
+}
+
+func (WebsocketClientRequest) new() *WebsocketClientRequest {
+	return &WebsocketClientRequest{}
+}
+
+func (w *WebsocketClientRequest) Fill(r *http.Request) error {
+	get := map[string]string{}
+	post := map[string]string{}
+	urlQuery := r.URL.Query()
+	for name, param := range urlQuery {
+		get[name] = string(param[0])
+	}
+	postVars := r.Form
+	for name, param := range postVars {
+		post[name] = string(param[0])
+	}
+	return errors.New("Not implemented: WebsocketClientRequest.Fill")
+}
+
+var _ RequestFiller = WebsocketClientRequest{}.new()

sam/websocket.structs.go

@@ -0,0 +1,28 @@
+package sam
+
+// Websocket
+type Websocket struct {
+	UserID uint64
+	User   User
+}
+
+func (Websocket) new() *Websocket {
+	return &Websocket{}
+}
+
+func (w *Websocket) GetUserID() uint64 {
+	return w.UserID
+}
+
+func (w *Websocket) SetUserID(value uint64) *Websocket {
+	w.UserID = value
+	return w
+}
+func (w *Websocket) GetUser() User {
+	return w.User
+}
+
+func (w *Websocket) SetUser(value User) *Websocket {
+	w.User = value
+	return w
+}