route

Documentation

Index

• Variables
• type APIRequestStructAdd
• type APIRequestStructAuth
• type APIRequestStructCreateToken
• type APIRequestStructCreateUser
• type APIRequestStructMe
• type APIRequestStructNotes
• type APIRequestStructSubscribe
• type APIRequestStructVerifyUser
• type APIResponseStructAccount
• type APIResponseStructNote
• type Configuration
• type Handler
  • func (handler Handler) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type Route
  • func Routes(config Configuration) []Route

Variables

var APIRouteAccount = Route{
	"/account",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructMe
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		_, err = account.GetToken(reqData.Token, data.TokenTypeAccess)
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		account, err = account.Verify()
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		return APIResponseStructAccount{
			account.Address,
			account.Created,
			account.HasSubscription(),
		}, nil
	},
}

APIRouteAccount is

var APIRouteAccountCreate = Route{
	"/account/create",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		var reqData APIRequestStructCreateUser
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account := data.AccountNew(reqData.Address)
		account, err := account.Store()

		if err != nil {
			return nil, errors.New("Unable to create account")
		}

		token := data.TokenNew(account.ID, data.TokenTypeMaintenace)
		tokenRaw := token.Raw()
		token, err = token.Store()

		if err != nil {
			account.Remove()
			return nil, errors.New("Unable to create account")
		}

		_, err = sendTokenWithTemplate(account.Address, tokenRaw, conf.TemplateWelcome)
		if err != nil {
			return nil, errors.New("Unable to send welcome mail")
		}

		if err != nil {
			account.Remove()
			return nil, errors.New("Unable to create account")
		}

		return nil, nil
	},
}

APIRouteAccountCreate is

var APIRouteAccountVerify = Route{
	"/account/verify",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructVerifyUser
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		_, err = account.GetToken(reqData.Token, data.TokenTypeMaintenace)
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		account, err = account.Verify()
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		_, err = sendTokenWithTemplate(account.Address, reqData.Token, conf.TemplateConfirm)
		if err != nil {
			return nil, errors.New("Unable to send verification mail")
		}

		return nil, nil
	},
}

APIRouteAccountVerify is

var APIRouteAdd = Route{
	"/add",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructAdd
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		if !account.Verified {
			return nil, errors.New("Account not verified")
		}

		_, err = account.GetToken(reqData.Token, data.TokenTypeAccess)
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		note := data.NoteNew(account.ID, reqData.Note)
		note, err = note.Store()

		if err != nil {
			return nil, errors.New("Unable to store note")
		}

		return nil, nil
	},
}

APIRouteAdd is

var APIRouteAuth = Route{
	"/auth",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructAuth
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		if !account.Verified {
			return nil, errors.New("Account not verified")
		}

		_, err = account.GetToken(reqData.Token, data.TokenTypeAccess)
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		return nil, nil
	},
}

APIRouteAuth is

var APIRouteNotes = Route{
	"/notes",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructNotes
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		if !account.Verified {
			return nil, errors.New("Account not verified")
		}

		_, err = account.GetToken(reqData.Token, data.TokenTypeAccess)
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		list, err := data.NoteListByAccount(account.ID)
		if err != nil {
			return nil, errors.New("Failed to get notes")
		}

		var noteList []APIResponseStructNote
		for i := 0; i < len(list); i++ {
			noteList = append(noteList, APIResponseStructNote{list[i].Text, list[i].Created})
		}

		return noteList, nil
	},
}

APIRouteNotes is

var APIRouteSubscribe = Route{
	"/subscribe",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructSubscribe
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		if !account.Verified {
			return nil, errors.New("Account not verified")
		}

		_, err = account.GetToken(reqData.Token, data.TokenTypeAccess)
		if err != nil {
			return nil, errors.New("Unable to use provided token")
		}

		stripe.Key = os.Getenv("STRIPE_API_KEY")
		expire := strings.Split(reqData.Expire, "/")
		t, err := stripeToken.New(&stripe.TokenParams{
			Card: &stripe.CardParams{
				Number: reqData.Number,
				Month:  expire[0],
				Year:   expire[1],
				CVC:    reqData.CVC,
			},
		})

		if err != nil {
			return nil, errors.New("Invalid card information")
		}

		customerParams := &stripe.CustomerParams{
			Desc: fmt.Sprintf("%s (#%d)", account.Address, account.ID),
		}
		customerParams.SetSource(t.ID)
		c, err := stripeCustomer.New(customerParams)

		if err != nil {
			return nil, errors.New("Invalid account information")
		}

		s, err := stripeSub.New(&stripe.SubParams{
			Customer: c.ID,
			Plan:     "blue",
		})

		if err != nil {
			return nil, errors.New("Invalid account information")
		}

		subscription := data.SubscriptionNew(account.ID, s.ID)
		subscription, err = subscription.Store()
		subscription, err = subscription.Activate()

		if err != nil {
			return nil, errors.New("Invalid account information")
		}

		return nil, nil
	},
}

APIRouteSubscribe is

var APIRouteTokenCreate = Route{
	"/token/create",
	func(res http.ResponseWriter, req *http.Request) (interface{}, error) {
		// Parse JSON request
		var reqData APIRequestStructCreateToken
		if err := checkJSONBody(req, res, &reqData); err != nil {
			return nil, err
		}

		account, err := data.AccountByAddress(reqData.Address)
		if err != nil {
			return nil, errors.New("Unknown account address")
		}

		if !account.Verified {
			return nil, errors.New("Account not verified")
		}

		token := data.TokenNew(account.ID, data.TokenTypeAccess)
		tokenRaw := token.Raw()
		token, err = token.Store()

		_, err = sendTokenWithTemplate(reqData.Address, tokenRaw, conf.TemplateToken)
		if err != nil {
			token.Remove()
			return nil, errors.New("Unable to create token for account")
		}

		return nil, nil
	},
}

APIRouteTokenCreate is

Types

type APIRequestStructAdd

type APIRequestStructAdd struct {
	Address string `json:"address"`
	Token   string `json:"token"`
	Note    string `json:"note"`
}

APIRequestStructAdd is

type APIRequestStructAuth

type APIRequestStructAuth struct {
	Address string `json:"address"`
	Token   string `json:"token"`
}

APIRequestStructAuth is

type APIRequestStructCreateToken

type APIRequestStructCreateToken struct {
	Address string `json:"address"`
}

APIRequestStructCreateToken is

type APIRequestStructCreateUser

type APIRequestStructCreateUser struct {
	Address string `json:"address"`
}

APIRequestStructCreateUser is

type APIRequestStructMe

type APIRequestStructMe struct {
	Address string `json:"address"`
	Token   string `json:"token"`
}

APIRequestStructMe is

type APIRequestStructNotes

type APIRequestStructNotes struct {
	Address string `json:"address"`
	Token   string `json:"token"`
}

APIRequestStructNotes is

type APIRequestStructSubscribe

type APIRequestStructSubscribe struct {
	Address string `json:"address"`
	Token   string `json:"token"`
	Number  string `json:"number"`
	Expire  string `json:"expire"`
	CVC     string `json:"cvc"`
}

APIRequestStructSubscribe is

type APIRequestStructVerifyUser

type APIRequestStructVerifyUser struct {
	Address string `json:"address"`
	Token   string `json:"token"`
}

APIRequestStructVerifyUser is

type APIResponseStructAccount

type APIResponseStructAccount struct {
	Address      string
	Created      time.Time
	Subscription bool
}

APIResponseStructAccount is

type APIResponseStructNote

type APIResponseStructNote struct {
	Text    string
	Created time.Time
}

APIResponseStructNote is

type Configuration

type Configuration struct {
	TemplateWelcome int64
	TemplateConfirm int64
	TemplateToken   int64

	PostmarkToken   string
	PostmarkFrom    string
	PostmarkReplyTo string
}

Configuration stores need variables

type Handler

type Handler func(http.ResponseWriter, *http.Request) (interface{}, error)

Handler is

func (Handler) ServeHTTP

func (handler Handler) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Route

type Route struct {
	URL     string
	Handler Handler
}

Route is a route

func Routes

func Routes(config Configuration) []Route

Routes returns available routes