added handling of weight (may still need some fine tuning

app/controllers/app.go

package controllers
import (
    "github.com/revolvingcow/grassfed/app/models"
	"github.com/revolvingcow/grassfed/app/models"
)
type Application struct {
    DatabaseController
	DatabaseController
}
func (c Application) Connected() *models.Account {
    if c.RenderArgs["account"] != nil {
        return c.RenderArgs["account"].(*models.Account)
    }
	if c.RenderArgs["account"] != nil {
		return c.RenderArgs["account"].(*models.Account)
	}
    if id, ok := c.Session["account"]; ok {
        return c.getAccount(id)
    }
	if id, ok := c.Session["account"]; ok {
		return c.getAccount(id)
	}
    return nil
	return nil
}
func (c Application) getAccount(id string) *models.Account {
    accounts, err := c.Transaction.Select(models.Account{}, `select * from Account where Profile = ?`, id)
	accounts, err := c.Transaction.Select(models.Account{}, `select * from Account where Profile = ?`, id)
    if err != nil {
        panic(err)
    }
	if err != nil {
		panic(err)
	}
    if len(accounts) == 0 {
        return nil
    }
	if len(accounts) == 0 {
		return nil
	}
    return accounts[0].(*models.Account)
	return accounts[0].(*models.Account)
}

app/controllers/database.go

package controllers
import (
    "database/sql"
    "github.com/coopernurse/gorp"
    _ "github.com/mattn/go-sqlite3"
    "github.com/revel/revel"
    "github.com/revel/revel/modules/db/app"
    "github.com/revolvingcow/grassfed/app/models"
	"database/sql"
	"github.com/coopernurse/gorp"
	_ "github.com/mattn/go-sqlite3"
	"github.com/revel/revel"
	"github.com/revel/revel/modules/db/app"
	"github.com/revolvingcow/grassfed/app/models"
)
// DbMap is the database mapping used throughout the database controller.
var (
    DbMap *gorp.DbMap
	DbMap *gorp.DbMap
)
// Initialize the database and create a database mapping.
func Initialize() {
    db.Init()
    DbMap = &gorp.DbMap{ Db: db.Db, Dialect: gorp.SqliteDialect{} }
	db.Init()
	DbMap = &gorp.DbMap{Db: db.Db, Dialect: gorp.SqliteDialect{}}
    DbMap.AddTable(models.Account{}).SetKeys(true, "Id")
    DbMap.AddTable(models.History{}).SetKeys(true, "Id")
    DbMap.AddTable(models.Goal{}).SetKeys(true, "Id")
    DbMap.AddTable(models.Weight{}).SetKeys(true, "Id")
	DbMap.AddTable(models.Account{}).SetKeys(true, "Id")
	DbMap.AddTable(models.History{}).SetKeys(true, "Id")
	DbMap.AddTable(models.Goal{}).SetKeys(true, "Id")
	DbMap.AddTable(models.Weight{}).SetKeys(true, "Id")
    DbMap.TraceOn("[db]", revel.INFO)
    DbMap.CreateTablesIfNotExists()
	DbMap.TraceOn("[db]", revel.INFO)
	DbMap.CreateTablesIfNotExists()
}
// DatabaseController wraps the Revel controller together with the database Transaction.
type DatabaseController struct {
    *revel.Controller
    Transaction *gorp.Transaction
	*revel.Controller
	Transaction *gorp.Transaction
}
// Begin creates a new transaction to be used.
func (c *DatabaseController) Begin() revel.Result {
    transaction, err := DbMap.Begin()
	transaction, err := DbMap.Begin()
    if err != nil {
        panic(err)
    }
	if err != nil {
		panic(err)
	}
    c.Transaction = transaction
    return nil
	c.Transaction = transaction
	return nil
}
// Commit attempts to finalize all database commands.
func (c *DatabaseController) Commit() revel.Result {
    if c.Transaction == nil {
        return nil
    }
	if c.Transaction == nil {
		return nil
	}
    if err := c.Transaction.Commit(); err != nil && err != sql.ErrTxDone {
        panic(err)
    }
	if err := c.Transaction.Commit(); err != nil && err != sql.ErrTxDone {
		panic(err)
	}
    c.Transaction = nil
    return nil
	c.Transaction = nil
	return nil
}
// Rollback will revert all recent changes returning the database to its original state. 
func (c *DatabaseController) Rollback() revel.Result {
    if c.Transaction == nil {
        return nil
    }
	if c.Transaction == nil {
		return nil
	}
    if err := c.Transaction.Rollback(); err != nil && err != sql.ErrTxDone {
        panic(err)
    }
	if err := c.Transaction.Rollback(); err != nil && err != sql.ErrTxDone {
		panic(err)
	}
    c.Transaction = nil
    return nil
	c.Transaction = nil
	return nil
}

app/controllers/home.go

package controllers
import (
    "github.com/revel/revel"
    "github.com/revolvingcow/grassfed/app/models"
	"github.com/revel/revel"
	"github.com/revolvingcow/grassfed/app/models"
)
type Home struct {
    Application
	Application
}
func (c Home) getNumberOfAccounts() (count int64) {
    count, err := c.Transaction.SelectInt(`select count(*) from Account`)
    if err != nil {
        return 0
    }
	count, err := c.Transaction.SelectInt(`select count(*) from Account`)
	if err != nil {
		return 0
	}
    return count
	return count
}
func (c Home) getNumberOfCalories() (calories int64) {
    calories, err := c.Transaction.SelectInt(`select sum(Calories) from History`)
    if err != nil {
        return 0
    }
	calories, err := c.Transaction.SelectInt(`select sum(Calories) from History`)
	if err != nil {
		return 0
	}
    return calories
	return calories
}
func (c Home) Index() revel.Result {
}
func (c Home) About() revel.Result {
    return c.Render()
	return c.Render()
}
func (c Home) Overview() revel.Result {
    model := models.Overview {
        Accounts: c.getNumberOfAccounts(),
        Calories: c.getNumberOfCalories(),
    }
	model := models.Overview{
		Accounts: c.getNumberOfAccounts(),
		Calories: c.getNumberOfCalories(),
	}
    return c.RenderJson(model)
	return c.RenderJson(model)
}

app/controllers/init.go

import "github.com/revel/revel"
func init() {
    revel.OnAppStart(Initialize)
    revel.InterceptMethod((*DatabaseController).Begin, revel.BEFORE)
    //revel.InterceptMethod((*Profile).Index, revel.BEFORE)
    revel.InterceptMethod((*DatabaseController).Commit, revel.AFTER)
    revel.InterceptMethod((*DatabaseController).Rollback, revel.FINALLY)
	revel.OnAppStart(Initialize)
	revel.InterceptMethod((*DatabaseController).Begin, revel.BEFORE)
	//revel.InterceptMethod((*Profile).Index, revel.BEFORE)
	revel.InterceptMethod((*DatabaseController).Commit, revel.AFTER)
	revel.InterceptMethod((*DatabaseController).Rollback, revel.FINALLY)
}

app/controllers/profile.go

package controllers
import (
    "fmt"
    "strings"
    "time"
    "github.com/revel/revel"
    "github.com/revolvingcow/grassfed/app/models"
	"fmt"
	"github.com/revel/revel"
	"github.com/revolvingcow/grassfed/app/models"
	"strings"
    "strconv"
	"time"
)
type Profile struct {
    Application
	Application
}
func (c Profile) getHistory(account *models.Account) []*models.History {
    if account == nil {
        return nil
    }
    results, err := c.Transaction.Select(
        models.History{},
        `select * from History where AccountId = ? order by Date desc`,
        account.Id)
    if err != nil {
        return nil
    }
const formatSmallDate = "2006-01-02"
func (c Profile) getGoals(account *models.Account, startDate time.Time) []*models.Goal {
	if account == nil {
		return nil
	}
    duration, _ := time.ParseDuration(fmt.Sprintf("%dh", 1*24))
    oneDayAhead := time.Now().Add(duration)
	results, err := c.Transaction.Select(
		models.Goal{},
		`select * from Goal where AccountId = ? and (Date between ? and ?) order by Date desc`,
		account.Id,
        startDate.Format(formatSmallDate),
        oneDayAhead.Format(formatSmallDate))
	if err != nil {
		return nil
	}
	rows := len(results)
	if rows == 0 {
		return nil
	}
	goals := make([]*models.Goal, 0)
	for i := 0; i < rows; i++ {
		goals = append(goals, results[i].(*models.Goal))
	}
	return goals
}
    rows := len(results)
    if rows == 0 {
        return nil
    }
func (c Profile) getDaysIn(month time.Month, year int) int {
    return time.Date(year, month+1, 0, 0, 0, 0, 0, time.UTC).Day()
}
    history := make([]*models.History, rows)
    for i := 0; i < rows; i++ {
        history = append(history, results[i].(*models.History))
    }
func (c Profile) getWeights(account *models.Account, startDate time.Time) []*models.Weight {
	if account == nil {
		return nil
	}
    duration, _ := time.ParseDuration(fmt.Sprintf("%dh", 1*24))
    oneDayAhead := time.Now().Add(duration)
	results, err := c.Transaction.Select(
		models.Weight{},
		`select * from Weight where AccountId = ? and (Date between ? and ?) order by Date desc`,
		account.Id,
        startDate.Format(formatSmallDate),
        oneDayAhead.Format(formatSmallDate))
	if err != nil {
		return nil
	}
	rows := len(results)
	if rows == 0 {
		return nil
	}
	weights := make([]*models.Weight, 0)
	for i := 0; i < rows; i++ {
		weights = append(weights, results[i].(*models.Weight))
	}
	return weights
}
    return history
func (c Profile) getHistory(account *models.Account, startDate time.Time) []*models.History {
	if account == nil {
		return nil
	}
    duration, _ := time.ParseDuration(fmt.Sprintf("%dh", 1*24))
    oneDayAhead := time.Now().Add(duration)
	results, err := c.Transaction.Select(
		models.History{},
		`select * from History where AccountId = ? and (Date between ? and ?) order by Date desc`,
		account.Id,
        startDate.Format(formatSmallDate),
        oneDayAhead.Format(formatSmallDate))
	if err != nil {
		return nil
	}
	rows := len(results)
	if rows == 0 {
		return nil
	}
	history := make([]*models.History, 0)
	for i := 0; i < rows; i++ {
		history = append(history, results[i].(*models.History))
	}
	return history
}
func (c Profile) getGoal(account *models.Account) (goal int64) {
    goal = 2000
func (c Profile) getLatestGoal(account *models.Account) (goal int64) {
	goal = 2000
    if account == nil {
        return goal
    }
	if account == nil {
		return goal
	}
    results := models.Goal{}
    err := c.Transaction.SelectOne(
        &results,
        `select * from Goal where AccountId = ? order by Date desc limit 1`,
        account.Id)
	results := models.Goal{}
	err := c.Transaction.SelectOne(
		&results,
		`select * from Goal where AccountId = ? order by Date desc limit 1`,
		account.Id)
    if err != nil {
        return goal
    }
	if err != nil {
		return goal
	}
    goal = results.Calories
    return goal
	goal = results.Calories
	return goal
}
func (c Profile) setGoal(account *models.Account, calories int64) {
    goals, err := c.Transaction.Select(
        models.Goal{},
        `select * from Goal where AccountId = ? order by Date desc limit 1`,
        account.Id)
    if err != nil {
        revel.INFO.Println(err)
        return
    }
	goals, err := c.Transaction.Select(
		models.Goal{},
		`select * from Goal where AccountId = ? order by Date desc limit 1`,
		account.Id)
	if err != nil {
		revel.INFO.Println(err)
		return
	}
	now := time.Now().Local()
	if len(goals) > 0 {
		goal := goals[0].(*models.Goal)
		local := goal.Date.Local()
		if now.Day() == local.Day() && now.Month() == local.Month() && now.Year() == local.Year() {
			goal.Calories = calories
			c.Transaction.Update(goal)
		} else {
			newGoal := models.Goal{AccountId: account.Id, Calories: calories, Date: now}
			c.Transaction.Insert(&newGoal)
		}
	} else {
		newGoal := models.Goal{AccountId: account.Id, Calories: calories, Date: now}
		c.Transaction.Insert(&newGoal)
	}
}
    now := time.Now().Local()
func (c Profile) getLatestWeight(account *models.Account) (weight float64) {
	weight = 0
    if len(goals) > 0 {
        goal := goals[0].(*models.Goal)
        local := goal.Date.Local()
	if account == nil {
		return weight
	}
        if now.Day() == local.Day() && now.Month() == local.Month() && now.Year() == local.Year() {
            goal.Calories = calories
            c.Transaction.Update(goal)
        } else {
            newGoal := models.Goal{ AccountId: account.Id, Calories: calories, Date: now }
            c.Transaction.Insert(&newGoal)
        }
    } else {
        newGoal := models.Goal{ AccountId: account.Id, Calories: calories, Date: now }
        c.Transaction.Insert(&newGoal)
    }
}
	results := models.Weight{}
	err := c.Transaction.SelectOne(
		&results,
		`select * from Weight where AccountId = ? order by Date desc limit 1`,
		account.Id)
func (c Profile) getCaloriesForDate(history []*models.History, date time.Time) (current int64) {
    current = 0
    if history != nil {
        for _, moment := range history {
            if moment != nil {
                local := moment.Date.Local()
                if local.Day() == date.Day() && local.Month() == date.Month() && local.Year() == date.Year() {
                    current += moment.Calories
                }
            }
        }
    }
	if err != nil {
		return weight
	}
    return current
	weight = results.Weight
	return weight
}
func (c Profile) getStreak(history []*models.History, ceiling int64) (streak int64) {
    now := time.Now()
    streak = 0
    if history != nil && len(history) > 0 {
        interval := 1
        for {
            s := fmt.Sprintf("-%dh", interval * 24)
            duration, _ := time.ParseDuration(s)
            count := c.getCaloriesForDate(history, now.Add(duration))
func (c Profile) setWeight(account *models.Account, weight float64) {
	weights, err := c.Transaction.Select(
		models.Weight{},
		`select * from Weight where AccountId = ? order by Date desc limit 1`,
		account.Id)
	if err != nil {
		revel.INFO.Println(err)
		return
	}
	now := time.Now().Local()
	if len(weights) > 0 {
		w := weights[0].(*models.Weight)
		local := w.Date.Local()
		if now.Day() == local.Day() && now.Month() == local.Month() && now.Year() == local.Year() {
			w.Weight = weight
			c.Transaction.Update(w)
		} else {
			newWeight := models.Weight{AccountId: account.Id, Weight: weight, Date: now}
			c.Transaction.Insert(&newWeight)
		}
	} else {
		newWeight := models.Weight{AccountId: account.Id, Weight: weight, Date: now}
		c.Transaction.Insert(&newWeight)
	}
}
            if count > 0 && ceiling > count {
                streak += 1
                interval += 1
            } else {
                break
            }
        }
    }
func (c Profile) getCaloriesForDate(history []*models.History, date time.Time) (current int64) {
	current = 0
	if history != nil {
		for _, moment := range history {
			if moment != nil {
				local := moment.Date.Local()
				if local.Day() == date.Day() && local.Month() == date.Month() && local.Year() == date.Year() {
					current += moment.Calories
				}
			}
		}
	}
	return current
}
    return streak
func (c Profile) getStreak(history []*models.History, ceiling int64) (streak int64) {
	now := time.Now()
	streak = 0
	if history != nil && len(history) > 0 {
		interval := 1
		for {
			s := fmt.Sprintf("-%dh", interval*24)
			duration, _ := time.ParseDuration(s)
			count := c.getCaloriesForDate(history, now.Add(duration))
			if count > 0 && ceiling > count {
				streak += 1
				interval += 1
			} else {
				break
			}
		}
	}
	return streak
}
func (c Profile) getMoment(id int64) *models.History {
    history, err := c.Transaction.Select(models.History{}, `select * from History where Id = ?`, id)
    if err != nil {
        panic(err)
    }
	history, err := c.Transaction.Select(models.History{}, `select * from History where Id = ?`, id)
	if err != nil {
		panic(err)
	}
    if len(history) == 0 {
        return nil
    }
	if len(history) == 0 {
		return nil
	}
    return history[0].(*models.History)
	return history[0].(*models.History)
}
func (c Profile) Index() revel.Result {
    account := c.Connected()
    return c.Render(account)
	account := c.Connected()
	return c.Render(account)
}
func (c Profile) Logon(id string) revel.Result {
    c.Response.ContentType = "application/json"
    c.Validation.Required(id).Message("You must be logged on.")
    if c.Validation.HasErrors() {
        revel.INFO.Println("Validation errors found.")
        c.Validation.Keep()
        c.FlashParams()
        return c.RenderJson(nil)
    }
    revel.INFO.Println("Setting up the variables for storage.")
    now := time.Now()
    account := c.getAccount(id)
    if account == nil {
        revel.INFO.Println("Creating account.")
        account = &models.Account{}
        account.Profile = id
        account.Created = now
        account.LastVisit = now
        c.Transaction.Insert(account)
    } else {
        revel.INFO.Println("Updating account.")
        account.LastVisit = now
        c.Transaction.Update(account)
    }
    c.Session["account"] = id
    c.Session.SetDefaultExpiration()
    return c.RenderJson(true)
	c.Response.ContentType = "application/json"
	c.Validation.Required(id).Message("You must be logged on.")
	if c.Validation.HasErrors() {
		revel.INFO.Println("Validation errors found.")
		c.Validation.Keep()
		c.FlashParams()
		return c.RenderJson(nil)
	}
	revel.INFO.Println("Setting up the variables for storage.")
	now := time.Now()
	account := c.getAccount(id)
	if account == nil {
		revel.INFO.Println("Creating account.")
		account = &models.Account{}
		account.Profile = id
		account.Created = now
		account.LastVisit = now
		c.Transaction.Insert(account)
	} else {
		revel.INFO.Println("Updating account.")
		account.LastVisit = now
		c.Transaction.Update(account)
	}
	c.Session["account"] = id
	c.Session.SetDefaultExpiration()
	return c.RenderJson(true)
}
func (c Profile) History() revel.Result {
    account := c.Connected()
    if account == nil {
        return c.RenderJson(nil)
    }
    history := c.getHistory(account)
    return c.RenderJson(history)
	account := c.Connected()
	if account == nil {
		return c.RenderJson(nil)
	}
    duration, _ := time.ParseDuration(fmt.Sprintf("-%dh", 8*24))
    sevenDaysAgo := time.Now().Add(duration)
	history := c.getHistory(account, sevenDaysAgo)
	return c.RenderJson(history)
}
func (c Profile) Stats() revel.Result {
	account := c.Connected()
	if account == nil {
		return c.RenderJson(nil)
	}
    duration, _ := time.ParseDuration(fmt.Sprintf("-%dh", 8*24))
    sevenDaysAgo := time.Now().Add(duration)
	goal := c.getLatestGoal(account)
	history := c.getHistory(account, sevenDaysAgo)
	response := models.ResponseStatistics{
		Goal:    goal,
		Current: c.getCaloriesForDate(history, time.Now()),
		Streak:  c.getStreak(history, goal),
	}
	return c.RenderJson(response)
}
func (c Profile) Trends() revel.Result {
    account := c.Connected()
    if account == nil {
        return c.RenderJson(nil)
    }
    goal := c.getGoal(account)
    history := c.getHistory(account)
    now := time.Now()
    duration, _ := time.ParseDuration(fmt.Sprintf("-%dh", 31*24))
    oneMonthAgo := now.Add(duration)
    response := models.ResponseStatistics {
        Goal: goal,
        Current: c.getCaloriesForDate(history, time.Now()),
        Streak: c.getStreak(history, goal),
    labels := make([]int, 0)
    for i := 1; i < c.getDaysIn(now.Month(), now.Year()); i++ {
        labels = append(labels, i)
    }
    return c.RenderJson(response)
}
func (c Profile) Add(product string, calories int64) revel.Result {
    account := c.Connected()
    if account == nil || strings.TrimSpace(product) == "" {
        return c.RenderJson(nil)
    }
    rawGoals := c.getGoals(account, oneMonthAgo)
    rawWeights := c.getWeights(account, oneMonthAgo)
    rawHistory := c.getHistory(account, oneMonthAgo)
    latestGoal := c.getLatestGoal(account)
    latestWeight := float64(0)
    goals := make(map[string]int64, 0)
    weights := make(map[string]float64, 0)
    calories := make(map[string]int64, 0)
    for _, day := range labels {
        dayAsString := strconv.Itoa(day)
        goals[dayAsString] = latestGoal
        weights[dayAsString] = latestWeight
        calories[dayAsString] = 0
        for _, goal := range rawGoals {
            if day == goal.Date.Day() {
                goals[dayAsString] = goal.Calories
            }
        }
    c.Validation.Required(product).Message("You must include a product.")
    c.Validation.Required(calories).Message("You must provide the amount of calories")
        for _, weight := range rawWeights {
            if day == weight.Date.Day() {
                weights[dayAsString] = weight.Weight
                latestWeight = weight.Weight
            }
        }
    if c.Validation.HasErrors() {
        c.Validation.Keep()
        c.FlashParams()
        return c.RenderJson(nil)
        for _, moment := range rawHistory {
            if day == moment.Date.Day() {
                calories[dayAsString] += moment.Calories
            }
        }
    }
    moment := models.History {
        AccountId: account.Id,
        Product: product,
        Calories: calories,
        Date: time.Now(),
    response := models.ResponseTrends{
        Labels:     labels,
        Goals:      goals,
        Weights:    weights,
        History:    calories,
    }
    c.Transaction.Insert(&moment)
    return c.RenderJson(moment)
    return c.RenderJson(response)
}
func (c Profile) Add(product string, calories int64) revel.Result {
	account := c.Connected()
	if account == nil || strings.TrimSpace(product) == "" {
		return c.RenderJson(nil)
	}
	c.Validation.Required(product).Message("You must include a product.")
	c.Validation.Required(calories).Message("You must provide the amount of calories")
	if c.Validation.HasErrors() {
		c.Validation.Keep()
		c.FlashParams()
		return c.RenderJson(nil)
	}
	moment := models.History{
		AccountId: account.Id,
		Product:   product,
		Calories:  calories,
		Date:      time.Now(),
	}
	c.Transaction.Insert(&moment)
	return c.RenderJson(moment)
}
func (c Profile) Delete(id int64) revel.Result {
    account := c.Connected()
    if account == nil {
        return c.RenderJson(nil)
    }
	account := c.Connected()
	if account == nil {
		return c.RenderJson(nil)
	}
	moment := c.getMoment(id)
	if moment == nil {
		return c.RenderJson(nil)
	}
	c.Transaction.Delete(moment)
	return c.RenderJson(true)
}
    moment := c.getMoment(id)
    if moment == nil {
        return c.RenderJson(nil)
    }
    c.Transaction.Delete(moment)
func (c Profile) Goal(calories int64) revel.Result {
	account := c.Connected()
	if account == nil {
		return c.RenderJson(nil)
	}
    return c.RenderJson(true)
	c.setGoal(account, calories)
	return c.RenderJson(true)
}
func (c Profile) Goal(calories int64) revel.Result {
func (c Profile) Weight(weight float64) revel.Result {
    account := c.Connected()
    if account == nil {
        return c.RenderJson(nil)
    }
    c.setGoal(account, calories)
    c.setWeight(account, weight)
    return c.RenderJson(true)
}

app/init.go

package app
import (
    "strings"
    "github.com/revel/revel"
	"github.com/revel/revel"
	"strings"
)
func init() {
	// Filters is the default set of global filters.
	revel.Filters = []revel.Filter{
        ContentTypeFilter,
		ContentTypeFilter,
		revel.PanicFilter,             // Recover from panics and display an error page instead.
		revel.RouterFilter,            // Use the routing table to select the right Action
		revel.FilterConfiguringFilter, // A hook for adding or removing per-Action filters.
// should probably also have a filter for CSRF
// not sure if it can go in the same filter or not
var HeaderFilter = func(c *revel.Controller, fc []revel.Filter) {
    // This was commented out so I could mask the origins with DNS
    //c.Response.Out.Header().Add("X-Frame-Options", "SAMEORIGIN")
	// This was commented out so I could mask the origins with DNS
	//c.Response.Out.Header().Add("X-Frame-Options", "SAMEORIGIN")
    // Add some common security headers
	// Add some common security headers
	c.Response.Out.Header().Add("X-XSS-Protection", "1; mode=block")
	c.Response.Out.Header().Add("X-Content-Type-Options", "nosniff")
}
var ContentTypeFilter = func(c *revel.Controller, fc []revel.Filter) {
    path := c.Request.Request.URL.Path
    formats := []string{"json", "xml"}
    for _, format := range formats {
        if strings.HasSuffix(path, "." + format) {
            trimmed := strings.TrimSuffix(path, "." + format)
            c.Request.Request.URL.Path = trimmed
            c.Request.Request.RequestURI = trimmed
            c.Request.Format = format
            break
        }
    }
    fc[0](c, fc[1:])
	path := c.Request.Request.URL.Path
	formats := []string{"json", "xml"}
	for _, format := range formats {
		if strings.HasSuffix(path, "."+format) {
			trimmed := strings.TrimSuffix(path, "."+format)
			c.Request.Request.URL.Path = trimmed
			c.Request.Request.RequestURI = trimmed
			c.Request.Format = format
			break
		}
	}
	fc[0](c, fc[1:])
}

app/models/account.go

package models
import (
    "time"
	"time"
)
type Account struct {
    Id              int64
    Profile         string
    Created         time.Time
    LastVisit       time.Time
	Id        int64
	Profile   string
	Created   time.Time
	LastVisit time.Time
}

app/models/goal.go

import "time"
type Goal struct {
    Id              int64
    AccountId       int64
    Calories        int64
    Date            time.Time
	Id        int64
	AccountId int64
	Calories  int64
	Date      time.Time
}

app/models/history.go

package models
import (
    "time"
	"time"
)
type History struct {
    Id              int64
    AccountId       int64
    Product         string
    Calories        int64
    Date            time.Time
	Id        int64
	AccountId int64
	Product   string
	Calories  int64
	Date      time.Time
}

app/models/overview.go

package models
type Overview struct {
    Accounts int64
    Calories int64
	Accounts int64
	Calories int64
}

app/models/statistics.go

package models
type ResponseStatistics struct {
    Goal int64
    Current int64
    Streak int64
	Goal    int64
	Current int64
	Streak  int64
    Weight  float64
}

app/models/trends.go

package models
type ResponseTrends struct {
    Labels  []int
    Goals   map[string]int64
    Weights map[string]float64
    History map[string]int64
}

app/models/weight.go

import "time"
type Weight struct {
    Id              int64
    AccountId       int64
    Weight          float64
    Date            time.Time
	Id        int64
	AccountId int64
	Weight    float64
	Date      time.Time
}

app/routes/routes.go

	return revel.MainRouter.Reverse("Profile.Stats", args).Url
}
func (_ tProfile) Trends(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("Profile.Trends", args).Url
}
func (_ tProfile) Add(
		product string,
		calories int64,
	return revel.MainRouter.Reverse("Profile.Goal", args).Url
}
func (_ tProfile) Weight(
		weight float64,
		) string {
	args := make(map[string]string)
	
	revel.Unbind(args, "weight", weight)
	return revel.MainRouter.Reverse("Profile.Weight", args).Url
}

app/tmp/main.go

				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
					149: []string{ 
					273: []string{ 
						"account",
					},
				},
				RenderArgNames: map[int][]string{ 
				},
			},
			&revel.MethodType{
				Name: "Trends",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
				},
			},
			&revel.MethodType{
				Name: "Add",
				Args: []*revel.MethodArg{ 
				RenderArgNames: map[int][]string{ 
				},
			},
			&revel.MethodType{
				Name: "Weight",
				Args: []*revel.MethodArg{ 
					&revel.MethodArg{Name: "weight", Type: reflect.TypeOf((*float64)(nil)) },
				},
				RenderArgNames: map[int][]string{ 
				},
			},
			
		})
	
	revel.DefaultValidationKeys = map[string]map[int]string{ 
		"github.com/revolvingcow/grassfed/app/controllers.Profile.Add": { 
			220: "product",
			221: "calories",
			409: "product",
			410: "calories",
		},
		"github.com/revolvingcow/grassfed/app/controllers.Profile.Logon": { 
			154: "id",
			278: "id",
		},
	}
	revel.TestSuites = []interface{}{ 

app/views/Profile/Index.html

            </div>
        </form>
        <h3>Trending</h3>
        <div class="text-center">
            <canvas id="trendsChart" width="400" height="250"></canvas>
        </div>
        <form id="recordWeight" action="/me/weight" method="post" role="form" class="form-horizontal">
            <div class="form-group">
                <div class="col-xs-offset-2 col-xs-3">
                    <label for="weight" class="form-label">Weight</label>
                </div>
                <div class="col-xs-5">
                    <input name="weight" type="number" min="0" max="1000" step="any" value="" class="col-xs-8 form-control" />
                </div>
            </div>
            <div class="form-group">
                <div class="col-xs-offset-6 col-xs-4">
                    <input type="submit" value="Record" class="form-control btn btn-primary" />
                </div>
            </div>
        </form>
        <h3>Streak</h3>
        <h3 class="streak text-center">0</h3>
        <h3 class="streak-units text-center">days</h3>

conf/app.conf

db.import = github.com/mattn/go-sqlite3
db.driver = sqlite3
#db.spec   = :memory:
db.spec   = grassfed.db
module.static=github.com/revel/revel/modules/static

conf/routes

GET     /me/history                             Profile.History
DELETE  /me/history/:id                         Profile.Delete
GET     /me/stats                               Profile.Stats
GET     /me/trends                              Profile.Trends
POST    /me/add                                 Profile.Add
POST    /me/goal                                Profile.Goal
POST    /me/weight                              Profile.Weight
# Ignore favicon requests
GET     /favicon.ico                            404

public/js/grassfed.js

})(jQuery);
$(function () {
    var chart = $("#goalChart")[0];
    var chart = $('#goalChart')[0];
    var trends = $('#trendsChart')[0];
    var doughnutChart;
    var lineChart;
    var trendData;
    function startEngine() {
        // Pull the information we need first.
        loadStatistics();
        loadTrends();
        loadHistory();
        // Set focus.
                    // Update the chart.
                    var previousCalories = parseInt($('input[name="current"][type="hidden"]').val());
                    $('input[name="current"][type="hidden"]').val(previousCalories + response.Calories);
                    updateChart();
                    updateCalorieChart();
                    loadTrends();
                    // Reset focus.
                    $('input[name="products"][type="text"]').focus();
        return false;
    });
    $('form#recordWeight').on('submit', function (e) {
        e.preventDefault();
        var weight = $('input[name="weight"][type="number"]').val();
        $.post('/me/weight', { 'weight': weight })
            .done(function (response) {
                if (response) {
                    // Reset the values.
                    $('input[name="weight"][type="number"]').val('');
                    loadTrends();
                }
            });
    });
    $(document).on('click', 'button.delete-history', function (e) {
        e.preventDefault();
        var moment = parseInt($(this).parents('div.media').attr('data-moment'));
                // Update our calorie chart.
                $('input[name="current"][type="hidden"]').val(previousCalories - calories);
                updateChart();
                updateCalorieChart();
                loadTrends();
                // Check if there are any more media elements in the panel. If not remove the panel.
                if ($(panel).find('div.media').length == 0) {
        $('span.goal').text(goal);
        // Update the chart.
        updateChart();
        updateCalorieChart();
        loadTrends();
    });
    function prependProduct(id, product, calories) {
                    $('.streak-unit').text('days');
                }
                updateChart();
                updateCalorieChart();
            });
    }
    function loadTrends() {
        $.get('/me/trends')
            .done(function (response) {
                if (response) {
                    goals = [];
                    calories = [];
                    weights = [];
                    for (var i = 0; i < response.Labels.length; i++) {
                        goals.push(response.Goals[i]);
                        calories.push(response.History[i]);
                        weights.push(response.Weights[i]);
                    }
                    updateTrendChart(
                        response.Labels, 
                        goals, 
                        calories, 
                        weights);
                }
            });
    }
            });
    }
    function updateChart() {
    function updateTrendChart(labels, goals, calories, weights) {
        //if (!lineChart) {
            var ctxTrends = trends.getContext("2d");
            lineChart = new Chart(ctxTrends).Line(
                {
                    labels: labels, 
                    datasets: [
                        {
                            label: 'Goal',
                            fillColor: 'rgba(220, 220, 220, 0.2)',
                            strokeColor: 'rgba(220, 220, 220, 1)',
                            pointColor: 'rgba(220, 220, 220, 1)',
                            pointStrokeColor: '#fff',
                            pointHighlightFill: '#fff',
                            pointHighlightStroke: 'rgba(220, 220, 220, 1)',
                            data: goals 
                        },
                        {
                            label: 'Calories',
                            fillColor: 'rgba(196, 46, 42, 0.2)',
                            strokeColor: 'rgba(196, 46, 42, 0.5)',
                            pointColor: 'rgba(220, 220, 220, 1)',
                            pointStrokeColor: '#fff',
                            pointHighlightFill: '#fff',
                            pointHighlightStroke: 'rgba(220, 220, 220, 1)',
                            data: calories 
                        },
                        {
                            label: 'Weight',
                            fillColor: 'rgba(51, 51, 204, 0.2)',
                            strokeColor: 'rgba(51, 51, 204, 0.5)',
                            pointColor: 'rgba(51, 51, 204, 1)',
                            pointStrokeColor: '#fff',
                            pointHighlightFill: '#fff',
                            pointHighlightStroke: 'rgba(220, 220, 220, 1)',
                            data: weights 
                        }
                    ]
                },
                {
                    animateScale: true,
                    pointDot: false
                });
        //}
    };
    function updateCalorieChart() {
        var goal = getDailyCalories();
        var count = getCurrentCalories();
        var goalColor = "#ddd";
        }
        
        if (!doughnutChart) {
            var ctx = chart.getContext("2d");
            doughnutChart = new Chart(ctx).Doughnut(
            var ctxCalories = chart.getContext("2d");
            doughnutChart = new Chart(ctxCalories).Doughnut(
                [
                    {
                        value: count,