route

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
	},
}

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
	},
}

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
	},
}

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
	},
}

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
	},
}

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
	},
}

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
	},
}

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
	},
}